@outputai/cli 0.1.4 → 0.1.5

package/dist/commands/credentials/get.spec.js

@@ -0,0 +1,74 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as credentialsService from '#services/credentials_service.js';
+import CredentialsGet from './get.js';
+vi.mock('#services/credentials_service.js');
+vi.mock('js-yaml', () => ({
+    load: vi.fn((yaml) => ({ anthropic: { api_key: yaml.includes('sk-test') ? 'sk-test' : undefined } }))
+}));
+vi.mock('@outputai/credentials', () => ({
+    getNestedValue: vi.fn((obj, path) => {
+        const parts = path.split('.');
+        return parts.reduce((acc, part) => acc?.[part], obj);
+    })
+}));
+describe('credentials get command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(credentialsService.credentialsExist).mockReturnValue(true);
+        vi.mocked(credentialsService.decryptCredentials).mockReturnValue('anthropic:\n  api_key: sk-test\n');
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    const createTestCommand = (parsedArgs = {}, flags = {}) => {
+        const cmd = new CredentialsGet([], {});
+        cmd.log = vi.fn();
+        cmd.error = vi.fn((msg) => {
+            throw new Error(msg);
+        });
+        Object.defineProperty(cmd, 'parse', {
+            value: vi.fn().mockResolvedValue({
+                args: { path: 'anthropic.api_key', ...parsedArgs },
+                flags: { environment: undefined, workflow: undefined, ...flags }
+            }),
+            configurable: true
+        });
+        return cmd;
+    };
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(CredentialsGet.description).toContain('credential value');
+        });
+        it('should have a required path argument', () => {
+            expect(CredentialsGet.args.path).toBeDefined();
+            expect(CredentialsGet.args.path.required).toBe(true);
+        });
+        it('should have environment and workflow flags', () => {
+            expect(CredentialsGet.flags.environment).toBeDefined();
+            expect(CredentialsGet.flags.workflow).toBeDefined();
+        });
+    });
+    describe('command execution', () => {
+        it('should log the credential value', async () => {
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith(undefined, undefined);
+            expect(cmd.log).toHaveBeenCalledWith('sk-test');
+        });
+        it('should error when both environment and workflow are specified', async () => {
+            const cmd = createTestCommand({}, { environment: 'production', workflow: 'my_workflow' });
+            await expect(cmd.run()).rejects.toThrow('Cannot specify both');
+        });
+        it('should error when credentials file does not exist', async () => {
+            vi.mocked(credentialsService.credentialsExist).mockReturnValue(false);
+            vi.mocked(credentialsService.resolveCredentialsPath).mockReturnValue('/project/config/credentials.yml.enc');
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('No credentials file found');
+        });
+        it('should error when credential path is not found', async () => {
+            const cmd = createTestCommand({ path: 'nonexistent.key' });
+            await expect(cmd.run()).rejects.toThrow('Credential not found');
+        });
+    });
+});

package/dist/commands/credentials/init.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class CredentialsInit extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        environment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workflow: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/credentials/init.js

