@agents-at-scale/ark 0.1.45 → 0.1.47

package/dist/lib/config.spec.js

@@ -35,6 +35,10 @@ describe('config', () => {
                 streaming: true,
                 outputFormat: 'text',
             },
+            marketplace: {
+                repoUrl: 'https://github.com/mckinsey/agents-at-scale-marketplace',
+                registry: 'oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts',
+            },
         });
     });
     it('loads and merges configs in order: defaults, user, project', () => {
@@ -66,6 +70,21 @@ describe('config', () => {
         expect(config.chat?.streaming).toBe(true);
         expect(config.chat?.outputFormat).toBe('markdown');
     });
+    it('loads queryTimeout from config file', () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue('yaml');
+        mockYaml.parse.mockReturnValue({ queryTimeout: '30m' });
+        const config = loadConfig();
+        expect(config.queryTimeout).toBe('30m');
+    });
+    it('ARK_QUERY_TIMEOUT environment variable overrides config', () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue('yaml');
+        mockYaml.parse.mockReturnValue({ queryTimeout: '5m' });
+        process.env.ARK_QUERY_TIMEOUT = '1h';
+        const config = loadConfig();
+        expect(config.queryTimeout).toBe('1h');
+    });
     it('throws error for invalid YAML', () => {
         const userConfigPath = path.join(os.homedir(), '.arkrc.yaml');
         mockFs.existsSync.mockImplementation((path) => path === userConfigPath);
@@ -96,4 +115,78 @@ describe('config', () => {
         expect(mockYaml.stringify).toHaveBeenCalledWith(config);
         expect(result).toBe('formatted');
     });
+    it('loads marketplace config from config file', () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue('yaml');
+        mockYaml.parse.mockReturnValue({
+            marketplace: {
+                repoUrl: 'https://example.com/my-marketplace',
+                registry: 'oci://example.com/charts',
+            },
+        });
+        const config = loadConfig();
+        expect(config.marketplace?.repoUrl).toBe('https://example.com/my-marketplace');
+        expect(config.marketplace?.registry).toBe('oci://example.com/charts');
+    });
+    it('marketplace environment variables override config', () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue('yaml');
+        mockYaml.parse.mockReturnValue({
+            marketplace: {
+                repoUrl: 'https://example.com/my-marketplace',
+                registry: 'oci://example.com/charts',
+            },
+        });
+        process.env.ARK_MARKETPLACE_REPO_URL = 'https://custom.com/marketplace';
+        process.env.ARK_MARKETPLACE_REGISTRY = 'oci://custom.com/charts';
+        const config = loadConfig();
+        expect(config.marketplace?.repoUrl).toBe('https://custom.com/marketplace');
+        expect(config.marketplace?.registry).toBe('oci://custom.com/charts');
+    });
+});
+describe('marketplace helpers', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env = { ...originalEnv };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it('getMarketplaceRepoUrl returns custom config value', async () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue('yaml');
+        mockYaml.parse.mockReturnValue({
+            marketplace: {
+                repoUrl: 'https://custom-repo.com/marketplace',
+            },
+        });
+        jest.resetModules();
+        const { getMarketplaceRepoUrl } = await import('./config.js');
+        expect(getMarketplaceRepoUrl()).toBe('https://custom-repo.com/marketplace');
+    });
+    it('getMarketplaceRepoUrl returns default value', async () => {
+        mockFs.existsSync.mockReturnValue(false);
+        jest.resetModules();
+        const { getMarketplaceRepoUrl } = await import('./config.js');
+        expect(getMarketplaceRepoUrl()).toBe('https://github.com/mckinsey/agents-at-scale-marketplace');
+    });
+    it('getMarketplaceRegistry returns custom config value', async () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue('yaml');
+        mockYaml.parse.mockReturnValue({
+            marketplace: {
+                registry: 'oci://custom-registry.com/charts',
+            },
+        });
+        jest.resetModules();
+        const { getMarketplaceRegistry } = await import('./config.js');
+        expect(getMarketplaceRegistry()).toBe('oci://custom-registry.com/charts');
+    });
+    it('getMarketplaceRegistry returns default value', async () => {
+        mockFs.existsSync.mockReturnValue(false);
+        jest.resetModules();
+        const { getMarketplaceRegistry } = await import('./config.js');
+        expect(getMarketplaceRegistry()).toBe('oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts');
+    });
 });

