@outputai/cli 0.1.4-dev.0 → 0.1.4

package/dist/services/cost_calculator.spec.js

@@ -1,540 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockReadFileSync = vi.fn();
-const mockExistsSync = vi.fn();
-vi.mock('node:fs', () => ({
-    readFileSync: (...args) => mockReadFileSync(...args),
-    existsSync: (...args) => mockExistsSync(...args)
-}));
-const mockLoad = vi.fn();
-vi.mock('js-yaml', () => ({
-    default: { load: (...args) => mockLoad(...args) }
-}));
-import { extractValue, findLLMCalls, findHTTPCalls, calculateLLMCallCost, identifyService, calculateServiceCost, calculateCost, loadPricingConfig } from '#services/cost_calculator.js';
-const llmTrace = {
-    id: 'test-trace-1',
-    kind: 'workflow',
-    name: 'test_workflow',
-    startedAt: 1700000000000,
-    endedAt: 1700000100000,
-    children: [
-        {
-            id: 'step-1',
-            kind: 'step',
-            name: 'test_workflow#generate_summary',
-            children: [
-                {
-                    id: 'llm-1',
-                    kind: 'llm',
-                    name: 'generate_summary',
-                    input: { loadedPrompt: { config: { model: 'claude-sonnet-4-5' } } },
-                    output: { usage: { inputTokens: 1000, outputTokens: 500 } }
-                }
-            ]
-        },
-        {
-            id: 'step-2',
-            kind: 'step',
-            name: 'test_workflow#analyze_data',
-            children: [
-                {
-                    id: 'llm-2',
-                    kind: 'llm',
-                    name: 'analyze_data',
-                    input: { loadedPrompt: { config: { model: 'claude-haiku-4-5' } } },
-                    output: { usage: { inputTokens: 2000, outputTokens: 1000, cachedInputTokens: 500 } }
-                }
-            ]
-        }
-    ]
-};
-const httpTrace = {
-    id: 'test-trace-2',
-    kind: 'workflow',
-    name: 'test_workflow',
-    startedAt: 1700000000000,
-    endedAt: 1700000100000,
-    children: [
-        {
-            id: 'step-1',
-            kind: 'step',
-            name: 'test_workflow#fetch_content',
-            children: [
-                {
-                    id: 'http-1',
-                    kind: 'http',
-                    name: 'jina_request',
-                    input: { url: 'https://r.jina.ai/https://example.com', method: 'GET' },
-                    output: { status: 200, body: { data: { usage: { tokens: 5000 } } } }
-                }
-            ]
-        },
-        {
-            id: 'step-2',
-            kind: 'step',
-            name: 'test_workflow#search',
-            children: [
-                {
-                    id: 'http-2',
-                    kind: 'http',
-                    name: 'exa_request',
-                    input: { url: 'https://api.exa.ai/research', method: 'GET' },
-                    output: {
-                        status: 200,
-                        body: {
-                            model: 'exa-research',
-                            costDollars: { total: 0.15, numSearches: 1, numPages: 5 }
-                        }
-                    }
-                }
-            ]
-        }
-    ]
-};
-const duplicateTrace = {
-    id: 'test-trace-3',
-    kind: 'workflow',
-    name: 'test_workflow',
-    startedAt: 1700000000000,
-    endedAt: 1700000100000,
-    children: [
-        {
-            id: 'step-1',
-            kind: 'step',
-            name: 'test_workflow#step_one',
-            children: [
-                {
-                    id: 'llm-same-id',
-                    kind: 'llm',
-                    name: 'generate',
-                    input: { loadedPrompt: { config: { model: 'claude-sonnet-4-5' } } },
-                    output: { usage: { inputTokens: 1000, outputTokens: 500 } }
-                }
-            ]
-        },
-        {
-            id: 'child-workflow',
-            kind: 'workflow',
-            name: 'child_workflow',
-            children: [
-                {
-                    id: 'llm-same-id',
-                    kind: 'llm',
-                    name: 'generate',
-                    input: { loadedPrompt: { config: { model: 'claude-sonnet-4-5' } } },
-                    output: { usage: { inputTokens: 1000, outputTokens: 500 } }
-                }
-            ]
-        }
-    ]
-};
-const testConfig = {
-    models: {
-        'claude-sonnet-4-5': { provider: 'anthropic', input: 3.0, output: 15.0, cached_input: 0.30 },
-        'claude-haiku-4-5': { provider: 'anthropic', input: 1.0, output: 5.0, cached_input: 0.10 }
-    },
-    services: {
-        jina: {
-            type: 'token',
-            url_pattern: 'r.jina.ai',
-            usage_path: 'body.data.usage.tokens',
-            per_million: 0.045
-        },
-        exa: {
-            type: 'response_cost',
-            url_pattern: 'api.exa.ai',
-            cost_path: 'output.body.costDollars.total',
-            billable_method: 'POST'
-        }
-    }
-};
-describe('extractValue', () => {
-    it('extracts nested values with dot notation', () => {
-        const obj = { a: { b: { c: 42 } } };
-        expect(extractValue(obj, 'a.b.c')).toBe(42);
-    });
-    it('extracts array values with bracket notation', () => {
-        const obj = { items: [{ name: 'first' }, { name: 'second' }] };
-        expect(extractValue(obj, 'items[0].name')).toBe('first');
-        expect(extractValue(obj, 'items[1].name')).toBe('second');
-    });
-    it('returns undefined for missing paths', () => {
-        const obj = { a: 1 };
-        expect(extractValue(obj, 'b.c.d')).toBeUndefined();
-    });
-    it('handles null/undefined input', () => {
-        expect(extractValue(null, 'a.b')).toBeNull();
-        expect(extractValue(undefined, 'a.b')).toBeUndefined();
-    });
-});
-describe('findLLMCalls', () => {
-    it('finds nested LLM calls', () => {
-        const calls = findLLMCalls(llmTrace);
-        expect(calls).toHaveLength(2);
-    });
-    it('extracts step names correctly', () => {
-        const calls = findLLMCalls(llmTrace);
-        expect(calls[0].stepName).toBe('generate_summary');
-        expect(calls[1].stepName).toBe('analyze_data');
-    });
-    it('extracts model names from loadedPrompt config', () => {
-        const calls = findLLMCalls(llmTrace);
-        expect(calls[0].model).toBe('claude-sonnet-4-5');
-        expect(calls[1].model).toBe('claude-haiku-4-5');
-    });
-    it('extracts token usage', () => {
-        const calls = findLLMCalls(llmTrace);
-        expect(calls[0].usage.inputTokens).toBe(1000);
-        expect(calls[0].usage.outputTokens).toBe(500);
-        expect(calls[1].usage.cachedInputTokens).toBe(500);
-    });
-    it('deduplicates by ID', () => {
-        const calls = findLLMCalls(duplicateTrace);
-        expect(calls).toHaveLength(1);
-    });
-});
-describe('findHTTPCalls', () => {
-    it('finds nested HTTP calls', () => {
-        const calls = findHTTPCalls(httpTrace);
-        expect(calls).toHaveLength(2);
-    });
-    it('extracts URLs and methods', () => {
-        const calls = findHTTPCalls(httpTrace);
-        expect(calls[0].url).toContain('r.jina.ai');
-        expect(calls[0].method).toBe('GET');
-    });
-    it('extracts step names', () => {
-        const calls = findHTTPCalls(httpTrace);
-        expect(calls[0].stepName).toBe('fetch_content');
-        expect(calls[1].stepName).toBe('search');
-    });
-});
-describe('calculateLLMCallCost', () => {
-    it('calculates cost for known model', () => {
-        const usage = { inputTokens: 1000000, outputTokens: 500000 };
-        const modelPricing = { provider: 'anthropic', input: 3.0, output: 15.0 };
-        const { cost } = calculateLLMCallCost(usage, modelPricing);
-        // 1M input * $3/M + 0.5M output * $15/M = $3 + $7.5 = $10.5
-        expect(cost).toBeCloseTo(10.5, 2);
-    });
-    it('includes cached input tokens at reduced rate', () => {
-        const usage = { inputTokens: 1000000, outputTokens: 0, cachedInputTokens: 1000000 };
-        const modelPricing = { provider: 'anthropic', input: 3.0, output: 15.0, cached_input: 0.3 };
-        const { cost } = calculateLLMCallCost(usage, modelPricing);
-        // 1M input * $3/M + 1M cached * $0.3/M = $3 + $0.3 = $3.3
-        expect(cost).toBeCloseTo(3.3, 2);
-    });
-    it('returns zero with warning for unknown model', () => {
-        const usage = { inputTokens: 1000, outputTokens: 500 };
-        const { cost, warning } = calculateLLMCallCost(usage, undefined);
-        expect(cost).toBe(0);
-        expect(warning).toBe('unknown model');
-    });
-});
-describe('identifyService', () => {
-    it('identifies Jina by URL pattern', () => {
-        const call = {
-            stepName: 'test',
-            url: 'https://r.jina.ai/https://example.com',
-            method: 'GET',
-            input: {},
-            output: {}
-        };
-        const result = identifyService(call, testConfig.services);
-        expect(result?.serviceName).toBe('jina');
-    });
-    it('identifies Exa by URL pattern', () => {
-        const call = {
-            stepName: 'test',
-            url: 'https://api.exa.ai/research',
-            method: 'GET',
-            input: {},
-            output: {}
-        };
-        const result = identifyService(call, testConfig.services);
-        expect(result?.serviceName).toBe('exa');
-    });
-    it('returns null for unknown URLs', () => {
-        const call = {
-            stepName: 'test',
-            url: 'https://unknown-api.com/endpoint',
-            method: 'GET',
-            input: {},
-            output: {}
-        };
-        const result = identifyService(call, testConfig.services);
-        expect(result).toBeNull();
-    });
-});
-describe('calculateServiceCost', () => {
-    it('calculates Jina token-based cost', () => {
-        const call = {
-            stepName: 'test',
-            url: 'https://r.jina.ai/https://example.com',
-            method: 'GET',
-            input: {},
-            output: {
-                body: { data: { usage: { tokens: 1000000 } } }
-            }
-        };
-        const serviceInfo = identifyService(call, testConfig.services);
-        const result = calculateServiceCost(call, serviceInfo);
-        // 1M tokens * $0.045/M = $0.045
-        expect(result.cost).toBeCloseTo(0.045, 4);
-    });
-    it('extracts Exa cost from response body', () => {
-        const call = {
-            stepName: 'test',
-            url: 'https://api.exa.ai/research',
-            method: 'GET',
-            input: {},
-            output: {
-                body: {
-                    model: 'exa-research',
-                    costDollars: { total: 0.15, numSearches: 1, numPages: 5 }
-                }
-            }
-        };
-        const serviceInfo = identifyService(call, testConfig.services);
-        const result = calculateServiceCost(call, serviceInfo);
-        expect(result.cost).toBe(0.15);
-        expect(result.usage).toContain('1 searches');
-        expect(result.usage).toContain('5 pages');
-    });
-    it('returns zero cost for Exa response without costDollars', () => {
-        const call = {
-            stepName: 'test',
-            url: 'https://api.exa.ai/research',
-            method: 'GET',
-            input: {},
-            output: {
-                body: { status: 'pending' }
-            }
-        };
-        const serviceInfo = identifyService(call, testConfig.services);
-        const result = calculateServiceCost(call, serviceInfo);
-        expect(result.cost).toBe(0);
-        expect(result.warning).toBe('no cost data');
-    });
-});
-describe('response_cost filtering in calculateCost', () => {
-    it('skips Exa polling requests without cost data', () => {
-        const trace = {
-            kind: 'workflow',
-            name: 'test_workflow',
-            startedAt: 1700000000000,
-            endedAt: 1700000100000,
-            children: [
-                {
-                    id: 'step-exa',
-                    kind: 'step',
-                    name: 'test_workflow#search',
-                    children: [
-                        {
-                            id: 'http-exa-poll',
-                            kind: 'http',
-                            name: 'exa_poll',
-                            input: { url: 'https://api.exa.ai/research/task-123', method: 'GET' },
-                            output: { status: 200, body: { status: 'in_progress' } }
-                        }
-                    ]
-                }
-            ]
-        };
-        const report = calculateCost(trace, testConfig, 'test.json');
-        expect(report.serviceTotalCost).toBe(0);
-        expect(report.services).toHaveLength(0);
-    });
-    it('counts Exa responses that have costDollars', () => {
-        const trace = {
-            kind: 'workflow',
-            name: 'test_workflow',
-            startedAt: 1700000000000,
-            endedAt: 1700000100000,
-            children: [
-                {
-                    id: 'step-exa',
-                    kind: 'step',
-                    name: 'test_workflow#search',
-                    children: [
-                        {
-                            id: 'http-exa-poll',
-                            kind: 'http',
-                            name: 'exa_poll',
-                            input: { url: 'https://api.exa.ai/research/task-123', method: 'GET' },
-                            output: { status: 200, body: { status: 'in_progress' } }
-                        },
-                        {
-                            id: 'http-exa-result',
-                            kind: 'http',
-                            name: 'exa_result',
-                            input: { url: 'https://api.exa.ai/research/task-123', method: 'GET' },
-                            output: {
-                                status: 200,
-                                body: {
-                                    model: 'exa-research',
-                                    costDollars: { total: 0.08, numSearches: 1, numPages: 3 }
-                                }
-                            }
-                        }
-                    ]
-                }
-            ]
-        };
-        const report = calculateCost(trace, testConfig, 'test.json');
-        expect(report.services).toHaveLength(1);
-        expect(report.services[0].calls).toHaveLength(1);
-        expect(report.services[0].totalCost).toBeCloseTo(0.08, 4);
-    });
-});
-describe('calculateCost', () => {
-    it('calculates total cost for LLM trace', () => {
-        const report = calculateCost(llmTrace, testConfig, 'test.json');
-        expect(report.llmCalls).toHaveLength(2);
-        expect(report.workflowName).toBe('test_workflow');
-        expect(report.llmTotalCost).toBeGreaterThan(0);
-        expect(report.totalCost).toBe(report.llmTotalCost + report.serviceTotalCost);
-    });
-    it('calculates total cost for HTTP trace', () => {
-        const report = calculateCost(httpTrace, testConfig, 'test.json');
-        expect(report.services.length).toBeGreaterThan(0);
-        expect(report.serviceTotalCost).toBeGreaterThan(0);
-    });
-    it('calculates duration from timestamps', () => {
-        const report = calculateCost(llmTrace, testConfig, 'test.json');
-        // 1700000100000 - 1700000000000 = 100000ms
-        expect(report.durationMs).toBe(100000);
-    });
-    it('handles deduplication in cost calculation', () => {
-        const report = calculateCost(duplicateTrace, testConfig, 'test.json');
-        expect(report.llmCalls).toHaveLength(1);
-    });
-    it('matches versioned model names by prefix', () => {
-        const trace = {
-            kind: 'workflow',
-            name: 'test',
-            children: [{
-                    id: 'step-1',
-                    kind: 'step',
-                    name: 'test#gen',
-                    children: [{
-                            id: 'llm-1',
-                            kind: 'llm',
-                            name: 'gen',
-                            input: { loadedPrompt: { config: { model: 'claude-sonnet-4-5-20250514' } } },
-                            output: { usage: { inputTokens: 1000, outputTokens: 500 } }
-                        }]
-                }]
-        };
-        const report = calculateCost(trace, testConfig, 'test.json');
-        expect(report.llmTotalCost).toBeGreaterThan(0);
-        expect(report.unknownModels).toHaveLength(0);
-        expect(report.llmCalls[0].warning).toBe('priced as claude-sonnet-4-5');
-    });
-    it('reports unknown model when no prefix match exists', () => {
-        const trace = {
-            kind: 'workflow',
-            name: 'test',
-            children: [{
-                    id: 'step-1',
-                    kind: 'step',
-                    name: 'test#gen',
-                    children: [{
-                            id: 'llm-1',
-                            kind: 'llm',
-                            name: 'gen',
-                            input: { loadedPrompt: { config: { model: 'totally-unknown-model' } } },
-                            output: { usage: { inputTokens: 1000, outputTokens: 500 } }
-                        }]
-                }]
-        };
-        const report = calculateCost(trace, testConfig, 'test.json');
-        expect(report.llmTotalCost).toBe(0);
-        expect(report.unknownModels).toContain('totally-unknown-model');
-        expect(report.llmCalls[0].warning).toBe('unknown model');
-    });
-    it('prefers exact model match over prefix', () => {
-        const trace = {
-            kind: 'workflow',
-            name: 'test',
-            children: [{
-                    id: 'step-1',
-                    kind: 'step',
-                    name: 'test#gen',
-                    children: [{
-                            id: 'llm-1',
-                            kind: 'llm',
-                            name: 'gen',
-                            input: { loadedPrompt: { config: { model: 'claude-sonnet-4-5' } } },
-                            output: { usage: { inputTokens: 1000, outputTokens: 500 } }
-                        }]
-                }]
-        };
-        const report = calculateCost(trace, testConfig, 'test.json');
-        expect(report.llmCalls[0].warning).toBeUndefined();
-    });
-});
-describe('loadPricingConfig', () => {
-    beforeEach(() => {
-        mockReadFileSync.mockReset();
-        mockLoad.mockReset();
-        mockExistsSync.mockReset();
-        mockExistsSync.mockReturnValue(false);
-    });
-    it('loads bundled config when no project config exists', () => {
-        const yamlContent = 'models: {}';
-        const parsed = { models: {}, services: {} };
-        mockReadFileSync.mockReturnValue(yamlContent);
-        mockLoad.mockReturnValue(parsed);
-        const result = loadPricingConfig();
-        expect(mockReadFileSync).toHaveBeenCalledTimes(1);
-        expect(mockLoad).toHaveBeenCalledWith(yamlContent);
-        expect(result).toEqual(parsed);
-    });
-    it('loads config from custom path without merging', () => {
-        const yamlContent = 'models: {}';
-        const parsed = { models: {}, services: {} };
-        mockReadFileSync.mockReturnValue(yamlContent);
-        mockLoad.mockReturnValue(parsed);
-        loadPricingConfig('/custom/path/costs.yml');
-        expect(mockReadFileSync).toHaveBeenCalledWith('/custom/path/costs.yml', 'utf-8');
-        expect(mockExistsSync).not.toHaveBeenCalled();
-    });
-    it('merges project config over bundled config', () => {
-        const bundled = {
-            models: { 'claude-sonnet-4-5': { provider: 'anthropic', input: 3.0, output: 15.0 } },
-            services: { jina: { type: 'token', url_pattern: 'r.jina.ai', per_million: 0.045 } }
-        };
-        const project = {
-            models: { 'custom-model': { provider: 'custom', input: 1.0, output: 2.0 } },
-            services: {}
-        };
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('yaml');
-        mockLoad
-            .mockReturnValueOnce(bundled)
-            .mockReturnValueOnce(project);
-        const result = loadPricingConfig();
-        expect(mockReadFileSync).toHaveBeenCalledTimes(2);
-        expect(result.models).toHaveProperty('claude-sonnet-4-5');
-        expect(result.models).toHaveProperty('custom-model');
-        expect(result.services).toHaveProperty('jina');
-    });
-    it('project config overrides bundled model prices', () => {
-        const bundled = {
-            models: { 'claude-sonnet-4-5': { provider: 'anthropic', input: 3.0, output: 15.0 } },
-            services: {}
-        };
-        const project = {
-            models: { 'claude-sonnet-4-5': { provider: 'anthropic', input: 2.0, output: 10.0 } },
-            services: {}
-        };
-        mockExistsSync.mockReturnValue(true);
-        mockReadFileSync.mockReturnValue('yaml');
-        mockLoad
-            .mockReturnValueOnce(bundled)
-            .mockReturnValueOnce(project);
-        const result = loadPricingConfig();
-        expect(result.models['claude-sonnet-4-5'].input).toBe(2.0);
-        expect(result.models['claude-sonnet-4-5'].output).toBe(10.0);
-    });
-});