@@ -0,0 +1,45 @@
+import { Command, Flags } from '@oclif/core';
+import { initCredentials, resolveCredentialsPath, resolveKeyPath, credentialsExist } from '#services/credentials_service.js';
+export default class CredentialsInit extends Command {
+    static description = 'Initialize encrypted credentials file and master key';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --environment production',
+        '<%= config.bin %> <%= command.id %> --workflow my_workflow'
+    ];
+    static flags = {
+        environment: Flags.string({
+            char: 'e',
+            description: 'Target environment (e.g. production, development)'
+        }),
+        workflow: Flags.string({
+            char: 'w',
+            description: 'Target a specific workflow directory'
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Overwrite existing credentials',
+            default: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(CredentialsInit);
+        const environment = flags.environment;
+        const workflow = flags.workflow;
+        if (environment && workflow) {
+            this.error('Cannot specify both --environment and --workflow.');
+        }
+        if (!flags.force && credentialsExist(environment, workflow)) {
+            this.error(`Credentials already exist at ${resolveCredentialsPath(environment, workflow)}. Use --force to overwrite.`);
+        }
+        const { keyPath, credPath } = initCredentials(environment, workflow);
+        this.log('');
+        this.log(`Created key:         ${keyPath}`);
+        this.log(`Created credentials: ${credPath}`);
+        this.log('');
+        this.log('IMPORTANT: Add the key file to .gitignore:');
+        this.log(`  ${resolveKeyPath(environment, workflow)}`);
+        this.log('');
+        this.log('Edit credentials with: output credentials edit');
+    }
+}

package/dist/commands/credentials/init.spec.d.ts

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

package/dist/commands/credentials/init.spec.js

@@ -0,0 +1,68 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as credentialsService from '#services/credentials_service.js';
+import CredentialsInit from './init.js';
+vi.mock('#services/credentials_service.js');
+describe('credentials init command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(credentialsService.credentialsExist).mockReturnValue(false);
+        vi.mocked(credentialsService.initCredentials).mockReturnValue({
+            keyPath: '/project/config/credentials.key',
+            credPath: '/project/config/credentials.yml.enc'
+        });
+        vi.mocked(credentialsService.resolveKeyPath).mockReturnValue('/project/config/credentials.key');
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    const createTestCommand = (flags = {}) => {
+        const cmd = new CredentialsInit([], {});
+        cmd.log = vi.fn();
+        cmd.error = vi.fn((msg) => {
+            throw new Error(msg);
+        });
+        Object.defineProperty(cmd, 'parse', {
+            value: vi.fn().mockResolvedValue({
+                args: {},
+                flags: { environment: undefined, workflow: undefined, force: false, ...flags }
+            }),
+            configurable: true
+        });
+        return cmd;
+    };
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(CredentialsInit.description).toContain('Initialize');
+        });
+        it('should have environment, workflow, and force flags', () => {
+            expect(CredentialsInit.flags.environment).toBeDefined();
+            expect(CredentialsInit.flags.workflow).toBeDefined();
+            expect(CredentialsInit.flags.force).toBeDefined();
+        });
+    });
+    describe('command execution', () => {
+        it('should call initCredentials and log results', async () => {
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(credentialsService.initCredentials).toHaveBeenCalledWith(undefined, undefined);
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('credentials.key'));
+        });
+        it('should error when both environment and workflow are specified', async () => {
+            const cmd = createTestCommand({ environment: 'production', workflow: 'my_workflow' });
+            await expect(cmd.run()).rejects.toThrow('Cannot specify both');
+        });
+        it('should error when credentials already exist without --force', async () => {
+            vi.mocked(credentialsService.credentialsExist).mockReturnValue(true);
+            vi.mocked(credentialsService.resolveCredentialsPath).mockReturnValue('/project/config/credentials.yml.enc');
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('already exist');
+        });
+        it('should proceed when credentials exist with --force', async () => {
+            vi.mocked(credentialsService.credentialsExist).mockReturnValue(true);
+            const cmd = createTestCommand({ force: true });
+            await cmd.run();
+            expect(credentialsService.initCredentials).toHaveBeenCalled();
+        });
+    });
+});

package/dist/commands/credentials/show.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class CredentialsShow extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        environment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workflow: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/credentials/show.js

