@agents-at-scale/ark 0.1.46 → 0.1.49

package/.arkrc.template.yaml

@@ -0,0 +1,51 @@
+# Ark CLI Configuration Template
+# Copy this to ~/.arkrc.yaml (user config) or .arkrc.yaml (project config)
+# All fields are optional - only include what you want to override
+
+# Chat configuration
+chat:
+  # Enable/disable streaming for chat responses (default: true)
+  # streaming: true
+
+  # Output format: 'text' or 'markdown' (default: text)
+  # outputFormat: text
+
+# Service configuration
+services:
+  # Reuse existing kubectl port-forward processes instead of failing (default: false)
+  # reusePortForwards: false
+
+  # Service overrides - customize specific Ark services
+  # Example: Enable localhost-gateway
+  # localhost-gateway:
+  #   enabled: true
+
+  # Example: Change namespace
+  # ark-controller:
+  #   namespace: custom-namespace
+
+  # Example: Add custom install arguments
+  # ark-api:
+  #   installArgs:
+  #     - --set
+  #     - replicas=3
+
+  # Example: Configure Agents @ Scale with container registry
+  # agents-at-scale:
+  #   enabled: true
+  #   installArgs:
+  #     - --set
+  #     - containerRegistry.enabled=true
+  #     - --set
+  #     - containerRegistry.username=YOUR_USERNAME
+  #     - --set
+  #     - containerRegistry.password=YOUR_PASSWORD
+
+# Available service properties:
+#   enabled: boolean           - Enable/disable service installation
+#   namespace: string          - Kubernetes namespace
+#   chartPath: string          - Custom Helm chart path
+#   installArgs: string[]      - Additional Helm install arguments
+#   k8sServiceName: string     - Kubernetes service name for port forwarding
+#   k8sServicePort: number     - Kubernetes service port for port forwarding
+#   k8sPortForwardLocalPort: number - Local port for port forwarding

package/README.md

@@ -46,6 +46,8 @@ To troubleshoot an installation, run `ark status`.
 
 You can customize Ark service installations using a `.arkrc.yaml` file in your home directory (`~/.arkrc.yaml`) or project directory. This allows you to override service properties like enabled status, namespace, or chart location.
 
+See [`.arkrc.template.yaml`](.arkrc.template.yaml) for a complete reference of all available configuration options.
+
 Example `.arkrc.yaml`:
 
 ```yaml
@@ -76,3 +78,5 @@ services:
 ```
 
 Replace `YOUR_USERNAME` and `YOUR_PASSWORD` with your JFrog credentials.
+
+See [.arkrc.yaml.sample](.arkrc.yaml.sample) for a complete example with all available options.

package/dist/arkServices.js

@@ -1,7 +1,7 @@
 /**
  * Centralized ARK service definitions used by both install and status commands
  */
