@agents-at-scale/ark 0.1.35-rc1 → 0.1.35

package/dist/commands/models/create.js

@@ -1,213 +0,0 @@
-import { execa } from 'execa';
-import inquirer from 'inquirer';
-import output from '../../lib/output.js';
-export async function createModel(modelName) {
-    // Step 1: Get model name if not provided
-    if (!modelName) {
-        const nameAnswer = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'modelName',
-                message: 'model name:',
-                default: 'default',
-                validate: (input) => {
-                    if (!input)
-                        return 'model name is required';
-                    // Kubernetes name validation
-                    if (!/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(input)) {
-                        return 'model name must be a valid Kubernetes resource name';
-                    }
-                    return true;
-                },
-            },
-        ]);
-        modelName = nameAnswer.modelName;
-    }
-    // Check if model already exists
-    try {
-        await execa('kubectl', ['get', 'model', modelName], { stdio: 'pipe' });
-        output.warning(`model ${modelName} already exists`);
-        const { overwrite } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'overwrite',
-                message: `overwrite existing model ${modelName}?`,
-                default: false,
-            },
-        ]);
-        if (!overwrite) {
-            output.info('model creation cancelled');
-            return false;
-        }
-    }
-    catch {
-        // Model doesn't exist, continue
-    }
-    // Step 2: Choose model type
-    const { modelType } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'modelType',
-            message: 'select model provider:',
-            choices: [
-                { name: 'Azure OpenAI', value: 'azure' },
-                { name: 'OpenAI', value: 'openai' },
-            ],
-            default: 'azure',
-        },
-    ]);
-    // Step 3: Get common parameters
-    const commonAnswers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'modelVersion',
-            message: 'model version:',
-            default: 'gpt-4o-mini',
-        },
-        {
-            type: 'input',
-            name: 'baseUrl',
-            message: 'base URL:',
-            validate: (input) => {
-                if (!input)
-                    return 'base URL is required';
-                try {
-                    new URL(input);
-                    return true;
-                }
-                catch {
-                    return 'please enter a valid URL';
-                }
-            },
-        },
-    ]);
-    // Remove trailing slash from base URL
-    const baseUrl = commonAnswers.baseUrl.replace(/\/$/, '');
-    // Step 4: Get provider-specific parameters
-    let apiVersion = '';
-    if (modelType === 'azure') {
-        const azureAnswers = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'apiVersion',
-                message: 'Azure API version:',
-                default: '2024-12-01-preview',
-            },
-        ]);
-        apiVersion = azureAnswers.apiVersion;
-    }
-    // Step 5: Get API key (password input)
-    const { apiKey } = await inquirer.prompt([
-        {
-            type: 'password',
-            name: 'apiKey',
-            message: 'API key:',
-            mask: '*',
-            validate: (input) => {
-                if (!input)
-                    return 'API key is required';
-                return true;
-            },
-        },
-    ]);
-    // Step 6: Create the Kubernetes secret
-    const secretName = `${modelName}-model-api-key`;
-    output.info(`creating secret ${secretName}...`);
-    try {
-        // Delete existing secret if it exists (update scenario)
-        await execa('kubectl', ['delete', 'secret', secretName], {
-            stdio: 'pipe',
-        }).catch(() => {
-            // Ignore error if secret doesn't exist
-        });
-        // Create the secret
-        await execa('kubectl', [
-            'create',
-            'secret',
-            'generic',
-            secretName,
-            `--from-literal=api-key=${apiKey}`,
-        ], { stdio: 'pipe' });
-        output.success(`secret ${secretName} created`);
-    }
-    catch (error) {
-        output.error('failed to create secret');
-        console.error(error);
-        return false;
-    }
-    // Step 7: Create the Model resource
-    output.info(`creating model ${modelName}...`);
-    const modelManifest = {
-        apiVersion: 'ark.mckinsey.com/v1alpha1',
-        kind: 'Model',
-        metadata: {
-            name: modelName,
-        },
-        spec: {
-            type: modelType,
-            model: {
-                value: commonAnswers.modelVersion,
-            },
-            config: {},
-        },
-    };
-    // Add provider-specific config
-    if (modelType === 'azure') {
-        modelManifest.spec.config.azure = {
-            apiKey: {
-                valueFrom: {
-                    secretKeyRef: {
-                        name: secretName,
-                        key: 'api-key',
-                    },
-                },
-            },
-            baseUrl: {
-                value: baseUrl,
-            },
-            apiVersion: {
-                value: apiVersion,
-            },
-        };
-    }
-    else {
-        modelManifest.spec.config.openai = {
-            apiKey: {
-                valueFrom: {
-                    secretKeyRef: {
-                        name: secretName,
-                        key: 'api-key',
-                    },
-                },
-            },
-            baseUrl: {
-                value: baseUrl,
-            },
-        };
-    }
-    try {
-        // Apply the model manifest using kubectl
-        const manifestJson = JSON.stringify(modelManifest);
-        await execa('kubectl', ['apply', '-f', '-'], {
-            input: manifestJson,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        output.success(`model ${modelName} created successfully`);
-        console.log();
-        output.info('you can now use this model with ARK agents and queries');
-        return true;
-    }
-    catch (error) {
-        output.error('failed to create model');
-        console.error(error);
-        // Try to clean up the secret if model creation failed
-        try {
-            await execa('kubectl', ['delete', 'secret', secretName], { stdio: 'pipe' });
-            output.info(`cleaned up secret ${secretName}`);
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-        return false;
-    }
-}

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

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

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

@@ -1,125 +0,0 @@
-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,3 +0,0 @@
-import { Command } from 'commander';
-import type { ArkConfig } from '../../lib/config.js';
-export declare function createModelsCommand(_: ArkConfig): Command;

package/dist/commands/models/index.js

@@ -1,60 +0,0 @@
-import { Command } from 'commander';
-import { execa } from 'execa';
-import output from '../../lib/output.js';
-import { createModel } from './create.js';
-async function listModels(options) {
-    try {
-        // Use kubectl to get models
-        const result = await execa('kubectl', ['get', 'models', '-o', 'json'], {
-            stdio: 'pipe',
-        });
-        const data = JSON.parse(result.stdout);
-        const models = data.items || [];
-        if (options.output === 'json') {
-            // Output the raw items for JSON format
-            console.log(JSON.stringify(models, null, 2));
-        }
-        else {
-            if (models.length === 0) {
-                output.info('No models found');
-                return;
-            }
-            // Just output the model names
-            models.forEach((model) => {
-                console.log(model.metadata.name);
-            });
-        }
-    }
-    catch (error) {
-        output.error('fetching models:', error instanceof Error ? error.message : error);
-        process.exit(1);
-    }
-}
-export function createModelsCommand(_) {
-    const modelsCommand = new Command('models');
-    modelsCommand
-        .description('List available models')
-        .option('-o, --output <format>', 'Output format (json)', 'text')
-        .action(async (options) => {
-        await listModels(options);
-    });
-    const listCommand = new Command('list');
-    listCommand
-        .alias('ls')
-        .description('List available models')
-        .option('-o, --output <format>', 'Output format (json)', 'text')
-        .action(async (options) => {
-        await listModels(options);
-    });
-    modelsCommand.addCommand(listCommand);
-    // Add create command
-    const createCommand = new Command('create');
-    createCommand
-        .description('Create a new model')
-        .argument('[name]', 'Model name (optional)')
-        .action(async (name) => {
-        await createModel(name);
-    });
-    modelsCommand.addCommand(createCommand);
-    return modelsCommand;
-}

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

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

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

@@ -1,76 +0,0 @@
-import { jest } from '@jest/globals';
-import { Command } from 'commander';
-const mockExeca = jest.fn();
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const mockOutput = {
-    info: jest.fn(),
-    error: jest.fn(),
-};
-jest.unstable_mockModule('../../lib/output.js', () => ({
-    default: mockOutput,
-}));
-const mockCreateModel = jest.fn();
-jest.unstable_mockModule('./create.js', () => ({
-    createModel: mockCreateModel,
-}));
-const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
-    throw new Error('process.exit called');
-}));
-const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
-const { createModelsCommand } = await import('./index.js');
-describe('models command', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('creates command with correct structure', () => {
-        const command = createModelsCommand({});
-        expect(command).toBeInstanceOf(Command);
-        expect(command.name()).toBe('models');
-    });
-    it('lists models in text format', async () => {
-        const mockModels = {
-            items: [{ metadata: { name: 'gpt-4' } }, { metadata: { name: 'claude-3' } }],
-        };
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockModels) });
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'models', '-o', 'json'], { stdio: 'pipe' });
-        expect(mockConsoleLog).toHaveBeenCalledWith('gpt-4');
-        expect(mockConsoleLog).toHaveBeenCalledWith('claude-3');
-    });
-    it('lists models in json format', async () => {
-        const mockModels = {
-            items: [{ metadata: { name: 'gpt-4' } }],
-        };
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockModels) });
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test', '-o', 'json']);
-        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockModels.items, null, 2));
-    });
-    it('shows info when no models', async () => {
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test']);
-        expect(mockOutput.info).toHaveBeenCalledWith('No models found');
-    });
-    it('handles errors', async () => {
-        mockExeca.mockRejectedValue(new Error('kubectl failed'));
-        const command = createModelsCommand({});
-        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('fetching models:', 'kubectl failed');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('list subcommand works', async () => {
-        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test', 'list']);
-        expect(mockExeca).toHaveBeenCalled();
-    });
-    it('create subcommand works', async () => {
-        const command = createModelsCommand({});
-        await command.parseAsync(['node', 'test', 'create', 'my-model']);
-        expect(mockCreateModel).toHaveBeenCalledWith('my-model');
-    });
-});

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