@@ -0,0 +1,33 @@
+import { Command, Flags } from '@oclif/core';
+import { decryptCredentials, credentialsExist, resolveCredentialsPath } from '#services/credentials_service.js';
+export default class CredentialsShow extends Command {
+    static description = 'Show decrypted credentials (for debugging)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --environment production',
+        '<%= config.bin %> <%= command.id %> --workflow my_workflow'
+    ];
+    static flags = {
+        environment: Flags.string({
+            char: 'e',
+            description: 'Target environment (e.g. production, development)'
+        }),
+        workflow: Flags.string({
+            char: 'w',
+            description: 'Target a specific workflow directory'
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(CredentialsShow);
+        const environment = flags.environment;
+        const workflow = flags.workflow;
+        if (environment && workflow) {
+            this.error('Cannot specify both --environment and --workflow.');
+        }
+        if (!credentialsExist(environment, workflow)) {
+            this.error(`No credentials file found at ${resolveCredentialsPath(environment, workflow)}. Run "output credentials init" first.`);
+        }
+        const plaintext = decryptCredentials(environment, workflow);
+        this.log(plaintext);
+    }
+}

package/dist/commands/credentials/show.spec.d.ts

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

package/dist/commands/credentials/show.spec.js

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as credentialsService from '#services/credentials_service.js';
+import CredentialsShow from './show.js';
+vi.mock('#services/credentials_service.js');
+describe('credentials show command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(credentialsService.credentialsExist).mockReturnValue(true);
+        vi.mocked(credentialsService.decryptCredentials).mockReturnValue('anthropic:\n  api_key: sk-test\n');
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    const createTestCommand = (flags = {}) => {
+        const cmd = new CredentialsShow([], {});
+        cmd.log = vi.fn();
+        cmd.error = vi.fn((msg) => {
+            throw new Error(msg);
+        });
+        Object.defineProperty(cmd, 'parse', {
+            value: vi.fn().mockResolvedValue({
+                args: {},
+                flags: { environment: undefined, workflow: undefined, ...flags }
+            }),
+            configurable: true
+        });
+        return cmd;
+    };
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(CredentialsShow.description).toContain('Show');
+        });
+        it('should have environment and workflow flags', () => {
+            expect(CredentialsShow.flags.environment).toBeDefined();
+            expect(CredentialsShow.flags.workflow).toBeDefined();
+        });
+    });
+    describe('command execution', () => {
+        it('should log decrypted credentials', async () => {
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith(undefined, undefined);
+            expect(cmd.log).toHaveBeenCalledWith('anthropic:\n  api_key: sk-test\n');
+        });
+        it('should error when both environment and workflow are specified', async () => {
+            const cmd = createTestCommand({ environment: 'production', workflow: 'my_workflow' });
+            await expect(cmd.run()).rejects.toThrow('Cannot specify both');
+        });
+        it('should error when credentials file does not exist', async () => {
+            vi.mocked(credentialsService.credentialsExist).mockReturnValue(false);
+            vi.mocked(credentialsService.resolveCredentialsPath).mockReturnValue('/project/config/credentials.yml.enc');
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('No credentials file found');
+        });
+    });
+});

