@outputai/cli 0.7.1-next.ae5bab4.0 → 0.7.1-next.bd6bd49.0

package/dist/services/npm_update_service.js

@@ -6,6 +6,8 @@ import packageJson from '../../package.json' with { type: 'json' };
 const execFile = promisify(execFileCb);
 const debug = debugFactory('output-cli:npm-update');
 const PACKAGE_NAME = packageJson.name;
+const REGISTRY_URL = 'https://registry.npmjs.org';
+const REGISTRY_TIMEOUT_MS = 5000;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 function findVersionInTree(deps) {
     if (!deps) {
@@ -33,9 +35,15 @@ function parseNpmLsVersion(output) {
 }
 export async function fetchLatestVersion() {
     try {
-        const { stdout } = await execFile('npm', ['view', PACKAGE_NAME, 'version']);
-        const version = stdout.trim();
-        return version || null;
+        const response = await fetch(`${REGISTRY_URL}/${PACKAGE_NAME}/latest`, {
+            signal: AbortSignal.timeout(REGISTRY_TIMEOUT_MS)
+        });
+        if (!response.ok) {
+            debug('Registry responded with status %d', response.status);
+            return null;
+        }
+        const data = await response.json();
+        return data.version || null;
     }
     catch (error) {
         debug('Failed to fetch latest version: %O', error);

package/dist/services/npm_update_service.spec.js

@@ -8,24 +8,37 @@ vi.mock('node:child_process', () => ({
 vi.mock('node:util', () => ({
     promisify: vi.fn(() => mockExecFile)
 }));
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
 describe('npm_update_service', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
     describe('fetchLatestVersion', () => {
-        it('should return version from npm view output', async () => {
-            mockExecFile.mockResolvedValue({ stdout: '1.2.3\n' });
+        it('should return version from the registry response', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: async () => ({ version: '1.2.3' })
+            });
             const result = await fetchLatestVersion();
             expect(result).toBe('1.2.3');
-            expect(mockExecFile).toHaveBeenCalledWith('npm', ['view', '@outputai/cli', 'version']);
+            expect(mockFetch).toHaveBeenCalledWith('https://registry.npmjs.org/@outputai/cli/latest', { signal: expect.any(AbortSignal) });
         });
-        it('should return null on empty output', async () => {
-            mockExecFile.mockResolvedValue({ stdout: '' });
+        it('should return null on non-ok response', async () => {
+            mockFetch.mockResolvedValue({ ok: false, status: 404 });
+            const result = await fetchLatestVersion();
+            expect(result).toBeNull();
+        });
+        it('should return null when response has no version', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: async () => ({})
+            });
             const result = await fetchLatestVersion();
             expect(result).toBeNull();
         });
-        it('should return null on whitespace-only output', async () => {
-            mockExecFile.mockResolvedValue({ stdout: '  \n' });
+        it('should return null on network failure or timeout', async () => {
+            mockFetch.mockRejectedValue(new Error('aborted'));
             const result = await fetchLatestVersion();
             expect(result).toBeNull();
         });

package/dist/services/version_check.d.ts

@@ -3,4 +3,22 @@ export interface VersionCheckResult {
     currentVersion: string;
     latestVersion: string;
 }
-export declare function checkForUpdate(currentVersion: string, cacheDir?: string): Promise<VersionCheckResult>;
+export declare function readCachedResult(currentVersion: string, cacheDir: string): Promise<VersionCheckResult | null>;
+/**
+ * Fetches the latest published version and persists the comparison to the
+ * cache file. Skips the write and returns false when the latest version
+ * can't be determined so the next invocation retries.
+ */
+export declare function refreshVersionCheck(currentVersion: string, cacheDir: string): Promise<boolean>;
+/**
+ * Entry point for the detached refresh helper. Validates the argv contract
+ * (`<currentVersion> <cacheDir>`) and returns the process exit code:
+ * 0 on success, 1 on bad args, 2 when the latest version couldn't be fetched.
+ */
+export declare function runRefresh(argv: string[]): Promise<number>;
+/**
+ * Refreshes the version-check cache in a detached child process so the
+ * registry roundtrip never blocks the invoked command. The result is picked
+ * up from the cache on the next invocation.
+ */
+export declare function spawnBackgroundRefresh(currentVersion: string, cacheDir: string): void;

package/dist/services/version_check.js

@@ -1,9 +1,13 @@
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import debugFactory from 'debug';
 import { fetchLatestVersion, isOutdated } from '#services/npm_update_service.js';
+const debug = debugFactory('output-cli:version-check');
 const CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
 const CACHE_FILENAME = 'version_check.json';
-async function readCache(cacheDir, currentVersion) {
+export async function readCachedResult(currentVersion, cacheDir) {
     try {
         const raw = await readFile(join(cacheDir, CACHE_FILENAME), 'utf-8');
         const cache = JSON.parse(raw);
@@ -15,7 +19,8 @@ async function readCache(cacheDir, currentVersion) {
         }
         return cache.result;
     }
-    catch {
+    catch (error) {
+        debug('Failed to read version cache: %O', error);
         return null;
     }
 }
@@ -25,28 +30,59 @@ async function writeCache(cacheDir, result) {
         const cache = { timestamp: Date.now(), result };
         await writeFile(join(cacheDir, CACHE_FILENAME), JSON.stringify(cache));
     }
-    catch {
-        // Silently ignore cache write failures
+    catch (error) {
+        debug('Failed to write version cache: %O', error);
     }
 }
-export async function checkForUpdate(currentVersion, cacheDir) {
-    if (cacheDir) {
-        const cached = await readCache(cacheDir, currentVersion);
-        if (cached) {
-            return cached;
-        }
-    }
+/**
+ * Fetches the latest published version and persists the comparison to the
+ * cache file. Skips the write and returns false when the latest version
+ * can't be determined so the next invocation retries.
+ */
+export async function refreshVersionCheck(currentVersion, cacheDir) {
     const latestVersion = await fetchLatestVersion();
     if (!latestVersion) {
-        return { updateAvailable: false, currentVersion, latestVersion: currentVersion };
+        debug('Latest version unavailable, skipping cache write');
+        return false;
     }
-    const result = {
+    await writeCache(cacheDir, {
         updateAvailable: isOutdated(currentVersion, latestVersion),
         currentVersion,
         latestVersion
-    };
-    if (cacheDir) {
-        await writeCache(cacheDir, result);
+    });
+    return true;
+}
+/**
+ * Entry point for the detached refresh helper. Validates the argv contract
+ * (`<currentVersion> <cacheDir>`) and returns the process exit code:
+ * 0 on success, 1 on bad args, 2 when the latest version couldn't be fetched.
+ */
+export async function runRefresh(argv) {
+    const [, , currentVersion, cacheDir] = argv;
+    if (!currentVersion || !cacheDir) {
+        console.error('Usage: refresh_version_check.js <currentVersion> <cacheDir>');
+        return 1;
+    }
+    return await refreshVersionCheck(currentVersion, cacheDir) ? 0 : 2;
+}
+/**
+ * Refreshes the version-check cache in a detached child process so the
+ * registry roundtrip never blocks the invoked command. The result is picked
+ * up from the cache on the next invocation.
+ */
+export function spawnBackgroundRefresh(currentVersion, cacheDir) {
+    try {
+        const scriptPath = fileURLToPath(new URL('../scripts/refresh_version_check.js', import.meta.url));
+        // stdio is discarded in normal use; surface the child's output when
+        // debugging is on so refresh failures are diagnosable
+        const stdio = debugFactory.enabled('output-cli:version-check') ? 'inherit' : 'ignore';
+        spawn(process.execPath, [scriptPath, currentVersion, cacheDir], {
+            detached: true,
+            stdio
+        }).unref();
+    }
+    catch (error) {
+        // Best-effort: a failed refresh only delays the update banner
+        debug('Failed to spawn background version refresh: %O', error);
     }
-    return result;
 }

package/dist/services/version_check.spec.js

@@ -1,7 +1,8 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { checkForUpdate } from './version_check.js';
+import { readCachedResult, refreshVersionCheck, runRefresh, spawnBackgroundRefresh } from './version_check.js';
 import { fetchLatestVersion, isOutdated } from '#services/npm_update_service.js';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
 vi.mock('#services/npm_update_service.js', () => ({
     fetchLatestVersion: vi.fn(),
     isOutdated: vi.fn()
@@ -11,96 +12,125 @@ vi.mock('node:fs/promises', () => ({
     writeFile: vi.fn(),
     mkdir: vi.fn()
 }));
+vi.mock('node:child_process', () => ({
+    spawn: vi.fn()
+}));
+const { mockDebugEnabled } = vi.hoisted(() => ({ mockDebugEnabled: vi.fn() }));
+vi.mock('debug', () => ({
+    default: Object.assign(vi.fn(() => vi.fn()), { enabled: mockDebugEnabled })
+}));
 describe('version_check', () => {
+    const cacheDir = '/tmp/test-cache';
     beforeEach(() => {
         vi.clearAllMocks();
+        mockDebugEnabled.mockReturnValue(false);
     });
-    describe('checkForUpdate', () => {
-        it('should return updateAvailable true when outdated', async () => {
-            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
-            vi.mocked(isOutdated).mockReturnValue(true);
-            const result = await checkForUpdate('0.8.4');
-            expect(result).toEqual({
-                updateAvailable: true,
-                currentVersion: '0.8.4',
-                latestVersion: '1.0.0'
-            });
-        });
-        it('should return updateAvailable false when up to date', async () => {
-            vi.mocked(fetchLatestVersion).mockResolvedValue('0.8.4');
-            vi.mocked(isOutdated).mockReturnValue(false);
-            const result = await checkForUpdate('0.8.4');
-            expect(result).toEqual({
-                updateAvailable: false,
-                currentVersion: '0.8.4',
-                latestVersion: '0.8.4'
-            });
-        });
-        it('should return updateAvailable false when fetch fails', async () => {
-            vi.mocked(fetchLatestVersion).mockResolvedValue(null);
-            const result = await checkForUpdate('0.8.4');
-            expect(result.updateAvailable).toBe(false);
-            expect(isOutdated).not.toHaveBeenCalled();
-        });
-    });
-    describe('caching', () => {
-        const cacheDir = '/tmp/test-cache';
+    describe('readCachedResult', () => {
         it('should return cached result when cache is fresh', async () => {
             const cached = {
                 timestamp: Date.now() - 1000,
                 result: { updateAvailable: true, currentVersion: '0.8.4', latestVersion: '1.0.0' }
             };
             vi.mocked(readFile).mockResolvedValue(JSON.stringify(cached));
-            const result = await checkForUpdate('0.8.4', cacheDir);
+            const result = await readCachedResult('0.8.4', cacheDir);
             expect(result).toEqual(cached.result);
-            expect(fetchLatestVersion).not.toHaveBeenCalled();
         });
-        it('should fetch fresh result when cache is expired', async () => {
+        it('should return null when cache is expired', async () => {
             const cached = {
                 timestamp: Date.now() - (5 * 60 * 60 * 1000), // 5 hours ago
                 result: { updateAvailable: true, currentVersion: '0.8.4', latestVersion: '0.9.0' }
             };
             vi.mocked(readFile).mockResolvedValue(JSON.stringify(cached));
-            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
-            vi.mocked(isOutdated).mockReturnValue(true);
-            const result = await checkForUpdate('0.8.4', cacheDir);
-            expect(fetchLatestVersion).toHaveBeenCalled();
-            expect(result.latestVersion).toBe('1.0.0');
+            expect(await readCachedResult('0.8.4', cacheDir)).toBeNull();
         });
-        it('should fetch fresh result when cached version differs from current', async () => {
+        it('should return null when cached version differs from current', async () => {
             const cached = {
                 timestamp: Date.now() - 1000,
                 result: { updateAvailable: true, currentVersion: '0.8.4', latestVersion: '1.0.0' }
             };
             vi.mocked(readFile).mockResolvedValue(JSON.stringify(cached));
-            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
-            vi.mocked(isOutdated).mockReturnValue(true);
-            const result = await checkForUpdate('0.9.0', cacheDir);
-            expect(fetchLatestVersion).toHaveBeenCalled();
-            expect(result.currentVersion).toBe('0.9.0');
+            expect(await readCachedResult('0.9.0', cacheDir)).toBeNull();
         });
-        it('should fetch fresh result when cache file is missing', async () => {
+        it('should return null when cache file is missing', async () => {
             vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
-            vi.mocked(isOutdated).mockReturnValue(true);
-            const result = await checkForUpdate('0.8.4', cacheDir);
-            expect(fetchLatestVersion).toHaveBeenCalled();
-            expect(result.latestVersion).toBe('1.0.0');
+            expect(await readCachedResult('0.8.4', cacheDir)).toBeNull();
         });
-        it('should write cache after fresh fetch', async () => {
-            vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
+        it('should return null when cache file is corrupt', async () => {
+            vi.mocked(readFile).mockResolvedValue('not json');
+            expect(await readCachedResult('0.8.4', cacheDir)).toBeNull();
+        });
+    });
+    describe('refreshVersionCheck', () => {
+        it('should write comparison result to the cache', async () => {
             vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
             vi.mocked(isOutdated).mockReturnValue(true);
-            await checkForUpdate('0.8.4', cacheDir);
+            await expect(refreshVersionCheck('0.8.4', cacheDir)).resolves.toBe(true);
             expect(mkdir).toHaveBeenCalledWith(cacheDir, { recursive: true });
-            expect(writeFile).toHaveBeenCalled();
+            expect(writeFile).toHaveBeenCalledTimes(1);
+            const written = JSON.parse(vi.mocked(writeFile).mock.calls[0][1]);
+            expect(written.result).toEqual({
+                updateAvailable: true,
+                currentVersion: '0.8.4',
+                latestVersion: '1.0.0'
+            });
+            // A missing/invalid timestamp would make the cache immortal (NaN > TTL is false)
+            expect(written.timestamp).toBeCloseTo(Date.now(), -3);
+        });
+        it('should skip the cache write when fetch fails so the next invocation retries', async () => {
+            vi.mocked(fetchLatestVersion).mockResolvedValue(null);
+            await expect(refreshVersionCheck('0.8.4', cacheDir)).resolves.toBe(false);
+            expect(isOutdated).not.toHaveBeenCalled();
+            expect(writeFile).not.toHaveBeenCalled();
         });
-        it('should skip caching when no cacheDir provided', async () => {
+    });
+    describe('runRefresh', () => {
+        it('should refresh the cache from argv in spawn order (script, currentVersion, cacheDir)', async () => {
             vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
             vi.mocked(isOutdated).mockReturnValue(true);
-            await checkForUpdate('0.8.4');
-            expect(readFile).not.toHaveBeenCalled();
+            const exitCode = await runRefresh(['node', 'refresh_version_check.js', '0.8.4', cacheDir]);
+            expect(exitCode).toBe(0);
+            expect(mkdir).toHaveBeenCalledWith(cacheDir, { recursive: true });
+            const written = JSON.parse(vi.mocked(writeFile).mock.calls[0][1]);
+            expect(written.result.currentVersion).toBe('0.8.4');
+            expect(written.result.latestVersion).toBe('1.0.0');
+        });
+        it('should exit with a distinct code when the latest version cannot be fetched', async () => {
+            vi.mocked(fetchLatestVersion).mockResolvedValue(null);
+            const exitCode = await runRefresh(['node', 'refresh_version_check.js', '0.8.4', cacheDir]);
+            expect(exitCode).toBe(2);
+            expect(writeFile).not.toHaveBeenCalled();
+        });
+        it('should exit non-zero with usage on missing args without fetching', async () => {
+            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            const exitCode = await runRefresh(['node', 'refresh_version_check.js']);
+            expect(exitCode).toBe(1);
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Usage:'));
+            expect(fetchLatestVersion).not.toHaveBeenCalled();
             expect(writeFile).not.toHaveBeenCalled();
+            errorSpy.mockRestore();
+        });
+    });
+    describe('spawnBackgroundRefresh', () => {
+        it('should spawn a detached unref-ed helper with version and cache dir args', () => {
+            const unref = vi.fn();
+            vi.mocked(spawn).mockReturnValue({ unref });
+            spawnBackgroundRefresh('0.8.4', cacheDir);
+            expect(spawn).toHaveBeenCalledWith(process.execPath, [expect.stringContaining('refresh_version_check.js'), '0.8.4', cacheDir], { detached: true, stdio: 'ignore' });
+            expect(unref).toHaveBeenCalled();
+        });
+        it('should inherit stdio when the version-check debug namespace is enabled', () => {
+            mockDebugEnabled.mockReturnValue(true);
+            const unref = vi.fn();
+            vi.mocked(spawn).mockReturnValue({ unref });
+            spawnBackgroundRefresh('0.8.4', cacheDir);
+            expect(mockDebugEnabled).toHaveBeenCalledWith('output-cli:version-check');
+            expect(spawn).toHaveBeenCalledWith(process.execPath, expect.any(Array), { detached: true, stdio: 'inherit' });
+        });
+        it('should swallow spawn failures', () => {
+            vi.mocked(spawn).mockImplementation(() => {
+                throw new Error('spawn failure');
+            });
+            expect(() => spawnBackgroundRefresh('0.8.4', cacheDir)).not.toThrow();
         });
     });
 });

package/dist/types/cost.d.ts

@@ -2,6 +2,10 @@
  * Cost Calculator Types
  *
  * TypeScript interfaces for trace parsing, pricing configuration, and cost reports.
+ *
+ * Costs are sourced from the trace events themselves (the as-charged "original"
+ * cost), with `costs.yml` applied as an optional override layer (the "adjusted"
+ * cost). Both figures are surfaced per model and per host.
  */
 export interface TokenUsage {
     inputTokens?: number;
@@ -9,6 +13,25 @@ export interface TokenUsage {
     cachedInputTokens?: number;
     reasoningTokens?: number;
 }
+export type { LLMUsageEvent } from '@outputai/llm';
+import type { LLMUsageEvent } from '@outputai/llm';
+export type LLMUsageLine = LLMUsageEvent['usage'][number];
+export interface HTTPCostEvent {
+    type: 'http:request:cost';
+    url: string;
+    requestId: string;
+    total: number;
+}
+export interface HTTPCountEvent {
+    type: 'http:request:count';
+    url: string;
+    requestId: string;
+}
+export interface NodeAttributes {
+    'llm:usage'?: LLMUsageEvent;
+    'http:request:cost'?: HTTPCostEvent;
+    'http:request:count'?: HTTPCountEvent;
+}
 export interface TraceNode {
     id?: string;
     kind: string;
@@ -17,15 +40,16 @@ export interface TraceNode {
     endedAt?: number;
     children?: TraceNode[];
     input?: Record<string, unknown>;
-    output?: Record<string, unknown> & {
-        usage?: TokenUsage;
-    };
+    output?: Record<string, unknown>;
+    attributes?: NodeAttributes;
 }
 export interface LLMCall {
     stepName: string;
     llmName: string;
     model: string;
     usage: TokenUsage;
+    originalCost: number;
+    lines: LLMUsageLine[];
 }
 export interface HTTPCall {
     stepName: string;
@@ -34,6 +58,8 @@ export interface HTTPCall {
     input: Record<string, unknown>;
     output: Record<string, unknown>;
     status?: number;
+    host: string;
+    originalCost?: number;
 }
 export interface ModelPricing {
     provider: string;
@@ -80,47 +106,60 @@ export interface LLMCostResult {
     output: number;
     cached: number;
     reasoning: number;
-    cost: number;
-    warning?: string;
+    originalCost: number;
+    adjustedCost: number;
 }
 export interface ServiceCostResult {
     step: string;
     cost: number;
     usage: string;
+    kind: 'computed' | 'estimated' | 'failed';
     model?: string;
     endpoint?: string;
     warning?: string;
     details?: Record<string, unknown>;
 }
-export interface ServiceCostSummary {
-    serviceName: string;
-    calls: ServiceCostResult[];
-    totalCost: number;
+export interface HTTPCostResult {
+    step: string;
+    host: string;
+    usage: string;
+    originalCost: number;
+    adjustedCost: number;
+}
+export interface HostCostSummary {
+    host: string;
+    calls: HTTPCostResult[];
+    originalTotalCost: number;
+    adjustedTotalCost: number;
 }
 export interface CostReport {
     traceFile: string;
     workflowName: string;
     durationMs: number | null;
     llmCalls: LLMCostResult[];
-    llmTotalCost: number;
+    llmOriginalCost: number;
+    llmAdjustedCost: number;
     totalInputTokens: number;
     totalOutputTokens: number;
     totalCachedTokens: number;
     totalReasoningTokens: number;
-    unknownModels: string[];
-    services: ServiceCostSummary[];
-    serviceTotalCost: number;
+    httpCosts: HostCostSummary[];
+    httpOriginalCost: number;
+    httpAdjustedCost: number;
+    originalTotalCost: number;
     totalCost: number;
 }
 export interface LLMModelSummary {
     model: string;
     count: number;
-    cost: number;
+    originalCost: number;
+    adjustedCost: number;
 }
-export interface ServiceSummary {
-    serviceName: string;
+export interface HostSummary {
+    host: string;
     callCount: number;
-    cost: number;
+    originalCost: number;
+    adjustedCost: number;
 }
 export interface VerboseFlags {
     hasReasoning: boolean;
@@ -132,18 +171,20 @@ export interface ParsedCostData {
     duration: string;
     llmModels: LLMModelSummary[];
     llmTotalCalls: number;
-    llmTotalCost: number;
-    services: ServiceSummary[];
-    serviceTotalCalls: number;
-    serviceTotalCost: number;
+    llmOriginalCost: number;
+    llmAdjustedCost: number;
+    hosts: HostSummary[];
+    httpTotalCalls: number;
+    httpOriginalCost: number;
+    httpAdjustedCost: number;
     verbose: VerboseFlags;
     llmCalls: LLMCostResult[];
-    serviceDetails: ServiceCostSummary[];
+    httpDetails: HostCostSummary[];
     totalInputTokens: number;
     totalOutputTokens: number;
     totalCachedTokens: number;
     totalReasoningTokens: number;
+    originalTotalCost: number;
     totalCost: number;
-    unknownModels: string[];
     isEmpty: boolean;
 }

package/dist/types/cost.js

@@ -2,5 +2,9 @@
  * Cost Calculator Types
  *
  * TypeScript interfaces for trace parsing, pricing configuration, and cost reports.
+ *
+ * Costs are sourced from the trace events themselves (the as-charged "original"
+ * cost), with `costs.yml` applied as an optional override layer (the "adjusted"
+ * cost). Both figures are surfaced per model and per host.
  */
 export {};