-import { loadConfig } from './lib/config.js';
+import { loadConfig, getMarketplaceRegistry } from './lib/config.js';
 const REGISTRY_BASE = 'oci://ghcr.io/mckinsey/agents-at-scale-ark/charts';
 /**
  * Dependencies that should be installed before ARK services
@@ -119,17 +119,17 @@ const defaultArkServices = {
         k8sDeploymentName: 'ark-mcp',
         k8sDevDeploymentName: 'ark-mcp-devspace',
     },
-    'ark-cluster-memory': {
-        name: 'ark-cluster-memory',
-        helmReleaseName: 'ark-cluster-memory',
+    'ark-broker': {
+        name: 'ark-broker',
+        helmReleaseName: 'ark-broker',
         description: 'In-memory storage service with streaming support for Ark queries',
         enabled: true,
         category: 'service',
         // namespace: undefined - uses current context namespace
-        chartPath: `${REGISTRY_BASE}/ark-cluster-memory`,
+        chartPath: `${REGISTRY_BASE}/ark-broker`,
         installArgs: [],
-        k8sDeploymentName: 'ark-cluster-memory',
-        k8sDevDeploymentName: 'ark-cluster-memory-devspace',
+        k8sDeploymentName: 'ark-broker',
+        k8sDevDeploymentName: 'ark-broker-devspace',
     },
     'mcp-filesystem': {
         name: 'mcp-filesystem',
@@ -153,13 +153,27 @@ const defaultArkServices = {
         chartPath: `${REGISTRY_BASE}/localhost-gateway`,
         installArgs: [],
     },
+    'noah': {
+        name: 'noah',
+        helmReleaseName: 'noah',
+        description: 'Runtime administration agent with cluster privileges',
+        enabled: true,
+        category: 'service',
+        chartPath: `${getMarketplaceRegistry()}/noah`,
+        installArgs: [],
+        k8sServiceName: 'noah-mcp',
+        k8sServicePort: 8639,
+        k8sDeploymentName: 'noah-mcp',
+    },
 };
 function applyConfigOverrides(defaults) {
     const config = loadConfig();
     const overrides = config?.services || {};
     const result = {};
     for (const [key, service] of Object.entries(defaults)) {
-        result[key] = overrides[key] ? { ...service, ...overrides[key] } : service;
+        const override = overrides[key];
+        result[key] =
+            override && typeof override === 'object' ? { ...service, ...override } : service;
     }
     return result;
 }

package/dist/arkServices.spec.js

@@ -1,12 +1,18 @@
 import { jest } from '@jest/globals';
 const mockLoadConfig = jest.fn();
+const mockGetMarketplaceRegistry = jest.fn();
 jest.unstable_mockModule('./lib/config.js', () => ({
     loadConfig: mockLoadConfig,
+    getMarketplaceRegistry: mockGetMarketplaceRegistry,
 }));
+mockLoadConfig.mockReturnValue({});
+mockGetMarketplaceRegistry.mockReturnValue('oci://test-registry/charts');
 const { arkDependencies, arkServices: originalArkServices, getInstallableServices, } = await import('./arkServices.js');
 describe('arkServices', () => {
     beforeEach(() => {
         jest.clearAllMocks();
+        mockLoadConfig.mockReturnValue({});
+        mockGetMarketplaceRegistry.mockReturnValue('oci://test-registry/charts');
     });
     it('exports arkDependencies with expected structure', () => {
         expect(arkDependencies).toBeDefined();

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

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

package/dist/commands/agents/index.js

@@ -30,7 +30,7 @@ async function listAgents(options) {
         process.exit(1);
     }
 }
-export function createAgentsCommand(_) {
+export function createAgentsCommand(config) {
     const agentsCommand = new Command('agents');
     agentsCommand
         .description('list available agents')
@@ -54,11 +54,13 @@ export function createAgentsCommand(_) {
         .description('Query an agent')
         .argument('<name>', 'Agent name')
         .argument('<message>', 'Message to send')
-        .action(async (name, message) => {
+        .option('--timeout <timeout>', 'Query timeout (e.g., 30s, 5m, 1h)')
+        .action(async (name, message, options) => {
         await executeQuery({
             targetType: 'agent',
             targetName: name,
             message,
+            timeout: options.timeout || config.queryTimeout,
         });
     });
     return agentsCommand;

package/dist/commands/chat/index.js

@@ -14,7 +14,7 @@ export function createChatCommand(config) {
         const initialTargetId = targetArg;
         // Config is passed from main
         try {
-            const proxy = new ArkApiProxy();
+            const proxy = new ArkApiProxy(undefined, config.services?.reusePortForwards ?? false);
             const arkApiClient = await proxy.start();
             render(_jsx(ChatUI, { initialTargetId: initialTargetId, arkApiClient: arkApiClient, arkApiProxy: proxy, config: config }));
         }

package/dist/commands/completion/index.js

@@ -28,7 +28,7 @@ _ark_completion() {
   
   case \${COMP_CWORD} in
     1)
-      opts="agents chat cluster completion config dashboard docs generate install marketplace models queries query routes status targets teams tools uninstall help"
+      opts="agents chat cluster completion config dashboard docs evaluation export generate import install marketplace memory models queries query routes status targets teams tools uninstall help"
       COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
       return 0
       ;;
@@ -84,15 +84,18 @@ _ark_completion() {
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
           return 0
           ;;
+        memory)
+          opts="list ls delete reset"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
         install)
-          # Suggest marketplace services with marketplace/services/ prefix
-          opts="marketplace/services/phoenix marketplace/services/langfuse"
+          opts="marketplace/services/phoenix marketplace/services/langfuse marketplace/agents/noah"
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
           return 0
           ;;
         uninstall)
-          # Suggest marketplace services with marketplace/services/ prefix
-          opts="marketplace/services/phoenix marketplace/services/langfuse"
+          opts="marketplace/services/phoenix marketplace/services/langfuse marketplace/agents/noah"
           COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
           return 0
           ;;
@@ -157,9 +160,13 @@ _ark() {
         'config[Configuration management]' \\
         'dashboard[Open ARK dashboard]' \\
         'docs[Open ARK documentation]' \\
+        'evaluation[Execute evaluations against evaluators]' \\
+        'export[Export ARK resources to a file]' \\
         'generate[Generate ARK resources]' \\
+        'import[Import ARK resources from a file]' \\
         'install[Install ARK services]' \\
         'marketplace[Manage marketplace services]' \\
+        'memory[Manage memory sessions and queries]' \\
         'models[List available models]' \\
         'queries[Manage query resources]' \\
         'query[Execute a single query]' \\
@@ -227,6 +234,13 @@ _ark() {
             'list[List available marketplace services]' \\
             'ls[List available marketplace services]'
           ;;
+        memory)
+          _values 'memory commands' \\
+            'list[List all sessions]' \\
+            'ls[List all sessions]' \\
+            'delete[Delete memory data]' \\
+            'reset[Delete memory data]'
+          ;;
         install)
           _values 'services to install' \\
             'marketplace/services/phoenix[Phoenix observability platform]' \\

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

@@ -1,4 +1,4 @@
 import { Command } from 'commander';
 import type { ArkConfig } from '../../lib/config.js';
-export declare function openDashboard(): Promise<void>;
-export declare function createDashboardCommand(_: ArkConfig): Command;
+export declare function openDashboard(config: ArkConfig): Promise<void>;
+export declare function createDashboardCommand(config: ArkConfig): Command;

package/dist/commands/dashboard/index.js

@@ -4,11 +4,12 @@ import open from 'open';
 import ora from 'ora';
 import { ArkServiceProxy } from '../../lib/arkServiceProxy.js';
 import { arkServices } from '../../arkServices.js';
-export async function openDashboard() {
+export async function openDashboard(config) {
     const spinner = ora('Connecting to dashboard').start();
     try {
         const dashboardService = arkServices['ark-dashboard'];
-        const proxy = new ArkServiceProxy(dashboardService, 3274); // DASH on phone keypad
+        const proxy = new ArkServiceProxy(dashboardService, 3274, // DASH on phone keypad
+        config.services?.reusePortForwards ?? false);
         const url = await proxy.start();
         spinner.succeed('Dashboard connected');
         console.log(`ARK dashboard running on: ${chalk.green(url)}`);
@@ -30,10 +31,10 @@ export async function openDashboard() {
         process.exit(1);
     }
 }
-export function createDashboardCommand(_) {
+export function createDashboardCommand(config) {
     const dashboardCommand = new Command('dashboard');
     dashboardCommand
         .description('Open the ARK dashboard in your browser')
-        .action(openDashboard);
+        .action(() => openDashboard(config));
     return dashboardCommand;
 }

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

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

package/dist/commands/export/index.js

@@ -0,0 +1,73 @@
+import { Command } from 'commander';
+import * as fs from 'fs/promises';
+import yaml from 'yaml';
+import { listResources } from '../../lib/kubectl.js';
+import output from '../../lib/output.js';
+// resource types in dependency order so that they can be loaded correctly
+// by default these will all be exported if not specified; can be overridden with defaultExportTypes in config
+const RESOURCE_ORDER = [
+    'secrets',
+    'tools',
+    'models',
+    'agents',
+    'teams',
+    'evaluators',
+    'mcpservers',
+    'a2aservers',
+];
+async function exportResources(options, config) {
+    try {
+        const allResourceTypes = config.defaultExportTypes || RESOURCE_ORDER;
+        const outputPath = options.output || 'ark-export.yaml';
+        let resourceTypes = options.types
+            ? (options.types.split(','))
+            : allResourceTypes;
+        // ensure that we get resources in the correct order; e.g. agents before teams that use the agents
+        resourceTypes.sort((a, b) => {
+            return RESOURCE_ORDER.indexOf(a) - RESOURCE_ORDER.indexOf(b);
+        });
+        output.info(`exporting ark resources to ${outputPath}...`);
+        const allResources = [];
+        let allResourceCount = 0;
+        for (const resourceType of resourceTypes) {
+            if (!RESOURCE_ORDER.includes(resourceType)) {
+                output.warning(`unknown resource type: ${resourceType}, skipping`);
+                continue;
+            }
+            output.info(`fetching ${resourceType}...`);
+            const resources = await listResources(resourceType, {
+                namespace: options.namespace,
+                labels: options.labels
+            });
+            const resourceCount = resources.length;
+            if (resources.length > 0) {
+                output.success(`found ${resourceCount} ${resourceType}`);
+                allResources.push(...resources);
+                allResourceCount += resourceCount;
+            }
+        }
+        if (allResourceCount === 0) {
+            output.warning('no resources found to export');
+            return;
+        }
+        const yamlContent = allResources.map((resource) => yaml.stringify(resource)).join("\n---\n");
+        await fs.writeFile(outputPath, yamlContent, 'utf-8');
+        output.success(`exported ${allResourceCount} resources to ${outputPath}`);
+    }
+    catch (error) {
+        output.error('export failed:', error instanceof Error ? error.message : error);
+    }
+}
+export function createExportCommand(config) {
+    const exportCommand = new Command('export');
+    exportCommand
+        .description('export ARK resources to a file')
+        .option('-o, --output <file>', 'output file path', 'ark-export.yaml')
+        .option('-n, --namespace <namespace>', 'namespace to export from')
+        .option('-t, --types <types>', 'comma-separated list of resource types to export')
+        .option('-l, --labels <labels>', 'label selector to filter resources')
+        .action(async (options) => {
+        await exportResources(options, config);
+    });
+    return exportCommand;
+}

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

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

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

@@ -0,0 +1,145 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockWriteFile = jest.fn();
+jest.unstable_mockModule('fs/promises', () => ({
+    writeFile: mockWriteFile,
+}));
+const mockOutput = {
+    info: jest.fn(),
+    success: jest.fn(),
+    warning: jest.fn(),
+    error: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+const mockKubectlGetResponse = {
+    "apiVersion": "v1",
+    "items": [{ "spec": "foo" }],
+    "kind": "List",
+    "metadata": {
+        "resourceVersion": ""
+    }
+};
+const { createExportCommand } = await import('./index.js');
+describe('export command', () => {
+    const mockConfig = {};
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should create export command with correct description', () => {
+        const command = createExportCommand(mockConfig);
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('export');
+        expect(command.description()).toBe('export ARK resources to a file');
+    });
+    it('should export all resource types by default', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync(['node', 'test', '-o', 'test.yaml']);
+        const expectedResourceTypes = [
+            'secrets',
+            'tools',
+            'models',
+            'agents',
+            'teams',
+            'evaluators',
+            'mcpservers',
+            'a2aservers',
+        ];
+        expect(mockExeca).toHaveBeenCalledTimes(expectedResourceTypes.length);
+        for (const resourceType of expectedResourceTypes) {
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['get', resourceType, '-o', 'json']), expect.any(Object));
+            expect(mockOutput.success).toHaveBeenCalledWith(`found 1 ${resourceType}`);
+        }
+        expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    });
+    it('should export types specified in config in dependency order', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const newDefaultTypes = ['teams', 'agents'];
+        const modifiedConfig = { defaultExportTypes: newDefaultTypes };
+        const command = createExportCommand(modifiedConfig);
+        await command.parseAsync(['node', 'test', '-o', 'test.yaml']);
+        expect(mockExeca.mock.calls).toEqual([
+            ['kubectl', expect.arrayContaining(['get', 'agents']), expect.any(Object)],
+            ['kubectl', expect.arrayContaining(['get', 'teams']), expect.any(Object)],
+        ]);
+        expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    });
+    it('should filter by resource types when specified and export in order', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync([
+            'node',
+            'test',
+            '-t',
+            'agents,models',
+            '-o',
+            'test.yaml',
+        ]);
+        expect(mockExeca.mock.calls).toEqual([
+            ['kubectl', expect.arrayContaining(['get', 'models']), expect.any(Object)],
+            ['kubectl', expect.arrayContaining(['get', 'agents']), expect.any(Object)],
+        ]);
+    });
+    it('should use namespace filter when specified', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync([
+            'node',
+            'test',
+            '-n',
+            'custom-namespace',
+            '-t',
+            'agents',
+            '-o',
+            'test.yaml',
+        ]);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['-n', 'custom-namespace']), expect.any(Object));
+        expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    });
+    it('should use label selector when specified', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockKubectlGetResponse),
+        });
+        mockWriteFile.mockResolvedValue(undefined);
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync([
+            'node',
+            'test',
+            '-l',
+            'app=test',
+            '-t',
+            'agents',
+            '-o',
+            'test.yaml',
+        ]);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['-l', 'app=test']), expect.any(Object));
+        expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    });
+    it('fails if kubectl get fails for a resource type', async () => {
+        mockExeca.mockRejectedValue('Export broke');
+        const command = createExportCommand(mockConfig);
+        await command.parseAsync(['node', 'test']);
+        expect(mockOutput.error).toHaveBeenCalledWith('export failed:', 'Export broke');
+    });
+});

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

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

package/dist/commands/import/index.js

@@ -0,0 +1,27 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import output from '../../lib/output.js';
+async function importResources(filepath) {
+    try {
+        output.info(`importing ark resources from ${filepath}...`);
+        const args = ['create', '-f', filepath];
+        const result = await execa('kubectl', args, {
+            stdio: 'pipe',
+        });
+        output.success(`imported resources from ${filepath}`);
+    }
+    catch (error) {
+        output.error('import failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+export function createImportCommand(_) {
+    const importCommand = new Command('import');
+    importCommand
+        .description('import ARK resources from a file')
+        .argument('<filepath>', 'input file path')
+        .action(async (filepath) => {
+        await importResources(filepath);
+    });
+    return importCommand;
+}

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

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

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

@@ -0,0 +1,46 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockOutput = {
+    info: jest.fn(),
+    success: jest.fn(),
+    warning: jest.fn(),
+    error: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+const { createImportCommand } = await import('./index.js');
+describe('import command', () => {
+    const mockConfig = {};
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should create import command with correct description', () => {
+        const command = createImportCommand(mockConfig);
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('import');
+        expect(command.description()).toBe('import ARK resources from a file');
+    });
+    it('should use kubectl to import', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify({ items: [] }),
+        });
+        const command = createImportCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'test.yaml']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['create', '-f', 'test.yaml'], expect.any(Object));
+    });
+    it('exits with error when kubectl create has error', async () => {
+        mockExeca.mockRejectedValue('Import broke');
+        const command = createImportCommand(mockConfig);
+        await expect(command.parseAsync(['node', 'test', 'test.yaml'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('import failed:', 'Import broke');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

package/dist/commands/install/index.js

@@ -5,7 +5,7 @@ import inquirer from 'inquirer';
 import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
 import { getInstallableServices, arkDependencies, arkServices, } from '../../arkServices.js';
-import { isMarketplaceService, extractMarketplaceServiceName, getMarketplaceService, getAllMarketplaceServices, } from '../../marketplaceServices.js';
+import { isMarketplaceService, getMarketplaceItem, getAllMarketplaceServices, getAllMarketplaceAgents, } from '../../marketplaceServices.js';
 import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
 import { waitForServicesReady, } from '../../lib/waitForReady.js';
@@ -42,20 +42,30 @@ export async function installArk(config, serviceName, options = {}) {
     console.log(); // Add blank line after cluster info
     // If a specific service is requested, install only that service
     if (serviceName) {
-        // Check if it's a marketplace service
+        // Check if it's a marketplace item
         if (isMarketplaceService(serviceName)) {
-            const marketplaceServiceName = extractMarketplaceServiceName(serviceName);
-            const service = getMarketplaceService(marketplaceServiceName);
+            const service = await getMarketplaceItem(serviceName);
             if (!service) {
-                output.error(`marketplace service '${marketplaceServiceName}' not found`);
-                output.info('available marketplace services:');
-                const marketplaceServices = getAllMarketplaceServices();
-                for (const serviceName of Object.keys(marketplaceServices)) {
-                    output.info(`  marketplace/services/${serviceName}`);
+                output.error(`marketplace item '${serviceName}' not found`);
+                output.info('available marketplace items:');
+                const marketplaceServices = await getAllMarketplaceServices();
+                if (marketplaceServices) {
+                    for (const name of Object.keys(marketplaceServices)) {
+                        output.info(`  marketplace/services/${name}`);
+                    }
+                }
+                const marketplaceAgents = await getAllMarketplaceAgents();
+                if (marketplaceAgents) {
+                    for (const name of Object.keys(marketplaceAgents)) {
+                        output.info(`  marketplace/agents/${name}`);
+                    }
+                }
+                if (!marketplaceServices && !marketplaceAgents) {
+                    output.warning('Marketplace unavailable');
                 }
                 process.exit(1);
             }
-            output.info(`installing marketplace service ${service.name}...`);
+            output.info(`installing marketplace item ${service.name}...`);
             try {
                 await installService(service, options.verbose);
                 output.success(`${service.name} installed successfully`);