package/dist/services/credentials_service.d.ts

@@ -1,12 +0,0 @@
-export type CredentialsEnvironment = string | undefined;
-export type WorkflowTarget = string | undefined;
-export declare const resolveCredentialsPath: (environment: CredentialsEnvironment, workflow?: WorkflowTarget) => string;
-export declare const resolveKeyPath: (environment: CredentialsEnvironment, workflow?: WorkflowTarget) => string;
-export declare const resolveKey: (environment: CredentialsEnvironment, workflow?: WorkflowTarget) => string;
-export declare const credentialsExist: (environment: CredentialsEnvironment, workflow?: WorkflowTarget) => boolean;
-export declare const decryptCredentials: (environment: CredentialsEnvironment, workflow?: WorkflowTarget) => string;
-export declare const writeEncrypted: (environment: CredentialsEnvironment, plaintext: string, workflow?: WorkflowTarget) => void;
-export declare const initCredentials: (environment: CredentialsEnvironment, workflow?: WorkflowTarget) => {
-    keyPath: string;
-    credPath: string;
-};

package/dist/services/credentials_service.integration.test.d.ts

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

package/dist/services/credentials_service.integration.test.js

@@ -1,66 +0,0 @@
-import { describe, it, expect, afterAll } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { load as parseYaml } from 'js-yaml';
-import { encrypt, decrypt, generateKey } from '@outputai/credentials';
-describe('credentials service integration', () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'output-creds-'));
-    afterAll(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    describe('encryption round-trip', () => {
-        it('should generate a valid hex key', () => {
-            const key = generateKey();
-            expect(key).toMatch(/^[0-9a-f]{64}$/);
-        });
-        it('should encrypt and decrypt plaintext', () => {
-            const key = generateKey();
-            const plaintext = 'anthropic:\n  api_key: sk-test-123\n';
-            const ciphertext = encrypt(plaintext, key);
-            const decrypted = decrypt(ciphertext, key);
-            expect(decrypted).toBe(plaintext);
-        });
-        it('should produce different ciphertext for the same plaintext (nonce)', () => {
-            const key = generateKey();
-            const plaintext = 'test: value\n';
-            const a = encrypt(plaintext, key);
-            const b = encrypt(plaintext, key);
-            expect(a).not.toBe(b);
-            expect(decrypt(a, key)).toBe(plaintext);
-            expect(decrypt(b, key)).toBe(plaintext);
-        });
-    });
-    describe('init, decrypt, and re-encrypt workflow', () => {
-        const key = generateKey();
-        const configDir = path.join(tmpDir, 'config');
-        const keyPath = path.join(configDir, 'credentials.key');
-        const credPath = path.join(configDir, 'credentials.yml.enc');
-        const template = 'anthropic:\n  api_key: ""\nopenai:\n  api_key: ""\n';
-        // Set up files once for all tests in this block
-        fs.mkdirSync(configDir, { recursive: true });
-        fs.writeFileSync(keyPath, key, { mode: 0o600 });
-        fs.writeFileSync(credPath, encrypt(template, key), 'utf8');
-        it('should create key and encrypted credentials on disk', () => {
-            expect(fs.existsSync(keyPath)).toBe(true);
-            expect(fs.existsSync(credPath)).toBe(true);
-        });
-        it('should decrypt to valid YAML', () => {
-            const ciphertext = fs.readFileSync(credPath, 'utf8').trim();
-            const plaintext = decrypt(ciphertext, key);
-            const parsed = parseYaml(plaintext);
-            expect(parsed).toHaveProperty('anthropic');
-            expect(parsed).toHaveProperty('openai');
-        });
-        it('should re-encrypt updated credentials and round-trip', () => {
-            const updated = 'anthropic:\n  api_key: sk-new-key-456\nopenai:\n  api_key: sk-openai-789\n';
-            fs.writeFileSync(credPath, encrypt(updated, key), 'utf8');
-            const ciphertext = fs.readFileSync(credPath, 'utf8').trim();
-            const decrypted = decrypt(ciphertext, key);
-            expect(decrypted).toBe(updated);
-            const parsed = parseYaml(decrypted);
-            expect(parsed.anthropic.api_key).toBe('sk-new-key-456');
-            expect(parsed.openai.api_key).toBe('sk-openai-789');
-        });
-    });
-});