package/dist/commands/dev/eject.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class DevEject extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {};
+    static flags: {
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/dev/eject.js

@@ -0,0 +1,58 @@
+import { Command, Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getDefaultDockerComposePath } from '#services/docker.js';
+import { getErrorMessage } from '#utils/error_utils.js';
+import { getEjectSuccessMessage } from '#services/messages.js';
+export default class DevEject extends Command {
+    static description = 'Eject the Docker Compose configuration to your project root for customization';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --output ./custom-compose.yml'
+    ];
+    static args = {};
+    static flags = {
+        output: Flags.string({
+            description: 'Output path for the docker-compose file',
+            required: false,
+            char: 'o',
+            default: 'docker-compose.yml'
+        }),
+        force: Flags.boolean({
+            description: 'Overwrite existing file without prompting',
+            required: false,
+            char: 'f',
+            default: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(DevEject);
+        // Source docker-compose file from assets
+        const sourcePath = getDefaultDockerComposePath();
+        // Destination path (relative to current working directory)
+        const destPath = path.resolve(process.cwd(), flags.output);
+        try {
+            // Check if source file exists
+            await fs.access(sourcePath);
+        }
+        catch {
+            this.error(`Docker Compose template not found at: ${sourcePath}`, { exit: 1 });
+        }
+        // Check if destination file already exists
+        const fileExists = await fs.access(destPath).then(() => true).catch(() => false);
+        if (fileExists && !flags.force) {
+            this.error(`File already exists at ${destPath}. Use --force to overwrite or specify a different output path with --output`, { exit: 1 });
+        }
+        try {
+            // Read the source file
+            const dockerComposeContent = await fs.readFile(sourcePath, 'utf-8');
+            // Write to destination
+            await fs.writeFile(destPath, dockerComposeContent, 'utf-8');
+            // Display the styled success message
+            this.log(getEjectSuccessMessage(destPath, flags.output, this.config.bin));
+        }
+        catch (error) {
+            this.error(`Failed to eject docker-compose configuration: ${getErrorMessage(error)}`, { exit: 1 });
+        }
+    }
+}

package/dist/commands/dev/eject.spec.d.ts

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

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

@@ -0,0 +1,109 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import DevEject from './eject.js';
+vi.mock('node:fs/promises');
+describe('dev eject command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(DevEject.description).toBeDefined();
+            expect(DevEject.description).toContain('Eject');
+            expect(DevEject.description).toContain('Docker Compose');
+        });
+        it('should have examples', () => {
+            expect(DevEject.examples).toBeDefined();
+            expect(Array.isArray(DevEject.examples)).toBe(true);
+            expect(DevEject.examples.length).toBeGreaterThan(0);
+        });
+        it('should have no required arguments', () => {
+            expect(DevEject.args).toBeDefined();
+            expect(Object.keys(DevEject.args)).toHaveLength(0);
+        });
+        it('should have output and force flags defined', () => {
+            expect(DevEject.flags).toBeDefined();
+            expect(DevEject.flags.output).toBeDefined();
+            expect(DevEject.flags.output.description).toContain('Output path');
+            expect(DevEject.flags.output.required).toBe(false);
+            expect(DevEject.flags.output.char).toBe('o');
+            expect(DevEject.flags.output.default).toBe('docker-compose.yml');
+            expect(DevEject.flags.force).toBeDefined();
+            expect(DevEject.flags.force.description).toContain('Overwrite');
+            expect(DevEject.flags.force.required).toBe(false);
+            expect(DevEject.flags.force.char).toBe('f');
+            expect(DevEject.flags.force.default).toBe(false);
+        });
+    });
+    describe('command instantiation', () => {
+        it('should be instantiable', () => {
+            const cmd = new DevEject([], {});
+            expect(cmd).toBeInstanceOf(DevEject);
+        });
+        it('should have a run method', () => {
+            const cmd = new DevEject([], {});
+            expect(cmd.run).toBeDefined();
+            expect(typeof cmd.run).toBe('function');
+        });
+    });
+    describe('file ejection', () => {
+        it('should eject docker-compose file to default location', async () => {
+            const config = {
+                runHook: vi.fn().mockResolvedValue({ failures: [], successes: [] })
+            };
+            const cmd = new DevEject([], config);
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            const mockDockerComposeContent = 'name: output-sdk\nservices:\n  redis:\n    image: redis:8-alpine';
+            // Mock source file exists and can be read
+            vi.mocked(fs.access).mockImplementation(path => {
+                if (path.toString().includes('assets/docker/docker-compose-dev.yml')) {
+                    return Promise.resolve();
+                }
+                // Destination file doesn't exist
+                return Promise.reject(new Error('File not found'));
+            });
+            vi.mocked(fs.readFile).mockResolvedValue(mockDockerComposeContent);
+            vi.mocked(fs.writeFile).mockResolvedValue();
+            await cmd.run();
+            expect(fs.readFile).toHaveBeenCalled();
+            expect(fs.writeFile).toHaveBeenCalledWith(expect.stringContaining('docker-compose.yml'), mockDockerComposeContent, 'utf-8');
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('SUCCESS!'));
+        });
+        it('should error if destination file exists and force flag is not set', async () => {
+            const config = {
+                runHook: vi.fn().mockResolvedValue({ failures: [], successes: [] })
+            };
+            const cmd = new DevEject([], config);
+            cmd.log = vi.fn();
+            cmd.error = vi.fn().mockImplementation(msg => {
+                throw new Error(msg);
+            });
+            // Mock both source and destination files exist
+            vi.mocked(fs.access).mockResolvedValue();
+            await expect(cmd.run()).rejects.toThrow('File already exists');
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('File already exists'), { exit: 1 });
+        });
+        it('should overwrite file if force flag is set', async () => {
+            const config = {
+                runHook: vi.fn().mockResolvedValue({ failures: [], successes: [] })
+            };
+            const cmd = new DevEject(['--force'], config);
+            cmd.log = vi.fn();
+            cmd.error = vi.fn();
+            const mockDockerComposeContent = 'name: output-sdk\nservices:\n  redis:\n    image: redis:8-alpine';
+            // Mock both source and destination files exist
+            vi.mocked(fs.access).mockResolvedValue();
+            vi.mocked(fs.readFile).mockResolvedValue(mockDockerComposeContent);
+            vi.mocked(fs.writeFile).mockResolvedValue();
+            await cmd.run();
+            expect(fs.readFile).toHaveBeenCalled();
+            expect(fs.writeFile).toHaveBeenCalledWith(expect.stringContaining('docker-compose.yml'), mockDockerComposeContent, 'utf-8');
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('SUCCESS!'));
+        });
+    });
+});

package/dist/commands/dev/index.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class Dev extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {};
+    static flags: {
+        'compose-file': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'image-pull-policy': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        detached: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private dockerProcess;
+    run(): Promise<void>;
+    private pollServiceStatus;
+}