@outputai/cli 0.1.3-dev.0 → 0.1.3

package/dist/services/credentials_service.spec.js

@@ -1,106 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import path from 'node:path';
-vi.mock('node:fs', () => ({
-    default: {
-        existsSync: vi.fn(),
-        readFileSync: vi.fn(),
-        writeFileSync: vi.fn(),
-        mkdirSync: vi.fn()
-    }
-}));
-vi.mock('@outputai/credentials', async (importOriginal) => ({
-    ...(await importOriginal()),
-    encrypt: vi.fn((plaintext) => `encrypted:${plaintext}`),
-    decrypt: vi.fn((ciphertext) => ciphertext.replace('encrypted:', '')),
-    generateKey: vi.fn(() => 'a'.repeat(64))
-}));
-import { resolveCredentialsPath, resolveKeyPath, credentialsExist, resolveKey, decryptCredentials, initCredentials } from './credentials_service.js';
-import fs from 'node:fs';
-describe('credentials service', () => {
-    const cwd = process.cwd();
-    beforeEach(() => {
-        vi.clearAllMocks();
-        delete process.env.OUTPUT_CREDENTIALS_KEY;
-        delete process.env.OUTPUT_CREDENTIALS_KEY_PRODUCTION;
-    });
-    afterEach(() => {
-        delete process.env.OUTPUT_CREDENTIALS_KEY;
-        delete process.env.OUTPUT_CREDENTIALS_KEY_PRODUCTION;
-    });
-    describe('resolveCredentialsPath', () => {
-        it('should resolve default path when no environment', () => {
-            const result = resolveCredentialsPath(undefined);
-            expect(result).toBe(path.resolve(cwd, 'config', 'credentials.yml.enc'));
-        });
-        it('should resolve environment-specific path', () => {
-            const result = resolveCredentialsPath('production');
-            expect(result).toBe(path.resolve(cwd, 'config', 'credentials', 'production.yml.enc'));
-        });
-    });
-    describe('resolveKeyPath', () => {
-        it('should resolve default key path', () => {
-            const result = resolveKeyPath(undefined);
-            expect(result).toBe(path.resolve(cwd, 'config', 'credentials.key'));
-        });
-        it('should resolve environment-specific key path', () => {
-            const result = resolveKeyPath('staging');
-            expect(result).toBe(path.resolve(cwd, 'config', 'credentials', 'staging.key'));
-        });
-    });
-    describe('credentialsExist', () => {
-        it('should return true when credentials file exists', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            expect(credentialsExist(undefined)).toBe(true);
-        });
-        it('should return false when credentials file does not exist', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(false);
-            expect(credentialsExist(undefined)).toBe(false);
-        });
-    });
-    describe('resolveKey', () => {
-        it('should return key from env var', () => {
-            process.env.OUTPUT_CREDENTIALS_KEY = 'env-key';
-            expect(resolveKey(undefined)).toBe('env-key');
-        });
-        it('should return environment-specific key from env var', () => {
-            process.env.OUTPUT_CREDENTIALS_KEY_PRODUCTION = 'prod-key';
-            expect(resolveKey('production')).toBe('prod-key');
-        });
-        it('should fall back to key file', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.readFileSync).mockReturnValue('file-key\n');
-            expect(resolveKey(undefined)).toBe('file-key');
-        });
-        it('should throw when no key source is available', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(false);
-            expect(() => resolveKey(undefined)).toThrow('No key found');
-        });
-    });
-    describe('decryptCredentials', () => {
-        it('should decrypt credentials file', () => {
-            process.env.OUTPUT_CREDENTIALS_KEY = 'test-key';
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.readFileSync).mockReturnValue('encrypted:hello');
-            expect(decryptCredentials(undefined)).toBe('hello');
-        });
-        it('should throw when credentials file does not exist', () => {
-            process.env.OUTPUT_CREDENTIALS_KEY = 'test-key';
-            vi.mocked(fs.existsSync).mockReturnValue(false);
-            expect(() => decryptCredentials(undefined)).toThrow('Credentials file not found');
-        });
-    });
-    describe('initCredentials', () => {
-        it('should create key file and encrypted credentials file', () => {
-            const result = initCredentials(undefined);
-            expect(fs.mkdirSync).toHaveBeenCalled();
-            expect(fs.writeFileSync).toHaveBeenCalledTimes(2);
-            expect(result.keyPath).toContain('credentials.key');
-            expect(result.credPath).toContain('credentials.yml.enc');
-        });
-        it('should create environment-specific files', () => {
-            const result = initCredentials('production');
-            expect(result.keyPath).toContain(path.join('credentials', 'production.key'));
-            expect(result.credPath).toContain(path.join('credentials', 'production.yml.enc'));
-        });
-    });
-});