package/dist/lib/constants.d.ts

@@ -1,3 +1,6 @@
 export declare const QUERY_ANNOTATIONS: {
     readonly A2A_CONTEXT_ID: "ark.mckinsey.com/a2a-context-id";
 };
+export declare const EVENT_ANNOTATIONS: {
+    readonly EVENT_DATA: "ark.mckinsey.com/event-data";
+};

package/dist/lib/constants.js

@@ -6,3 +6,8 @@ export const QUERY_ANNOTATIONS = {
     // A2A context ID annotation (goes to K8s annotations)
     A2A_CONTEXT_ID: `${ARK_PREFIX}a2a-context-id`,
 };
+// Event annotation constants
+export const EVENT_ANNOTATIONS = {
+    // Event data annotation for structured event data
+    EVENT_DATA: `${ARK_PREFIX}event-data`,
+};

package/dist/lib/executeQuery.js

@@ -7,6 +7,7 @@ import chalk from 'chalk';
 import { ExitCodes } from './errors.js';
 import { ArkApiProxy } from './arkApiProxy.js';
 import { ChatClient } from './chatClient.js';
+import { watchEventsLive } from './kubectl.js';
 export async function executeQuery(options) {
     if (options.outputFormat) {
         return executeQueryWithFormat(options);
@@ -27,9 +28,8 @@ export async function executeQuery(options) {
         let lastAgentName;
         let headerShown = false;
         let firstOutput = true;
-        // Get sessionId from option or environment variable
         const sessionId = options.sessionId || process.env.ARK_SESSION_ID;
-        await chatClient.sendMessage(targetId, messages, { streamingEnabled: true, sessionId }, (chunk, toolCalls, arkMetadata) => {
+        await chatClient.sendMessage(targetId, messages, { streamingEnabled: true, sessionId, queryTimeout: options.timeout }, (chunk, toolCalls, arkMetadata) => {
             if (firstOutput) {
                 spinner.stop();
                 firstOutput = false;
@@ -118,6 +118,12 @@ async function executeQueryWithFormat(options) {
             input: JSON.stringify(queryManifest),
             stdio: ['pipe', 'pipe', 'pipe'],
         });
+        // Give Kubernetes a moment to process the resource before watching
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        if (options.outputFormat === 'events') {
+            await watchEventsLive(queryName);
+            return;
+        }
         const timeoutSeconds = 300;
         await execa('kubectl', [
             'wait',
@@ -134,7 +140,7 @@ async function executeQueryWithFormat(options) {
             console.log(stdout);
         }
         else {
-            console.error(chalk.red(`Invalid output format: ${options.outputFormat}. Use: yaml, json, or name`));
+            console.error(chalk.red(`Invalid output format: ${options.outputFormat}. Use: yaml, json, name, or events`));
             process.exit(ExitCodes.CliError);
         }
     }

package/dist/lib/executeQuery.spec.js

@@ -206,9 +206,12 @@ describe('executeQuery', () => {
             expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringMatching(/cli-query-\d+/));
         });
         it('should include sessionId in query manifest when outputFormat is specified', async () => {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
             let appliedManifest = '';
             mockExeca.mockImplementation(async (command, args) => {
-                if (args.includes('apply') && args.includes('-f') && args.includes('-')) {
+                if (args.includes('apply') &&
+                    args.includes('-f') &&
+                    args.includes('-')) {
                     // Capture the stdin input
                     const stdinIndex = args.indexOf('-');
                     if (stdinIndex >= 0 && args[stdinIndex + 1]) {

package/dist/lib/kubectl.d.ts

@@ -12,4 +12,5 @@ export declare function deleteResource(resourceType: string, name?: string, opti
     all?: boolean;
 }): Promise<void>;
 export declare function replaceResource<T extends K8sResource>(resource: T): Promise<T>;
+export declare function watchEventsLive(queryName: string): Promise<void>;
 export {};

package/dist/lib/kubectl.js

@@ -1,4 +1,6 @@
 import { execa } from 'execa';
+import chalk from 'chalk';
+import { EVENT_ANNOTATIONS } from './constants.js';
 export async function getResource(resourceType, name) {
     if (name === '@latest') {
         const result = await execa('kubectl', [
@@ -45,3 +47,63 @@ export async function replaceResource(resource) {
     });
     return JSON.parse(result.stdout);
 }
+export async function watchEventsLive(queryName) {
+    const seenEvents = new Set();
+    const pollEvents = async () => {
+        try {
+            const { stdout } = await execa('kubectl', [
+                'get',
+                'events',
+                '--field-selector',
+                `involvedObject.name=${queryName}`,
+                '-o',
+                'json',
+            ]);
+            const eventsData = JSON.parse(stdout);
+            for (const event of eventsData.items || []) {
+                const eventId = event.metadata?.uid;
+                if (eventId && !seenEvents.has(eventId)) {
+                    seenEvents.add(eventId);
+                    const annotations = event.metadata?.annotations || {};
+                    const eventData = annotations[EVENT_ANNOTATIONS.EVENT_DATA];
+                    if (eventData) {
+                        const now = new Date();
+                        const hours = now.getHours().toString().padStart(2, '0');
+                        const minutes = now.getMinutes().toString().padStart(2, '0');
+                        const seconds = now.getSeconds().toString().padStart(2, '0');
+                        const millis = now.getMilliseconds().toString().padStart(3, '0');
+                        const timestamp = `${hours}:${minutes}:${seconds}.${millis}`;
+                        const reason = event.reason || 'Unknown';
+                        const eventType = event.type || 'Normal';
+                        const colorCode = eventType === 'Normal' ? 32 : eventType === 'Warning' ? 33 : 31;
+                        console.log(`${timestamp} \x1b[${colorCode}m${reason}\x1b[0m ${eventData}`);
+                    }
+                }
+            }
+            // eslint-disable-next-line no-empty, @typescript-eslint/no-unused-vars
+        }
+        catch (error) { }
+    };
+    const pollInterval = setInterval(pollEvents, 200);
+    const timeoutSeconds = 300;
+    const waitProcess = execa('kubectl', [
+        'wait',
+        '--for=condition=Completed',
+        `query/${queryName}`,
+        `--timeout=${timeoutSeconds}s`,
+    ], {
+        timeout: timeoutSeconds * 1000,
+    });
+    try {
+        await waitProcess;
+        await pollEvents();
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        await pollEvents();
+    }
+    catch (error) {
+        console.error(chalk.red('Query wait failed:', error instanceof Error ? error.message : 'Unknown error'));
+    }
+    finally {
+        clearInterval(pollInterval);
+    }
+}

package/dist/lib/marketplaceFetcher.d.ts

@@ -0,0 +1,6 @@
+import type { ArkService, ServiceCollection } from '../types/arkService.js';
+import type { AnthropicMarketplaceManifest, AnthropicMarketplaceItem } from '../types/marketplace.js';
+export declare function fetchMarketplaceManifest(): Promise<AnthropicMarketplaceManifest | null>;
+export declare function mapMarketplaceItemToArkService(item: AnthropicMarketplaceItem, registry?: string): ArkService;
+export declare function getMarketplaceServicesFromManifest(): Promise<ServiceCollection | null>;
+export declare function getMarketplaceAgentsFromManifest(): Promise<ServiceCollection | null>;

package/dist/lib/marketplaceFetcher.js

@@ -0,0 +1,80 @@
+import axios from 'axios';
+import { getMarketplaceRepoUrl, getMarketplaceRegistry } from './config.js';
+export async function fetchMarketplaceManifest() {
+    const repoUrl = getMarketplaceRepoUrl();
+    const manifestUrl = `${repoUrl}/raw/main/marketplace.json`;
+    try {
+        const response = await axios.get(manifestUrl, {
+            timeout: 10000,
+            headers: {
+                Accept: 'application/json',
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
+                return null;
+            }
+        }
+        return null;
+    }
+}
+export function mapMarketplaceItemToArkService(item, registry) {
+    const defaultRegistry = registry || getMarketplaceRegistry();
+    const serviceName = item.name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .replace(/^-+|-+$/g, '');
+    const chartPath = item.ark?.chartPath || `${defaultRegistry}/${serviceName}`;
+    return {
+        name: serviceName,
+        helmReleaseName: item.ark?.helmReleaseName || serviceName,
+        description: item.description,
+        enabled: true,
+        category: 'marketplace',
+        namespace: item.ark?.namespace || serviceName,
+        chartPath,
+        installArgs: item.ark?.installArgs || ['--create-namespace'],
+        k8sServiceName: item.ark?.k8sServiceName || serviceName,
+        k8sServicePort: item.ark?.k8sServicePort,
+        k8sPortForwardLocalPort: item.ark?.k8sPortForwardLocalPort,
+        k8sDeploymentName: item.ark?.k8sDeploymentName || serviceName,
+        k8sDevDeploymentName: item.ark?.k8sDevDeploymentName,
+    };
+}
+export async function getMarketplaceServicesFromManifest() {
+    const manifest = await fetchMarketplaceManifest();
+    if (!manifest || !manifest.items) {
+        return null;
+    }
+    const services = {};
+    for (const item of manifest.items) {
+        if (item.ark && item.type === 'service') {
+            const serviceName = item.name
+                .toLowerCase()
+                .replace(/[^a-z0-9-]/g, '-')
+                .replace(/^-+|-+$/g, '');
+            services[serviceName] = mapMarketplaceItemToArkService(item);
+        }
+    }
+    return Object.keys(services).length > 0 ? services : null;
+}
+export async function getMarketplaceAgentsFromManifest() {
+    const manifest = await fetchMarketplaceManifest();
+    if (!manifest || !manifest.items) {
+        return null;
+    }
+    const agents = {};
+    for (const item of manifest.items) {
+        if (item.ark && item.type === 'agent') {
+            const agentName = item.name
+                .toLowerCase()
+                .replace(/[^a-z0-9-]/g, '-')
+                .replace(/^-+|-+$/g, '');
+            agents[agentName] = mapMarketplaceItemToArkService(item);
+        }
+    }
+    return Object.keys(agents).length > 0 ? agents : null;
+}

package/dist/lib/marketplaceFetcher.spec.d.ts

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

package/dist/lib/marketplaceFetcher.spec.js

@@ -0,0 +1,225 @@
+import { jest } from '@jest/globals';
+const mockAxiosGet = jest.fn();
+jest.unstable_mockModule('axios', () => ({
+    default: {
+        get: mockAxiosGet,
+        isAxiosError: (error) => {
+            return (typeof error === 'object' &&
+                error !== null &&
+                'isAxiosError' in error &&
+                error.isAxiosError === true);
+        },
+    },
+}));
+const mockGetMarketplaceRepoUrl = jest.fn();
+const mockGetMarketplaceRegistry = jest.fn();
+jest.unstable_mockModule('./config.js', () => ({
+    getMarketplaceRepoUrl: mockGetMarketplaceRepoUrl,
+    getMarketplaceRegistry: mockGetMarketplaceRegistry,
+}));
+const { fetchMarketplaceManifest, mapMarketplaceItemToArkService, getMarketplaceServicesFromManifest, } = await import('./marketplaceFetcher.js');
+describe('marketplaceFetcher', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockAxiosGet.mockClear();
+        mockGetMarketplaceRepoUrl.mockReturnValue('https://test-repo.example.com/marketplace');
+        mockGetMarketplaceRegistry.mockReturnValue('oci://test-registry.example.com/charts');
+    });
+    describe('fetchMarketplaceManifest', () => {
+        it('fetches and returns manifest successfully', async () => {
+            const mockManifest = {
+                version: '1.0.0',
+                marketplace: 'ARK Marketplace',
+                items: [
+                    {
+                        name: 'test-service',
+                        description: 'Test service',
+                        ark: {
+                            chartPath: 'oci://registry/test-service',
+                            namespace: 'test',
+                        },
+                    },
+                ],
+            };
+            mockAxiosGet.mockResolvedValue({
+                data: mockManifest,
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: {},
+            });
+            const result = await fetchMarketplaceManifest();
+            expect(result).toEqual(mockManifest);
+            expect(mockAxiosGet).toHaveBeenCalledWith(expect.stringContaining('marketplace.json'), expect.objectContaining({
+                timeout: 10000,
+                headers: { Accept: 'application/json' },
+            }));
+        });
+        it('returns null on network error', async () => {
+            const networkError = new Error('Network error');
+            networkError.code = 'ENOTFOUND';
+            networkError.isAxiosError = true;
+            mockAxiosGet.mockRejectedValue(networkError);
+            const result = await fetchMarketplaceManifest();
+            expect(result).toBeNull();
+        });
+        it('returns null on connection refused', async () => {
+            const connectionError = Object.assign(new Error('Connection refused'), {
+                code: 'ECONNREFUSED',
+                isAxiosError: true,
+            });
+            mockAxiosGet.mockRejectedValue(connectionError);
+            const result = await fetchMarketplaceManifest();
+            expect(result).toBeNull();
+        });
+    });
+    describe('mapMarketplaceItemToArkService', () => {
+        it('maps marketplace item to ARK service correctly', () => {
+            const item = {
+                name: 'test-service',
+                description: 'Test description',
+                ark: {
+                    chartPath: 'oci://registry/test',
+                    namespace: 'test-ns',
+                    helmReleaseName: 'test-release',
+                    installArgs: ['--create-namespace'],
+                    k8sServiceName: 'test-svc',
+                    k8sServicePort: 8080,
+                    k8sDeploymentName: 'test-deploy',
+                },
+            };
+            const result = mapMarketplaceItemToArkService(item);
+            expect(result).toEqual({
+                name: 'test-service',
+                helmReleaseName: 'test-release',
+                description: 'Test description',
+                enabled: true,
+                category: 'marketplace',
+                namespace: 'test-ns',
+                chartPath: 'oci://registry/test',
+                installArgs: ['--create-namespace'],
+                k8sServiceName: 'test-svc',
+                k8sServicePort: 8080,
+                k8sDeploymentName: 'test-deploy',
+            });
+        });
+        it('uses defaults when ark fields are missing', () => {
+            const item = {
+                name: 'simple-service',
+                description: 'Simple service',
+                ark: {},
+            };
+            const result = mapMarketplaceItemToArkService(item);
+            expect(result.name).toBe('simple-service');
+            expect(result.helmReleaseName).toBe('simple-service');
+            expect(result.namespace).toBe('simple-service');
+            expect(result.chartPath).toContain('simple-service');
+        });
+        it('sanitizes service name', () => {
+            const item = {
+                name: 'Test Service 123!',
+                description: 'Test',
+                ark: {},
+            };
+            const result = mapMarketplaceItemToArkService(item);
+            expect(result.name).toBe('test-service-123');
+        });
+    });
+    describe('getMarketplaceServicesFromManifest', () => {
+        it('converts manifest items to service collection', async () => {
+            const mockManifest = {
+                version: '1.0.0',
+                marketplace: 'ARK Marketplace',
+                items: [
+                    {
+                        name: 'service1',
+                        description: 'Service 1',
+                        type: 'service',
+                        ark: {
+                            chartPath: 'oci://registry/service1',
+                            namespace: 'ns1',
+                        },
+                    },
+                    {
+                        name: 'service2',
+                        description: 'Service 2',
+                        type: 'service',
+                        ark: {
+                            chartPath: 'oci://registry/service2',
+                            namespace: 'ns2',
+                        },
+                    },
+                ],
+            };
+            mockAxiosGet.mockResolvedValue({
+                data: mockManifest,
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: {},
+            });
+            const result = await getMarketplaceServicesFromManifest();
+            expect(result).not.toBeNull();
+            expect(result?.['service1']).toBeDefined();
+            expect(result?.['service2']).toBeDefined();
+            expect(result?.['service1']?.description).toBe('Service 1');
+            expect(result?.['service2']?.description).toBe('Service 2');
+        });
+        it('filters out items without ark field', async () => {
+            const mockManifest = {
+                version: '1.0.0',
+                marketplace: 'ARK Marketplace',
+                items: [
+                    {
+                        name: 'service1',
+                        description: 'Service 1',
+                        type: 'service',
+                        ark: {
+                            chartPath: 'oci://registry/service1',
+                        },
+                    },
+                    {
+                        name: 'service2',
+                        description: 'Service 2',
+                        type: 'service',
+                    },
+                ],
+            };
+            mockAxiosGet.mockResolvedValue({
+                data: mockManifest,
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: {},
+            });
+            const result = await getMarketplaceServicesFromManifest();
+            expect(result).not.toBeNull();
+            expect(result?.['service1']).toBeDefined();
+            expect(result?.['service2']).toBeUndefined();
+        });
+        it('returns null when manifest fetch fails', async () => {
+            const networkError = new Error('Network error');
+            networkError.code = 'ENOTFOUND';
+            networkError.isAxiosError = true;
+            mockAxiosGet.mockRejectedValue(networkError);
+            const result = await getMarketplaceServicesFromManifest();
+            expect(result).toBeNull();
+        });
+        it('returns null when manifest has no items', async () => {
+            const mockManifest = {
+                version: '1.0.0',
+                marketplace: 'ARK Marketplace',
+                items: [],
+            };
+            mockAxiosGet.mockResolvedValue({
+                data: mockManifest,
+                status: 200,
+                statusText: 'OK',
+                headers: {},
+                config: {},
+            });
+            const result = await getMarketplaceServicesFromManifest();
+            expect(result).toBeNull();
+        });
+    });
+});

package/dist/marketplaceServices.d.ts

@@ -2,14 +2,23 @@
  * Marketplace service definitions for external ARK marketplace resources
  * Repository: https://github.com/mckinsey/agents-at-scale-marketplace
  * Charts are installed from the public OCI registry
+ *
+ * Supports Anthropic Marketplace JSON format for dynamic enumeration
  */
 import type { ArkService, ServiceCollection } from './types/arkService.js';
 /**
- * Available marketplace services
- * Charts are published to: oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts
+ * Get all marketplace services, fetching from marketplace.json
+ * Returns null if marketplace is unavailable
  */
-export declare const marketplaceServices: ServiceCollection;
-export declare function getMarketplaceService(name: string): ArkService | undefined;
-export declare function getAllMarketplaceServices(): ServiceCollection;
+export declare function getAllMarketplaceServices(): Promise<ServiceCollection | null>;
+/**
+ * Get all marketplace agents, fetching from marketplace.json
+ * Returns null if marketplace is unavailable
+ */
+export declare function getAllMarketplaceAgents(): Promise<ServiceCollection | null>;
+/**
+ * Get a marketplace item by path (supports both services and agents)
+ * Returns null if marketplace is unavailable
+ */
+export declare function getMarketplaceItem(path: string): Promise<ArkService | undefined | null>;
 export declare function isMarketplaceService(name: string): boolean;
-export declare function extractMarketplaceServiceName(path: string): string;