@agents-at-scale/ark 0.1.35-rc.1 → 0.1.35-rc2

package/dist/commands/install/index.js

@@ -1,46 +1,40 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { execa } from 'execa';
+import { execute } from '../../lib/commands.js';
 import inquirer from 'inquirer';
-import { isCommandAvailable } from '../../lib/commandUtils.js';
-import { getClusterInfo } from '../../lib/cluster.js';
+import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
 import { getInstallableServices, arkDependencies } from '../../arkServices.js';
 import { isArkReady } from '../../lib/arkStatus.js';
+import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
-export async function installArk(options = {}) {
+async function installService(service, verbose = false) {
+    const helmArgs = [
+        'upgrade',
+        '--install',
+        service.helmReleaseName,
+        service.chartPath,
+    ];
+    // Only add namespace flag if service has explicit namespace
+    if (service.namespace) {
+        helmArgs.push('--namespace', service.namespace);
+    }
+    // Add any additional install args
+    helmArgs.push(...(service.installArgs || []));
+    await execute('helm', helmArgs, { stdio: 'inherit' }, { verbose });
+}
+export async function installArk(config, serviceName, options = {}) {
     // Validate that --wait-for-ready requires -y
     if (options.waitForReady && !options.yes) {
         output.error('--wait-for-ready requires -y flag for non-interactive mode');
         process.exit(1);
     }
-    // Check if helm is installed
-    const helmInstalled = await isCommandAvailable('helm');
-    if (!helmInstalled) {
-        output.error('helm is not installed. please install helm first:');
-        output.info('https://helm.sh/docs/intro/install/');
-        process.exit(1);
-    }
-    // Check if kubectl is installed (needed for some dependencies)
-    const kubectlInstalled = await isCommandAvailable('kubectl');
-    if (!kubectlInstalled) {
-        output.error('kubectl is not installed. please install kubectl first:');
-        output.info('https://kubernetes.io/docs/tasks/tools/');
-        process.exit(1);
-    }
-    // Check cluster connectivity
-    const clusterInfo = await getClusterInfo();
-    if (clusterInfo.error) {
-        output.error('no kubernetes cluster detected');
-        output.info('please ensure you have a running cluster and kubectl is configured.');
-        output.info('');
-        output.info('for local development, we recommend minikube:');
-        output.info('• install: https://minikube.sigs.k8s.io/docs/start');
-        output.info('• start cluster: minikube start');
-        output.info('');
-        output.info('alternatively, you can use kind or docker desktop.');
+    // Check cluster connectivity from config
+    if (!config.clusterInfo) {
+        showNoClusterError();
         process.exit(1);
     }
+    const clusterInfo = config.clusterInfo;
     // Show cluster info
     output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
     output.info(`type: ${clusterInfo.type}`);
@@ -49,22 +43,185 @@ export async function installArk(options = {}) {
         output.info(`ip: ${clusterInfo.ip}`);
     }
     console.log(); // Add blank line after cluster info
-    // Ask about installing dependencies
-    const shouldInstallDeps = options.yes || (await inquirer.prompt([
-        {
-            type: 'confirm',
-            name: 'shouldInstallDeps',
-            message: 'install required dependencies (cert-manager, gateway api)?',
-            default: true,
-        },
-    ])).shouldInstallDeps;
-    if (shouldInstallDeps) {
+    // If a specific service is requested, install only that service
+    if (serviceName) {
+        const services = getInstallableServices();
+        const service = Object.values(services).find((s) => s.name === serviceName);
+        if (!service) {
+            output.error(`service '${serviceName}' not found`);
+            output.info('available services:');
+            for (const s of Object.values(services)) {
+                output.info(`  ${s.name}`);
+            }
+            process.exit(1);
+        }
+        output.info(`installing ${service.name}...`);
+        try {
+            await installService(service, options.verbose);
+            output.success(`${service.name} installed successfully`);
+        }
+        catch (error) {
+            output.error(`failed to install ${service.name}`);
+            console.error(error);
+            process.exit(1);
+        }
+        return;
+    }
+    // If not using -y flag, show checklist interface
+    if (!options.yes) {
+        console.log(chalk.cyan.bold('\nSelect components to install:'));
+        console.log(chalk.gray('Use arrow keys to navigate, space to toggle, enter to confirm\n'));
+        // Build choices for the checkbox prompt
+        const allChoices = [
+            new inquirer.Separator(chalk.bold('──── Dependencies ────')),
+            {
+                name: `cert-manager ${chalk.gray('- Certificate management')}`,
+                value: 'cert-manager',
+                checked: true,
+            },
+            {
+                name: `gateway-api ${chalk.gray('- Gateway API CRDs')}`,
+                value: 'gateway-api',
+                checked: true,
+            },
+            new inquirer.Separator(chalk.bold('──── Ark Core ────')),
+            {
+                name: `ark-controller ${chalk.gray('- Core Ark controller')}`,
+                value: 'ark-controller',
+                checked: true,
+            },
+            new inquirer.Separator(chalk.bold('──── Ark Services ────')),
+            {
+                name: `ark-api ${chalk.gray('- API service')}`,
+                value: 'ark-api',
+                checked: true,
+            },
+            {
+                name: `ark-dashboard ${chalk.gray('- Web dashboard')}`,
+                value: 'ark-dashboard',
+                checked: true,
+            },
+            {
+                name: `ark-mcp ${chalk.gray('- MCP services')}`,
+                value: 'ark-mcp',
+                checked: true,
+            },
+            {
+                name: `localhost-gateway ${chalk.gray('- Gateway for local access')}`,
+                value: 'localhost-gateway',
+                checked: true,
+            },
+        ];
+        let selectedComponents = [];
+        try {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'components',
+                    message: 'Components to install:',
+                    choices: allChoices,
+                    pageSize: 15,
+                },
+            ]);
+            selectedComponents = answers.components;
+            if (selectedComponents.length === 0) {
+                output.warning('No components selected. Exiting.');
+                process.exit(0);
+            }
+        }
+        catch (error) {
+            // Handle Ctrl-C gracefully
+            if (error && error.name === 'ExitPromptError') {
+                console.log('\nInstallation cancelled');
+                process.exit(130);
+            }
+            throw error;
+        }
+        // Install dependencies if selected
+        const shouldInstallDeps = selectedComponents.includes('cert-manager') ||
+            selectedComponents.includes('gateway-api');
+        // Install selected dependencies
+        if (shouldInstallDeps) {
+            // Always install cert-manager repo and update if installing any dependency
+            if (selectedComponents.includes('cert-manager') ||
+                selectedComponents.includes('gateway-api')) {
+                for (const depKey of ['cert-manager-repo', 'helm-repo-update']) {
+                    const dep = arkDependencies[depKey];
+                    output.info(`installing ${dep.description || dep.name}...`);
+                    try {
+                        await execute(dep.command, dep.args, {
+                            stdio: 'inherit',
+                        }, { verbose: options.verbose });
+                        output.success(`${dep.name} completed`);
+                        console.log();
+                    }
+                    catch {
+                        console.log();
+                        process.exit(1);
+                    }
+                }
+            }
+            // Install cert-manager if selected
+            if (selectedComponents.includes('cert-manager')) {
+                const dep = arkDependencies['cert-manager'];
+                output.info(`installing ${dep.description || dep.name}...`);
+                try {
+                    await execute(dep.command, dep.args, {
+                        stdio: 'inherit',
+                    }, { verbose: options.verbose });
+                    output.success(`${dep.name} completed`);
+                    console.log();
+                }
+                catch {
+                    console.log();
+                    process.exit(1);
+                }
+            }
+            // Install gateway-api if selected
+            if (selectedComponents.includes('gateway-api')) {
+                const dep = arkDependencies['gateway-api-crds'];
+                output.info(`installing ${dep.description || dep.name}...`);
+                try {
+                    await execute(dep.command, dep.args, {
+                        stdio: 'inherit',
+                    }, { verbose: options.verbose });
+                    output.success(`${dep.name} completed`);
+                    console.log();
+                }
+                catch {
+                    console.log();
+                    process.exit(1);
+                }
+            }
+        }
+        // Install selected services
+        const services = getInstallableServices();
+        for (const service of Object.values(services)) {
+            // Check if this service was selected
+            const serviceKey = service.helmReleaseName;
+            if (!selectedComponents.includes(serviceKey)) {
+                continue;
+            }
+            output.info(`installing ${service.name}...`);
+            try {
+                await installService(service, options.verbose);
+                console.log(); // Add blank line after command output
+            }
+            catch {
+                // Continue with remaining services on error
+                console.log(); // Add blank line after error output
+            }
+        }
+    }
+    else {
+        // -y flag was used, install everything
+        // Install all dependencies
         for (const dep of Object.values(arkDependencies)) {
             output.info(`installing ${dep.description || dep.name}...`);
             try {
-                await execa(dep.command, dep.args, {
+                await execute(dep.command, dep.args, {
                     stdio: 'inherit',
-                });
+                }, { verbose: options.verbose });
                 output.success(`${dep.name} completed`);
                 console.log(); // Add blank line after dependency
             }
@@ -73,49 +230,25 @@ export async function installArk(options = {}) {
                 process.exit(1);
             }
         }
-    }
-    // Get installable services and iterate through them
-    const services = getInstallableServices();
-    for (const service of Object.values(services)) {
-        // Ask for confirmation
-        const shouldInstall = options.yes || (await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'shouldInstall',
-                message: `install ${chalk.bold(service.name)}? ${service.description ? chalk.gray(`(${service.description.toLowerCase()})`) : ''}`,
-                default: true,
-            },
-        ])).shouldInstall;
-        if (!shouldInstall) {
-            output.warning(`skipping ${service.name}`);
-            continue;
-        }
-        try {
-            // Build helm arguments
-            const helmArgs = [
-                'upgrade',
-                '--install',
-                service.helmReleaseName,
-                service.chartPath,
-                '--namespace',
-                service.namespace,
-            ];
-            // Add any additional args from the service definition
-            if (service.installArgs) {
-                helmArgs.push(...service.installArgs);
+        // Install all services
+        const services = getInstallableServices();
+        for (const service of Object.values(services)) {
+            output.info(`installing ${service.name}...`);
+            try {
+                await installService(service, options.verbose);
+                console.log(); // Add blank line after command output
+            }
+            catch {
+                // Continue with remaining services on error
+                console.log(); // Add blank line after error output
             }
-            // Run helm upgrade --install with streaming output
-            await execa('helm', helmArgs, {
-                stdio: 'inherit',
-            });
-            console.log(); // Add blank line after command output
-        }
-        catch {
-            // Continue with remaining services on error
-            console.log(); // Add blank line after error output
         }
     }
-    // Wait for ARK to be ready if requested
+    // Show next steps after successful installation
+    if (!serviceName || serviceName === 'all') {
+        printNextSteps();
+    }
+    // Wait for Ark to be ready if requested
     if (options.waitForReady) {
         // Parse timeout value (e.g., '30s', '2m', '60')
         const parseTimeout = (value) => {
@@ -131,19 +264,19 @@ export async function installArk(options = {}) {
             const timeoutSeconds = parseTimeout(options.waitForReady);
             const startTime = Date.now();
             const endTime = startTime + timeoutSeconds * 1000;
-            const spinner = ora(`Waiting for ARK to be ready (timeout: ${timeoutSeconds}s)...`).start();
+            const spinner = ora(`Waiting for Ark to be ready (timeout: ${timeoutSeconds}s)...`).start();
             while (Date.now() < endTime) {
                 if (await isArkReady()) {
-                    spinner.succeed('ARK is ready!');
+                    spinner.succeed('Ark is ready!');
                     return;
                 }
                 const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                spinner.text = `Waiting for ARK to be ready (${elapsed}/${timeoutSeconds}s)...`;
+                spinner.text = `Waiting for Ark to be ready (${elapsed}/${timeoutSeconds}s)...`;
                 // Wait 2 seconds before checking again
-                await new Promise(resolve => setTimeout(resolve, 2000));
+                await new Promise((resolve) => setTimeout(resolve, 2000));
             }
             // Timeout reached
-            spinner.fail(`ARK did not become ready within ${timeoutSeconds} seconds`);
+            spinner.fail(`Ark did not become ready within ${timeoutSeconds} seconds`);
             process.exit(1);
         }
         catch (error) {
@@ -152,14 +285,16 @@ export async function installArk(options = {}) {
         }
     }
 }
-export function createInstallCommand() {
+export function createInstallCommand(config) {
     const command = new Command('install');
     command
         .description('Install ARK components using Helm')
+        .argument('[service]', 'specific service to install, or all if omitted')
         .option('-y, --yes', 'automatically confirm all installations')
-        .option('--wait-for-ready <timeout>', 'wait for ARK to be ready after installation (e.g., 30s, 2m)')
-        .action(async (options) => {
-        await installArk(options);
+        .option('--wait-for-ready <timeout>', 'wait for Ark to be ready after installation (e.g., 30s, 2m)')
+        .option('-v, --verbose', 'show commands being executed')
+        .action(async (service, options) => {
+        await installArk(config, service, options);
     });
     return command;
 }

package/dist/commands/install/index.spec.d.ts

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

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

@@ -0,0 +1,143 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn(() => Promise.resolve());
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockGetClusterInfo = jest.fn();
+jest.unstable_mockModule('../../lib/cluster.js', () => ({
+    getClusterInfo: mockGetClusterInfo,
+}));
+const mockGetInstallableServices = jest.fn();
+const mockArkServices = {};
+const mockArkDependencies = {};
+jest.unstable_mockModule('../../arkServices.js', () => ({
+    getInstallableServices: mockGetInstallableServices,
+    arkServices: mockArkServices,
+    arkDependencies: mockArkDependencies,
+}));
+const mockOutput = {
+    error: jest.fn(),
+    info: jest.fn(),
+    success: jest.fn(),
+    warning: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+jest.spyOn(console, 'log').mockImplementation(() => { });
+jest.spyOn(console, 'error').mockImplementation(() => { });
+const { createInstallCommand } = await import('./index.js');
+describe('install command', () => {
+    const mockConfig = {
+        clusterInfo: {
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        });
+    });
+    it('creates command with correct structure', () => {
+        const command = createInstallCommand(mockConfig);
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('install');
+    });
+    it('installs single service with correct helm parameters', async () => {
+        const mockService = {
+            name: 'ark-api',
+            helmReleaseName: 'ark-api',
+            chartPath: './charts/ark-api',
+            namespace: 'ark-system',
+            installArgs: ['--set', 'image.tag=latest'],
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': mockService,
+        });
+        const command = createInstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'ark-api']);
+        expect(mockExeca).toHaveBeenCalledWith('helm', [
+            'upgrade',
+            '--install',
+            'ark-api',
+            './charts/ark-api',
+            '--namespace',
+            'ark-system',
+            '--set',
+            'image.tag=latest',
+        ], { stdio: 'inherit' });
+        expect(mockOutput.success).toHaveBeenCalledWith('ark-api installed successfully');
+    });
+    it('shows error when service not found', async () => {
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': { name: 'ark-api' },
+            'ark-controller': { name: 'ark-controller' },
+        });
+        const command = createInstallCommand(mockConfig);
+        await expect(command.parseAsync(['node', 'test', 'invalid-service'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith("service 'invalid-service' not found");
+        expect(mockOutput.info).toHaveBeenCalledWith('available services:');
+        expect(mockOutput.info).toHaveBeenCalledWith('  ark-api');
+        expect(mockOutput.info).toHaveBeenCalledWith('  ark-controller');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('handles service without namespace (uses current context)', async () => {
+        const mockService = {
+            name: 'ark-dashboard',
+            helmReleaseName: 'ark-dashboard',
+            chartPath: './charts/ark-dashboard',
+            // namespace is undefined - should use current context
+            installArgs: ['--set', 'replicas=2'],
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-dashboard': mockService,
+        });
+        const command = createInstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'ark-dashboard']);
+        // Should NOT include --namespace flag
+        expect(mockExeca).toHaveBeenCalledWith('helm', [
+            'upgrade',
+            '--install',
+            'ark-dashboard',
+            './charts/ark-dashboard',
+            '--set',
+            'replicas=2',
+        ], { stdio: 'inherit' });
+    });
+    it('handles service without installArgs', async () => {
+        const mockService = {
+            name: 'simple-service',
+            helmReleaseName: 'simple-service',
+            chartPath: './charts/simple',
+            namespace: 'default',
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'simple-service': mockService,
+        });
+        const command = createInstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'simple-service']);
+        expect(mockExeca).toHaveBeenCalledWith('helm', [
+            'upgrade',
+            '--install',
+            'simple-service',
+            './charts/simple',
+            '--namespace',
+            'default',
+        ], { stdio: 'inherit' });
+    });
+    it('exits when cluster not connected', async () => {
+        mockGetClusterInfo.mockResolvedValue({ error: true });
+        const command = createInstallCommand({});
+        await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

package/dist/commands/models/create.spec.d.ts

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

package/dist/commands/models/create.spec.js

@@ -0,0 +1,125 @@
+import { jest } from '@jest/globals';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockInquirer = {
+    prompt: jest.fn(),
+};
+jest.unstable_mockModule('inquirer', () => ({
+    default: mockInquirer,
+}));
+const mockOutput = {
+    info: jest.fn(),
+    warning: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+jest.spyOn(console, 'log').mockImplementation(() => { });
+jest.spyOn(console, 'error').mockImplementation(() => { });
+const { createModel } = await import('./create.js');
+describe('createModel', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates new model with provided name', async () => {
+        // Model doesn't exist
+        mockExeca.mockRejectedValueOnce(new Error('not found'));
+        // Prompts for model details
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelType: 'openai' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://api.openai.com/',
+        })
+            .mockResolvedValueOnce({ apiKey: 'secret-key' });
+        // Secret operations succeed
+        mockExeca.mockResolvedValueOnce({}); // delete secret (may not exist)
+        mockExeca.mockResolvedValueOnce({}); // create secret
+        mockExeca.mockResolvedValueOnce({}); // apply model
+        const result = await createModel('test-model');
+        expect(result).toBe(true);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'model', 'test-model'], { stdio: 'pipe' });
+        expect(mockOutput.success).toHaveBeenCalledWith('model test-model created successfully');
+    });
+    it('prompts for name when not provided', async () => {
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelName: 'prompted-model' })
+            .mockResolvedValueOnce({ modelType: 'azure' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://azure.com',
+        })
+            .mockResolvedValueOnce({ apiVersion: '2024-12-01' })
+            .mockResolvedValueOnce({ apiKey: 'secret' });
+        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
+        mockExeca.mockResolvedValue({}); // all kubectl ops succeed
+        const result = await createModel();
+        expect(result).toBe(true);
+        expect(mockInquirer.prompt).toHaveBeenCalledWith([
+            expect.objectContaining({
+                name: 'modelName',
+                message: 'model name:',
+            }),
+        ]);
+    });
+    it('handles overwrite confirmation when model exists', async () => {
+        // Model exists
+        mockExeca.mockResolvedValueOnce({});
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ overwrite: true })
+            .mockResolvedValueOnce({ modelType: 'openai' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://api.openai.com',
+        })
+            .mockResolvedValueOnce({ apiKey: 'secret' });
+        mockExeca.mockResolvedValue({}); // remaining kubectl ops
+        const result = await createModel('existing-model');
+        expect(result).toBe(true);
+        expect(mockOutput.warning).toHaveBeenCalledWith('model existing-model already exists');
+    });
+    it('cancels when user declines overwrite', async () => {
+        mockExeca.mockResolvedValueOnce({}); // model exists
+        mockInquirer.prompt.mockResolvedValueOnce({ overwrite: false });
+        const result = await createModel('existing-model');
+        expect(result).toBe(false);
+        expect(mockOutput.info).toHaveBeenCalledWith('model creation cancelled');
+    });
+    it('handles secret creation failure', async () => {
+        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelType: 'openai' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://api.openai.com',
+        })
+            .mockResolvedValueOnce({ apiKey: 'secret' });
+        mockExeca.mockRejectedValueOnce(new Error('delete failed')); // delete secret may fail
+        mockExeca.mockRejectedValueOnce(new Error('secret creation failed')); // create secret fails
+        const result = await createModel('test-model');
+        expect(result).toBe(false);
+        expect(mockOutput.error).toHaveBeenCalledWith('failed to create secret');
+    });
+    it('cleans up secret if model creation fails', async () => {
+        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelType: 'openai' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://api.openai.com',
+        })
+            .mockResolvedValueOnce({ apiKey: 'secret' });
+        mockExeca.mockResolvedValueOnce({}); // delete secret
+        mockExeca.mockResolvedValueOnce({}); // create secret
+        mockExeca.mockRejectedValueOnce(new Error('apply failed')); // apply model fails
+        mockExeca.mockResolvedValueOnce({}); // cleanup secret
+        const result = await createModel('test-model');
+        expect(result).toBe(false);
+        expect(mockOutput.error).toHaveBeenCalledWith('failed to create model');
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'secret', 'test-model-model-api-key'], { stdio: 'pipe' });
+    });
+});

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

@@ -1,2 +1,3 @@
 import { Command } from 'commander';
-export declare function createModelsCommand(): Command;
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createModelsCommand(_: ArkConfig): Command;