package/dist/services/datasets.d.ts

@@ -1,20 +0,0 @@
-import type { Dataset } from '@outputai/evals';
-export interface DatasetInfo {
-    name: string;
-    path: string;
-    hasLastOutput: boolean;
-    lastOutputDate?: string;
-    lastEvalDate?: string;
-}
-export declare function resolveDatasetsDir(workflowName: string, basePath?: string): string | null;
-export declare function resolveDefaultDatasetsDir(workflowName: string, basePath?: string): string;
-export declare function readDataset(filePath: string): Promise<Dataset>;
-export declare function readAllDatasets(workflowName: string, filterNames?: string[], basePath?: string): Promise<{
-    datasets: Dataset[];
-    dir: string;
-}>;
-export declare function writeDataset(dataset: Dataset, filePath: string): Promise<void>;
-export declare function listDatasets(workflowName: string, basePath?: string): Promise<DatasetInfo[]>;
-export declare function buildDataset(name: string, input: Record<string, unknown>, output: unknown, executionTimeMs?: number): Dataset;
-export declare function extractDatasetName(tracePathOrKey: string): string;
-export declare function getExecutionTime(workflowId: string | undefined): Promise<number | undefined>;

package/dist/services/datasets.js

@@ -1,132 +0,0 @@
-import { readFile, writeFile, readdir, mkdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { resolve, join } from 'node:path';
-import yaml from 'js-yaml';
-import { DatasetSchema } from '@outputai/evals';
-import { getTrace } from '#services/trace_reader.js';
-import { sanitizeSecrets } from '#utils/secret_sanitizer.js';
-const DATASETS_DIR = 'tests/datasets';
-const WORKFLOWS_PATHS = ['src/workflows', 'workflows'];
-export function resolveDatasetsDir(workflowName, basePath = process.cwd()) {
-    for (const workflowsDir of WORKFLOWS_PATHS) {
-        const candidate = resolve(basePath, workflowsDir, workflowName, DATASETS_DIR);
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-export function resolveDefaultDatasetsDir(workflowName, basePath = process.cwd()) {
-    const existing = resolveDatasetsDir(workflowName, basePath);
-    if (existing) {
-        return existing;
-    }
-    // Default to first workflows path
-    return resolve(basePath, WORKFLOWS_PATHS[0], workflowName, DATASETS_DIR);
-}
-export async function readDataset(filePath) {
-    const content = await readFile(filePath, 'utf-8');
-    const raw = yaml.load(content);
-    return DatasetSchema.parse(raw);
-}
-export async function readAllDatasets(workflowName, filterNames, basePath) {
-    const dir = resolveDatasetsDir(workflowName, basePath);
-    if (!dir) {
-        return { datasets: [], dir: resolveDefaultDatasetsDir(workflowName, basePath) };
-    }
-    const files = await readdir(dir);
-    const ymlFiles = files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
-    const datasets = [];
-    for (const file of ymlFiles) {
-        const dataset = await readDataset(join(dir, file));
-        if (filterNames && !filterNames.includes(dataset.name)) {
-            continue;
-        }
-        datasets.push(dataset);
-    }
-    return { datasets, dir };
-}
-async function mergeWithExisting(dataset, filePath) {
-    if (!existsSync(filePath)) {
-        return dataset;
-    }
-    try {
-        const existing = await readDataset(filePath);
-        return {
-            ...existing,
-            ...dataset,
-            ground_truth: dataset.ground_truth ?? existing.ground_truth,
-            last_output: dataset.last_output ?? existing.last_output,
-            last_eval: dataset.last_eval ?? existing.last_eval
-        };
-    }
-    catch {
-        return dataset;
-    }
-}
-export async function writeDataset(dataset, filePath) {
-    const merged = await mergeWithExisting(dataset, filePath);
-    const dir = resolve(filePath, '..');
-    if (!existsSync(dir)) {
-        await mkdir(dir, { recursive: true });
-    }
-    const content = yaml.dump(merged, { lineWidth: 120, noRefs: true, sortKeys: false });
-    await writeFile(filePath, content, 'utf-8');
-}
-export async function listDatasets(workflowName, basePath) {
-    const dir = resolveDatasetsDir(workflowName, basePath);
-    if (!dir) {
-        return [];
-    }
-    const files = await readdir(dir);
-    const ymlFiles = files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
-    const results = [];
-    for (const file of ymlFiles) {
-        const filePath = join(dir, file);
-        try {
-            const dataset = await readDataset(filePath);
-            results.push({
-                name: dataset.name,
-                path: filePath,
-                hasLastOutput: dataset.last_output?.output !== undefined,
-                lastOutputDate: dataset.last_output?.date,
-                lastEvalDate: dataset.last_eval?.date
-            });
-        }
-        catch {
-            results.push({
-                name: file.replace(/\.(yml|yaml)$/, ''),
-                path: filePath,
-                hasLastOutput: false
-            });
-        }
-    }
-    return results;
-}
-export function buildDataset(name, input, output, executionTimeMs) {
-    return {
-        name,
-        input: sanitizeSecrets(input),
-        last_output: {
-            output: sanitizeSecrets(output),
-            executionTimeMs,
-            date: new Date().toISOString()
-        }
-    };
-}
-export function extractDatasetName(tracePathOrKey) {
-    return tracePathOrKey.replace(/^.*\//, '').replace(/\.json$/, '');
-}
-export function getExecutionTime(workflowId) {
-    if (!workflowId) {
-        return Promise.resolve(undefined);
-    }
-    return getTrace(workflowId)
-        .then(traceResult => {
-        const root = traceResult.data.root;
-        return (root.startTime && root.endTime) ?
-            root.endTime - root.startTime :
-            root.duration;
-    })
-        .catch(() => undefined);
-}

package/dist/services/docker.d.ts

@@ -1,39 +0,0 @@
-import { type ChildProcess } from 'node:child_process';
-export declare const SERVICE_HEALTH: {
-    readonly HEALTHY: "healthy";
-    readonly UNHEALTHY: "unhealthy";
-    readonly STARTING: "starting";
-    readonly NONE: "none";
-};
-export declare const SERVICE_STATE: {
-    readonly RUNNING: "running";
-    readonly EXITED: "exited";
-};
-declare class DockerValidationError extends Error {
-}
-export interface ServiceStatus {
-    name: string;
-    state: string;
-    health: string;
-    ports: string[];
-}
-export declare class DockerComposeConfigNotFoundError extends Error {
-    constructor(dockerComposePath: string);
-}
-declare const isDockerInstalled: () => boolean;
-declare const isDockerComposeAvailable: () => boolean;
-declare const isDockerDaemonRunning: () => boolean;
-export declare function validateDockerEnvironment(): void;
-export declare function getDefaultDockerComposePath(): string;
-export declare function parseServiceStatus(jsonOutput: string): ServiceStatus[];
-export declare function getServiceStatus(dockerComposePath: string): Promise<ServiceStatus[]>;
-export declare function waitForServicesHealthy(dockerComposePath: string, timeoutMs?: number, pollIntervalMs?: number): Promise<void>;
-export interface DockerComposeProcess {
-    process: ChildProcess;
-    waitForHealthy: () => Promise<void>;
-}
-export type PullPolicy = 'always' | 'missing' | 'never';
-export declare function startDockerCompose(dockerComposePath: string, pullPolicy?: PullPolicy): Promise<DockerComposeProcess>;
-export declare function startDockerComposeDetached(dockerComposePath: string, pullPolicy?: PullPolicy): void;
-export declare function stopDockerCompose(dockerComposePath: string): Promise<void>;
-export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };

package/dist/services/docker.js

@@ -1,160 +0,0 @@
-import { execFileSync, execSync, spawn } from 'node:child_process';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { ux } from '@oclif/core';
-import logUpdate from 'log-update';
-const DEFAULT_COMPOSE_PATH = '../assets/docker/docker-compose-dev.yml';
-export const SERVICE_HEALTH = {
-    HEALTHY: 'healthy',
-    UNHEALTHY: 'unhealthy',
-    STARTING: 'starting',
-    NONE: 'none'
-};
-export const SERVICE_STATE = {
-    RUNNING: 'running',
-    EXITED: 'exited'
-};
-class DockerValidationError extends Error {
-}
-export class DockerComposeConfigNotFoundError extends Error {
-    constructor(dockerComposePath) {
-        super(`Docker Compose configuration not found at: ${dockerComposePath}\n\
-This may indicate a problem with the CLI installation.`);
-    }
-}
-const checkDockerCommand = (command) => {
-    try {
-        execSync(command, { stdio: 'pipe' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-const isDockerInstalled = () => checkDockerCommand('docker --version');
-const isDockerComposeAvailable = () => checkDockerCommand('docker compose version');
-const isDockerDaemonRunning = () => checkDockerCommand('docker ps');
-const DOCKER_VALIDATIONS = [
-    {
-        check: isDockerInstalled,
-        error: 'Docker is not installed. Please install Docker to use the dev command.\nVisit: https://docs.docker.com/get-docker/'
-    },
-    {
-        check: isDockerComposeAvailable,
-        error: 'Docker Compose is not installed. Please install Docker Compose to use the dev command.\nVisit: https://docs.docker.com/compose/install/'
-    },
-    {
-        check: isDockerDaemonRunning,
-        error: 'Docker daemon is not running. Please start Docker and try again.'
-    }
-];
-export function validateDockerEnvironment() {
-    const failedValidation = DOCKER_VALIDATIONS.find(v => !v.check());
-    if (failedValidation) {
-        throw new DockerValidationError(failedValidation.error);
-    }
-}
-export function getDefaultDockerComposePath() {
-    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), DEFAULT_COMPOSE_PATH);
-}
-export function parseServiceStatus(jsonOutput) {
-    if (!jsonOutput.trim()) {
-        return [];
-    }
-    return jsonOutput
-        .trim()
-        .split('\n')
-        .filter(Boolean)
-        .map(line => {
-        const data = JSON.parse(line);
-        return {
-            name: data.Service || data.Name || 'unknown',
-            state: data.State,
-            health: data.Health || SERVICE_HEALTH.NONE,
-            ports: data.Publishers?.map(p => `${p.PublishedPort}:${p.TargetPort}`) || []
-        };
-    });
-}
-export async function getServiceStatus(dockerComposePath) {
-    const result = execFileSync('docker', ['compose', '-f', dockerComposePath, 'ps', '--all', '--format', 'json'], { encoding: 'utf-8', cwd: process.cwd() });
-    return parseServiceStatus(result);
-}
-const STATUS_ICONS = {
-    [SERVICE_HEALTH.HEALTHY]: '✓',
-    [SERVICE_HEALTH.UNHEALTHY]: '✗',
-    [SERVICE_HEALTH.STARTING]: '◐',
-    [SERVICE_HEALTH.NONE]: '✓',
-    [SERVICE_STATE.RUNNING]: '●',
-    [SERVICE_STATE.EXITED]: '✗'
-};
-const STATUS_COLORS = {
-    [SERVICE_HEALTH.HEALTHY]: '\x1b[32m',
-    [SERVICE_HEALTH.UNHEALTHY]: '\x1b[31m',
-    [SERVICE_HEALTH.STARTING]: '\x1b[33m',
-    [SERVICE_HEALTH.NONE]: '\x1b[32m',
-    [SERVICE_STATE.RUNNING]: '\x1b[34m',
-    [SERVICE_STATE.EXITED]: '\x1b[31m'
-};
-const ANSI_RESET = '\x1b[0m';
-const formatServiceStatus = (services) => services.map(s => {
-    const healthKey = s.health === SERVICE_HEALTH.NONE ? s.state : s.health;
-    const icon = STATUS_ICONS[healthKey] || '?';
-    const color = STATUS_COLORS[healthKey] || '';
-    const status = s.health === SERVICE_HEALTH.NONE ? s.state : s.health;
-    return `  ${color}${icon}${ANSI_RESET} ${s.name}: ${status}`;
-}).join('\n');
-export async function waitForServicesHealthy(dockerComposePath, timeoutMs = 120000, pollIntervalMs = 2000) {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-        const services = await getServiceStatus(dockerComposePath);
-        const allHealthy = services.every(s => s.health === SERVICE_HEALTH.HEALTHY || s.health === SERVICE_HEALTH.NONE);
-        if (services.length > 0) {
-            const statusLines = formatServiceStatus(services);
-            logUpdate(`⏳ Waiting for services to become healthy...\n${statusLines}`);
-        }
-        if (allHealthy && services.length > 0) {
-            logUpdate.done();
-            return;
-        }
-        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
-    }
-    logUpdate.done();
-    throw new Error('Timeout waiting for services to become healthy');
-}
-export async function startDockerCompose(dockerComposePath, pullPolicy) {
-    const args = [
-        'compose',
-        '-f', dockerComposePath,
-        '--project-directory', process.cwd(),
-        'up'
-    ];
-    if (pullPolicy) {
-        args.push('--pull', pullPolicy);
-    }
-    ux.stdout('🐳 Starting Docker services...\n');
-    const dockerProcess = spawn('docker', args, {
-        cwd: process.cwd(),
-        stdio: ['ignore', 'pipe', 'pipe']
-    });
-    return {
-        process: dockerProcess,
-        waitForHealthy: () => waitForServicesHealthy(dockerComposePath)
-    };
-}
-export function startDockerComposeDetached(dockerComposePath, pullPolicy) {
-    const args = [
-        'compose',
-        '-f', dockerComposePath,
-        '--project-directory', process.cwd(),
-        'up', '-d'
-    ];
-    if (pullPolicy) {
-        args.push('--pull', pullPolicy);
-    }
-    execFileSync('docker', args, { stdio: 'inherit', cwd: process.cwd() });
-}
-export async function stopDockerCompose(dockerComposePath) {
-    ux.stdout('⏹️  Stopping services...\n');
-    execFileSync('docker', ['compose', '-f', dockerComposePath, 'down'], { stdio: 'inherit', cwd: process.cwd() });
-}
-export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };

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

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

package/dist/services/docker.spec.js

@@ -1,124 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { execFileSync } from 'node:child_process';
-import { parseServiceStatus, getServiceStatus, waitForServicesHealthy } from './docker.js';
-vi.mock('node:child_process', () => ({
-    execSync: vi.fn(),
-    execFileSync: vi.fn(),
-    spawn: vi.fn()
-}));
-vi.mock('log-update', () => {
-    const fn = vi.fn();
-    fn.done = vi.fn();
-    return { default: fn };
-});
-describe('docker service', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    describe('parseServiceStatus', () => {
-        it('should parse single service JSON output', () => {
-            const jsonOutput = '{"Service":"redis","State":"running","Health":"healthy","Publishers":[{"PublishedPort":6379,"TargetPort":6379}]}';
-            const result = parseServiceStatus(jsonOutput);
-            expect(result).toHaveLength(1);
-            expect(result[0]).toEqual({
-                name: 'redis',
-                state: 'running',
-                health: 'healthy',
-                ports: ['6379:6379']
-            });
-        });
-        it('should parse multiple services from JSON lines output', () => {
-            const jsonOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[{"PublishedPort":6379,"TargetPort":6379}]}
-{"Service":"temporal","State":"running","Health":"healthy","Publishers":[{"PublishedPort":7233,"TargetPort":7233}]}
-{"Service":"temporal-ui","State":"running","Health":"","Publishers":[{"PublishedPort":8080,"TargetPort":8080}]}`;
-            const result = parseServiceStatus(jsonOutput);
-            expect(result).toHaveLength(3);
-            expect(result[0].name).toBe('redis');
-            expect(result[1].name).toBe('temporal');
-            expect(result[2].name).toBe('temporal-ui');
-        });
-        it('should handle empty health status', () => {
-            const jsonOutput = '{"Service":"api","State":"running","Health":"","Publishers":[]}';
-            const result = parseServiceStatus(jsonOutput);
-            expect(result[0].health).toBe('none');
-        });
-        it('should handle missing Publishers array', () => {
-            const jsonOutput = '{"Service":"worker","State":"running","Health":"healthy"}';
-            const result = parseServiceStatus(jsonOutput);
-            expect(result[0].ports).toEqual([]);
-        });
-        it('should handle empty output', () => {
-            const result = parseServiceStatus('');
-            expect(result).toEqual([]);
-        });
-        it('should filter out empty lines', () => {
-            const jsonOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
-
-{"Service":"api","State":"running","Health":"","Publishers":[]}
-`;
-            const result = parseServiceStatus(jsonOutput);
-            expect(result).toHaveLength(2);
-        });
-        it('should use Name field as fallback when Service is missing', () => {
-            const jsonOutput = '{"Name":"output-sdk-redis-1","State":"running","Health":"healthy","Publishers":[]}';
-            const result = parseServiceStatus(jsonOutput);
-            expect(result[0].name).toBe('output-sdk-redis-1');
-        });
-    });
-    describe('getServiceStatus', () => {
-        it('should call docker compose ps with correct arguments', async () => {
-            const mockOutput = '{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}';
-            vi.mocked(execFileSync).mockReturnValue(mockOutput);
-            await getServiceStatus('/path/to/docker-compose.yml');
-            expect(execFileSync).toHaveBeenCalledWith('docker', ['compose', '-f', '/path/to/docker-compose.yml', 'ps', '--all', '--format', 'json'], expect.objectContaining({ encoding: 'utf-8' }));
-        });
-        it('should return parsed service status', async () => {
-            const mockOutput = '{"Service":"redis","State":"running","Health":"healthy","Publishers":[{"PublishedPort":6379,"TargetPort":6379}]}';
-            vi.mocked(execFileSync).mockReturnValue(mockOutput);
-            const result = await getServiceStatus('/path/to/docker-compose.yml');
-            expect(result).toHaveLength(1);
-            expect(result[0].name).toBe('redis');
-        });
-        it('should throw error when docker compose command fails', async () => {
-            vi.mocked(execFileSync).mockImplementation(() => {
-                throw new Error('Docker command failed');
-            });
-            await expect(getServiceStatus('/path/to/docker-compose.yml')).rejects.toThrow();
-        });
-    });
-    describe('waitForServicesHealthy', () => {
-        it('should resolve when all services are healthy', async () => {
-            const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
-{"Service":"temporal","State":"running","Health":"healthy","Publishers":[]}`;
-            vi.mocked(execFileSync).mockReturnValue(mockOutput);
-            await expect(waitForServicesHealthy('/path/to/docker-compose.yml', 5000)).resolves.toBeUndefined();
-        });
-        it('should resolve when services have no health check (health: none)', async () => {
-            const mockOutput = `{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}
-{"Service":"api","State":"running","Health":"","Publishers":[]}`;
-            vi.mocked(execFileSync).mockReturnValue(mockOutput);
-            await expect(waitForServicesHealthy('/path/to/docker-compose.yml', 5000)).resolves.toBeUndefined();
-        });
-        it('should timeout when services remain unhealthy', async () => {
-            const mockOutput = '{"Service":"redis","State":"running","Health":"starting","Publishers":[]}';
-            vi.mocked(execFileSync).mockReturnValue(mockOutput);
-            const promise = waitForServicesHealthy('/path/to/docker-compose.yml', 100);
-            await expect(promise).rejects.toThrow('Timeout waiting for services to become healthy');
-        }, 10000);
-        it('should poll multiple times until healthy', async () => {
-            const callTracker = { count: 0 };
-            vi.mocked(execFileSync).mockImplementation(() => {
-                callTracker.count++;
-                if (callTracker.count < 3) {
-                    return '{"Service":"redis","State":"running","Health":"starting","Publishers":[]}';
-                }
-                return '{"Service":"redis","State":"running","Health":"healthy","Publishers":[]}';
-            });
-            await waitForServicesHealthy('/path/to/docker-compose.yml', 10000, 50);
-            expect(callTracker.count).toBeGreaterThanOrEqual(3);
-        });
-    });
-});

package/dist/services/env_configurator.d.ts

@@ -1,15 +0,0 @@
-/**
- * Interactively configures environment variables for a project by prompting the user
- * to provide values for empty variables or variables marked as secrets.
- *
- * This function reads from .env.example and, when the user confirms configuration,
- * copies it to .env before prompting for values. The .env.example file remains
- * unchanged as a template for other developers.
- *
- * @param projectPath - The absolute path to the project directory containing the .env.example file
- * @param skipPrompt - If true, copies .env.example to .env without interactive prompts and returns false
- * @returns A promise that resolves to true if environment variables were successfully configured,
- *          false if configuration was skipped (no .env.example file, user declined, no variables to configure,
- *          or an error occurred)
- */
-export declare function configureEnvironmentVariables(projectPath: string, skipPrompt?: boolean): Promise<boolean>;