@agents-at-scale/ark 0.1.46 → 0.1.49

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/lib/types.d.ts

@@ -122,6 +122,7 @@ export interface Query {
         input: string;
         targets: QueryTarget[];
         sessionId?: string;
+        conversationId?: string;
         timeout?: string;
     };
     status?: QueryStatus;

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;

package/dist/marketplaceServices.js

@@ -2,50 +2,48 @@
  * 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
  */
-const MARKETPLACE_REGISTRY = 'oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts';
+import { getMarketplaceServicesFromManifest, getMarketplaceAgentsFromManifest, } from './lib/marketplaceFetcher.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 const marketplaceServices = {
-    phoenix: {
-        name: 'phoenix',
-        helmReleaseName: 'phoenix',
-        description: 'AI/ML observability and evaluation platform with OpenTelemetry integration',
-        enabled: true,
-        category: 'marketplace',
-        namespace: 'phoenix',
-        chartPath: `${MARKETPLACE_REGISTRY}/phoenix`,
-        installArgs: ['--create-namespace'],
-        k8sServiceName: 'phoenix',
-        k8sServicePort: 6006,
-        k8sDeploymentName: 'phoenix',
-    },
-    langfuse: {
-        name: 'langfuse',
-        helmReleaseName: 'langfuse',
-        description: 'Open-source LLM observability and analytics platform with session tracking',
-        enabled: true,
-        category: 'marketplace',
-        namespace: 'telemetry',
-        chartPath: `${MARKETPLACE_REGISTRY}/langfuse`,
-        installArgs: ['--create-namespace'],
-        k8sServiceName: 'langfuse',
-        k8sServicePort: 3000,
-        k8sDeploymentName: 'langfuse-web',
-    },
-};
-export function getMarketplaceService(name) {
-    return marketplaceServices[name];
+export async function getAllMarketplaceServices() {
+    return await getMarketplaceServicesFromManifest();
 }
-export function getAllMarketplaceServices() {
-    return marketplaceServices;
+/**
+ * Get all marketplace agents, fetching from marketplace.json
+ * Returns null if marketplace is unavailable
+ */
+export async function getAllMarketplaceAgents() {
+    return await getMarketplaceAgentsFromManifest();
 }
-export function isMarketplaceService(name) {
-    return name.startsWith('marketplace/services/');
+/**
+ * Get a marketplace item by path (supports both services and agents)
+ * Returns null if marketplace is unavailable
+ */
+export async function getMarketplaceItem(path) {
+    if (path.startsWith('marketplace/services/')) {
+        const name = path.replace(/^marketplace\/services\//, '');
+        const services = await getAllMarketplaceServices();
+        if (!services) {
+            return null;
+        }
+        return services[name];
+    }
+    if (path.startsWith('marketplace/agents/')) {
+        const name = path.replace(/^marketplace\/agents\//, '');
+        const agents = await getAllMarketplaceAgents();
+        if (!agents) {
+            return null;
+        }
+        return agents[name];
+    }
+    return undefined;
 }
-export function extractMarketplaceServiceName(path) {
-    // Extract service name from marketplace/services/phoenix
-    return path.replace(/^marketplace\/services\//, '');
+export function isMarketplaceService(name) {
+    return (name.startsWith('marketplace/services/') ||
+        name.startsWith('marketplace/agents/'));
 }

package/dist/marketplaceServices.spec.d.ts

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

package/dist/marketplaceServices.spec.js

@@ -0,0 +1,74 @@
+import { jest } from '@jest/globals';
+const mockGetMarketplaceServicesFromManifest = jest.fn();
+const mockGetMarketplaceAgentsFromManifest = jest.fn();
+const mockFetchMarketplaceManifest = jest.fn();
+jest.unstable_mockModule('./lib/marketplaceFetcher.js', () => ({
+    getMarketplaceServicesFromManifest: mockGetMarketplaceServicesFromManifest,
+    getMarketplaceAgentsFromManifest: mockGetMarketplaceAgentsFromManifest,
+    fetchMarketplaceManifest: mockFetchMarketplaceManifest,
+}));
+const { getAllMarketplaceServices, getAllMarketplaceAgents, getMarketplaceItem, } = await import('./marketplaceServices.js');
+describe('marketplaceServices', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockGetMarketplaceServicesFromManifest.mockClear();
+    });
+    describe('getAllMarketplaceServices', () => {
+        it('returns manifest services when available', async () => {
+            const mockServices = {
+                'new-service': {
+                    name: 'new-service',
+                    helmReleaseName: 'new-service',
+                    description: 'New service',
+                    enabled: true,
+                    category: 'marketplace',
+                    namespace: 'new-ns',
+                },
+            };
+            mockGetMarketplaceServicesFromManifest.mockResolvedValue(mockServices);
+            const result = await getAllMarketplaceServices();
+            expect(result).toEqual(mockServices);
+            expect(mockGetMarketplaceServicesFromManifest).toHaveBeenCalled();
+        });
+        it('returns null when manifest unavailable', async () => {
+            mockGetMarketplaceServicesFromManifest.mockResolvedValue(null);
+            const result = await getAllMarketplaceServices();
+            expect(result).toBeNull();
+        });
+    });
+    describe('getMarketplaceItem', () => {
+        it('returns service by path from manifest', async () => {
+            const mockServices = {
+                'test-service': {
+                    name: 'test-service',
+                    helmReleaseName: 'test-service',
+                    description: 'Test',
+                    enabled: true,
+                    category: 'marketplace',
+                },
+            };
+            mockGetMarketplaceServicesFromManifest.mockResolvedValue(mockServices);
+            const result = await getMarketplaceItem('marketplace/services/test-service');
+            expect(result).toEqual(mockServices['test-service']);
+        });
+        it('returns undefined for non-existent service', async () => {
+            const mockServices = {
+                'test-service': {
+                    name: 'test-service',
+                    helmReleaseName: 'test-service',
+                    description: 'Test',
+                    enabled: true,
+                    category: 'marketplace',
+                },
+            };
+            mockGetMarketplaceServicesFromManifest.mockResolvedValue(mockServices);
+            const result = await getMarketplaceItem('marketplace/services/non-existent');
+            expect(result).toBeUndefined();
+        });
+        it('returns null when marketplace unavailable', async () => {
+            mockGetMarketplaceServicesFromManifest.mockResolvedValue(null);
+            const result = await getMarketplaceItem('marketplace/services/phoenix');
+            expect(result).toBeNull();
+        });
+    });
+});

package/dist/types/marketplace.d.ts

@@ -0,0 +1,37 @@
+export interface AnthropicMarketplaceItem {
+    name: string;
+    displayName?: string;
+    description: string;
+    type?: 'service' | 'agent';
+    version?: string;
+    author?: string;
+    homepage?: string;
+    repository?: string;
+    license?: string;
+    tags?: string[];
+    category?: string;
+    icon?: string;
+    screenshots?: string[];
+    documentation?: string;
+    support?: {
+        email?: string;
+        url?: string;
+    };
+    metadata?: Record<string, unknown>;
+    ark?: {
+        chartPath?: string;
+        namespace?: string;
+        helmReleaseName?: string;
+        installArgs?: string[];
+        k8sServiceName?: string;
+        k8sServicePort?: number;
+        k8sPortForwardLocalPort?: number;
+        k8sDeploymentName?: string;
+        k8sDevDeploymentName?: string;
+    };
+}
+export interface AnthropicMarketplaceManifest {
+    version: string;
+    marketplace: string;
+    items: AnthropicMarketplaceItem[];
+}

package/dist/types/marketplace.js

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

package/dist/ui/MainMenu.js

@@ -155,9 +155,11 @@ const MainMenu = ({ config }) => {
                 // Import and start ChatUI in the same process
                 const { render } = await import('ink');
                 const { ArkApiProxy } = await import('../lib/arkApiProxy.js');
+                const { loadConfig } = await import('../lib/config.js');
                 const ChatUI = (await import('../components/ChatUI.js')).default;
                 try {
-                    const proxy = new ArkApiProxy();
+                    const config = loadConfig();
+                    const proxy = new ArkApiProxy(undefined, config.services?.reusePortForwards ?? false);
                     const arkApiClient = await proxy.start();
                     // Render ChatUI as a new Ink app
                     render(_jsx(ChatUI, { arkApiClient: arkApiClient, arkApiProxy: proxy }));
@@ -211,7 +213,9 @@ const MainMenu = ({ config }) => {
                 //  Unmount fullscreen app and clear screen.
                 await unmountInkApp();
                 const { openDashboard } = await import('../commands/dashboard/index.js');
-                await openDashboard();
+                const { loadConfig } = await import('../lib/config.js');
+                const config = loadConfig();
+                await openDashboard(config);
                 break;
             }
             case 'status': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.46",
+  "version": "0.1.49",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",
@@ -9,7 +9,8 @@
   },
   "files": [
     "dist",
-    "templates"
+    "templates",
+    ".arkrc.template.yaml"
   ],
   "scripts": {
     "build": "npm run copy-templates && tsc && chmod +x dist/index.js",
@@ -48,6 +49,7 @@
     "commander": "^12.1.0",
     "debug": "^4.4.1",
     "execa": "^9.6.0",
+    "find-process": "^1.4.7",
     "ink": "^6.0.1",
     "ink-select-input": "^6.2.0",
     "ink-spinner": "^5.0.0",

package/templates/marketplace/marketplace.json.example

@@ -0,0 +1,59 @@
+{
+  "version": "1.0.0",
+  "marketplace": "ARK Marketplace",
+  "items": [
+    {
+      "name": "phoenix",
+      "displayName": "Phoenix",
+      "description": "AI/ML observability and evaluation platform with OpenTelemetry integration",
+      "version": "0.1.5",
+      "author": "ARK Marketplace",
+      "homepage": "https://github.com/mckinsey/agents-at-scale-marketplace",
+      "repository": "https://github.com/mckinsey/agents-at-scale-marketplace",
+      "license": "Apache-2.0",
+      "tags": ["observability", "evaluation", "telemetry", "monitoring"],
+      "category": "observability",
+      "icon": "https://example.com/phoenix-icon.png",
+      "documentation": "https://mckinsey.github.io/agents-at-scale-marketplace/services/phoenix/",
+      "support": {
+        "url": "https://github.com/mckinsey/agents-at-scale-marketplace/issues"
+      },
+      "ark": {
+        "chartPath": "oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts/phoenix",
+        "namespace": "phoenix",
+        "helmReleaseName": "phoenix",
+        "installArgs": ["--create-namespace"],
+        "k8sServiceName": "phoenix",
+        "k8sServicePort": 6006,
+        "k8sDeploymentName": "phoenix"
+      }
+    },
+    {
+      "name": "langfuse",
+      "displayName": "Langfuse",
+      "description": "Open-source LLM observability and analytics platform with session tracking",
+      "version": "0.1.4",
+      "author": "ARK Marketplace",
+      "homepage": "https://github.com/mckinsey/agents-at-scale-marketplace",
+      "repository": "https://github.com/mckinsey/agents-at-scale-marketplace",
+      "license": "Apache-2.0",
+      "tags": ["observability", "analytics", "llm", "tracking"],
+      "category": "observability",
+      "icon": "https://example.com/langfuse-icon.png",
+      "documentation": "https://mckinsey.github.io/agents-at-scale-marketplace/services/langfuse/",
+      "support": {
+        "url": "https://github.com/mckinsey/agents-at-scale-marketplace/issues"
+      },
+      "ark": {
+        "chartPath": "oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts/langfuse",
+        "namespace": "telemetry",
+        "helmReleaseName": "langfuse",
+        "installArgs": ["--create-namespace"],
+        "k8sServiceName": "langfuse",
+        "k8sServicePort": 3000,
+        "k8sDeploymentName": "langfuse-web"
+      }
+    }
+  ]
+}
+