@@ -1,8 +0,0 @@
-import { Model, ArkApiClient } from '../../lib/arkApiClient.js';
-interface ModelSelectorProps {
-    arkApiClient: ArkApiClient;
-    onSelect: (model: Model) => void;
-    onExit: () => void;
-}
-export declare function ModelSelector({ arkApiClient, onSelect, onExit, }: ModelSelectorProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/commands/models/selector.js

@@ -1,53 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, useEffect } from 'react';
-import { Box, Text, useInput } from 'ink';
-export function ModelSelector({ arkApiClient, onSelect, onExit, }) {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const [models, setModels] = useState([]);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-    useEffect(() => {
-        arkApiClient
-            .getModels()
-            .then((fetchedModels) => {
-            setModels(fetchedModels);
-            setLoading(false);
-        })
-            .catch((err) => {
-            setError(err.message || 'Failed to fetch models');
-            setLoading(false);
-        });
-    }, [arkApiClient]);
-    useInput((input, key) => {
-        if (key.escape) {
-            onExit();
-        }
-        else if (key.upArrow || input === 'k') {
-            setSelectedIndex((prev) => (prev === 0 ? models.length - 1 : prev - 1));
-        }
-        else if (key.downArrow || input === 'j') {
-            setSelectedIndex((prev) => (prev === models.length - 1 ? 0 : prev + 1));
-        }
-        else if (key.return) {
-            onSelect(models[selectedIndex]);
-        }
-        else {
-            // Handle number keys for quick selection
-            const num = parseInt(input, 10);
-            if (!isNaN(num) && num >= 1 && num <= models.length) {
-                onSelect(models[num - 1]);
-            }
-        }
-    });
-    if (loading) {
-        return (_jsx(Box, { children: _jsx(Text, { children: "Loading models..." }) }));
-    }
-    if (error) {
-        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }));
-    }
-    if (models.length === 0) {
-        return (_jsx(Box, { children: _jsx(Text, { children: "No models available" }) }));
-    }
-    const selectedModel = models[selectedIndex];
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 2, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Select Model" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Choose a model to start a conversation with" }) }), _jsx(Box, { flexDirection: "column", children: models.map((model, index) => (_jsx(Box, { marginBottom: 0, children: _jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', index + 1, ". ", model.name, model.type ? ` (${model.type})` : ''] }) }, model.name))) }), selectedModel && selectedModel.model && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsxs(Text, { dimColor: true, wrap: "wrap", children: ["Model: ", selectedModel.model] }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Number to select \u00B7 Esc to exit" }) })] }));
-}

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

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

package/dist/commands/routes/index.js

@@ -1,93 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { execa } from 'execa';
-import output from '../../lib/output.js';
-async function listRoutes() {
-    const namespace = 'ark-system';
-    const port = 8080;
-    const portSuffix = `:${port}`;
-    try {
-        // Check if localhost-gateway is installed
-        const { stdout: gatewayCheck } = await execa('kubectl', ['get', 'gateway', 'localhost-gateway', '-n', namespace], { reject: false });
-        if (!gatewayCheck) {
-            output.error("localhost-gateway not installed in namespace 'ark-system'");
-            output.info("run 'ark install' first");
-            process.exit(1);
-        }
-        // Get HTTPRoutes
-        const { stdout: routeOutput } = await execa('kubectl', [
-            'get',
-            'httproutes',
-            '-A',
-            '-o',
-            'custom-columns=NAMESPACE:.metadata.namespace,NAME:.metadata.name,HOSTNAMES:.spec.hostnames',
-            '--no-headers',
-        ], { reject: false });
-        if (!routeOutput || routeOutput.trim() === '') {
-            console.log(chalk.white('available localhost gateway routes: 0'));
-            output.info('no httproutes found. install services to see routes here.');
-            return;
-        }
-        // Parse routes
-        const lines = routeOutput.trim().split('\n');
-        const routes = [];
-        lines.forEach((line) => {
-            const parts = line.split(/\s+/);
-            if (parts.length >= 3) {
-                const name = parts[1];
-                // Remove brackets and split hostnames
-                const hostnamesStr = parts.slice(2).join(' ').replace(/\[|\]/g, '');
-                const hostnames = hostnamesStr
-                    .split(',')
-                    .map((h) => h.trim())
-                    .filter((h) => h && h !== '<none>');
-                if (hostnames.length > 0) {
-                    routes.push({ name, hostnames });
-                }
-            }
-        });
-        // Count total routes (each hostname counts as a route)
-        const routeCount = routes.reduce((count, r) => count + r.hostnames.length, 0);
-        console.log(chalk.white(`available localhost gateway routes: ${routeCount}`));
-        // Check port-forward status
-        const { stdout: psOutput } = await execa('pgrep', ['-f', `kubectl.*port-forward.*${port}:80`], { reject: false });
-        const portForwardActive = !!psOutput;
-        if (portForwardActive) {
-            output.info(`port-forward active on localhost${portSuffix}`);
-        }
-        else {
-            output.error(`port-forward not running on localhost${portSuffix} - routes are not exposed`);
-            console.log(chalk.blue('run:'), `kubectl port-forward -n ${namespace} service/localhost-gateway-nginx ${port}:80 > /dev/null 2>&1 &`);
-        }
-        console.log();
-        // Display routes
-        if (routes.length > 0) {
-            const maxLength = Math.max(...routes.map((r) => r.name.length));
-            routes.forEach((route) => {
-                route.hostnames.forEach((hostname) => {
-                    const url = `http://${hostname}${portSuffix}/`;
-                    const padding = ' '.repeat(maxLength - route.name.length);
-                    if (portForwardActive) {
-                        console.log(`  ${route.name}${padding}: ${chalk.blue(url)}`);
-                    }
-                    else {
-                        console.log(`  ${route.name}${padding}: ${chalk.blue(url)} ${chalk.red('(unavailable)')}`);
-                    }
-                });
-            });
-        }
-    }
-    catch (error) {
-        output.error('failed to fetch routes:', error instanceof Error ? error.message : 'Unknown error');
-        process.exit(1);
-    }
-}
-export function createRoutesCommand(_) {
-    const command = new Command('routes');
-    command
-        .description('show available gateway routes and their urls')
-        .action(async () => {
-        await listRoutes();
-    });
-    return command;
-}

package/dist/commands/routes.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function createRoutesCommand(): Command;