package/dist/services/credentials_service.js

@@ -1,64 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { dump as stringifyYaml } from 'js-yaml';
-import { encrypt, decrypt, generateKey, resolveCredentialsPath as resolveCredPath, resolveKeyPath as resolveKPath, resolveKeyEnvVar, resolveWorkflowCredentialsPath, resolveWorkflowKeyPath, resolveWorkflowKeyEnvVar } from '@outputai/credentials';
-const WORKFLOWS_DIR = path.join('src', 'workflows');
-const resolveWorkflowDir = (workflow) => path.resolve(process.cwd(), WORKFLOWS_DIR, workflow);
-export const resolveCredentialsPath = (environment, workflow) => workflow ?
-    resolveWorkflowCredentialsPath(resolveWorkflowDir(workflow)) :
-    resolveCredPath(process.cwd(), environment);
-export const resolveKeyPath = (environment, workflow) => workflow ?
-    resolveWorkflowKeyPath(resolveWorkflowDir(workflow)) :
-    resolveKPath(process.cwd(), environment);
-export const resolveKey = (environment, workflow) => {
-    if (workflow) {
-        const wfEnvVar = resolveWorkflowKeyEnvVar(workflow);
-        if (process.env[wfEnvVar]) {
-            return process.env[wfEnvVar];
-        }
-        const wfKeyPath = resolveKeyPath(undefined, workflow);
-        if (fs.existsSync(wfKeyPath)) {
-            return fs.readFileSync(wfKeyPath, 'utf8').trim();
-        }
-        return resolveKey(undefined);
-    }
-    const envVar = resolveKeyEnvVar(environment);
-    if (process.env[envVar]) {
-        return process.env[envVar];
-    }
-    const keyPath = resolveKeyPath(environment);
-    if (fs.existsSync(keyPath)) {
-        return fs.readFileSync(keyPath, 'utf8').trim();
-    }
-    throw new Error(`No key found. Set ${envVar} env var or create ${keyPath}.`);
-};
-export const credentialsExist = (environment, workflow) => fs.existsSync(resolveCredentialsPath(environment, workflow));
-export const decryptCredentials = (environment, workflow) => {
-    const key = resolveKey(environment, workflow);
-    const credPath = resolveCredentialsPath(environment, workflow);
-    if (!fs.existsSync(credPath)) {
-        throw new Error(`Credentials file not found: ${credPath}`);
-    }
-    const ciphertext = fs.readFileSync(credPath, 'utf8').trim();
-    return decrypt(ciphertext, key);
-};
-export const writeEncrypted = (environment, plaintext, workflow) => {
-    const key = resolveKey(environment, workflow);
-    const credPath = resolveCredentialsPath(environment, workflow);
-    fs.mkdirSync(path.dirname(credPath), { recursive: true });
-    fs.writeFileSync(credPath, encrypt(plaintext, key), 'utf8');
-};
-export const initCredentials = (environment, workflow) => {
-    const credPath = resolveCredentialsPath(environment, workflow);
-    const keyPath = resolveKeyPath(environment, workflow);
-    fs.mkdirSync(path.dirname(keyPath), { recursive: true });
-    fs.mkdirSync(path.dirname(credPath), { recursive: true });
-    const key = generateKey();
-    fs.writeFileSync(keyPath, key, { mode: 0o600 });
-    const template = stringifyYaml({
-        anthropic: { api_key: '' },
-        openai: { api_key: '' }
-    });
-    fs.writeFileSync(credPath, encrypt(template, key), 'utf8');
-    return { keyPath, credPath };
-};

package/dist/services/credentials_service.spec.d.ts

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