@agents-at-scale/ark 0.1.46 → 0.1.49

package/dist/lib/config.d.ts

@@ -4,11 +4,19 @@ export interface ChatConfig {
     streaming?: boolean;
     outputFormat?: 'text' | 'markdown';
 }
+export interface MarketplaceConfig {
+    repoUrl?: string;
+    registry?: string;
+}
 export interface ArkConfig {
     chat?: ChatConfig;
+    marketplace?: MarketplaceConfig;
     services?: {
-        [serviceName: string]: Partial<ArkService>;
+        reusePortForwards?: boolean;
+        [serviceName: string]: Partial<ArkService> | boolean | undefined;
     };
+    queryTimeout?: string;
+    defaultExportTypes?: string[];
     clusterInfo?: ClusterInfo;
 }
 /**
@@ -30,3 +38,11 @@ export declare function getConfigPaths(): {
  * Format config as YAML for display
  */
 export declare function formatConfig(config: ArkConfig): string;
+/**
+ * Get marketplace repository URL from config
+ */
+export declare function getMarketplaceRepoUrl(): string;
+/**
+ * Get marketplace registry from config
+ */
+export declare function getMarketplaceRegistry(): string;

package/dist/lib/config.js

@@ -16,6 +16,13 @@ export function loadConfig() {
             streaming: true,
             outputFormat: 'text',
         },
+        marketplace: {
+            repoUrl: 'https://github.com/mckinsey/agents-at-scale-marketplace',
+            registry: 'oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts',
+        },
+        services: {
+            reusePortForwards: false,
+        },
     };
     // Load user config from home directory
     const userConfigPath = path.join(os.homedir(), '.arkrc.yaml');
@@ -44,9 +51,7 @@ export function loadConfig() {
     // Apply environment variable overrides
     if (process.env.ARK_CHAT_STREAMING !== undefined) {
         config.chat = config.chat || {};
-        config.chat.streaming =
-            process.env.ARK_CHAT_STREAMING === '1' ||
-                process.env.ARK_CHAT_STREAMING === 'true';
+        config.chat.streaming = process.env.ARK_CHAT_STREAMING === '1';
     }
     if (process.env.ARK_CHAT_OUTPUT_FORMAT !== undefined) {
         config.chat = config.chat || {};
@@ -55,6 +60,22 @@ export function loadConfig() {
             config.chat.outputFormat = format;
         }
     }
+    if (process.env.ARK_QUERY_TIMEOUT !== undefined) {
+        config.queryTimeout = process.env.ARK_QUERY_TIMEOUT;
+    }
+    if (process.env.ARK_MARKETPLACE_REPO_URL !== undefined) {
+        config.marketplace = config.marketplace || {};
+        config.marketplace.repoUrl = process.env.ARK_MARKETPLACE_REPO_URL;
+    }
+    if (process.env.ARK_MARKETPLACE_REGISTRY !== undefined) {
+        config.marketplace = config.marketplace || {};
+        config.marketplace.registry = process.env.ARK_MARKETPLACE_REGISTRY;
+    }
+    if (process.env.ARK_SERVICES_REUSE_PORT_FORWARDS !== undefined) {
+        config.services = config.services || {};
+        config.services.reusePortForwards =
+            process.env.ARK_SERVICES_REUSE_PORT_FORWARDS === '1';
+    }
     return config;
 }
 /**
@@ -70,15 +91,35 @@ function mergeConfig(target, source) {
             target.chat.outputFormat = source.chat.outputFormat;
         }
     }
+    if (source.marketplace) {
+        target.marketplace = target.marketplace || {};
+        if (source.marketplace.repoUrl !== undefined) {
+            target.marketplace.repoUrl = source.marketplace.repoUrl;
+        }
+        if (source.marketplace.registry !== undefined) {
+            target.marketplace.registry = source.marketplace.registry;
+        }
+    }
     if (source.services) {
         target.services = target.services || {};
+        if (source.services.reusePortForwards !== undefined) {
+            target.services.reusePortForwards = source.services.reusePortForwards;
+        }
         for (const [serviceName, overrides] of Object.entries(source.services)) {
-            target.services[serviceName] = {
-                ...target.services[serviceName],
-                ...overrides,
-            };
+            if (serviceName !== 'reusePortForwards' && typeof overrides === 'object') {
+                target.services[serviceName] = {
+                    ...target.services[serviceName],
+                    ...overrides,
+                };
+            }
         }
     }
+    if (source.queryTimeout !== undefined) {
+        target.queryTimeout = source.queryTimeout;
+    }
+    if (source.defaultExportTypes) {
+        target.defaultExportTypes = source.defaultExportTypes;
+    }
 }
 /**
  * Get the paths checked for config files
@@ -95,3 +136,17 @@ export function getConfigPaths() {
 export function formatConfig(config) {
     return yaml.stringify(config);
 }
+/**
+ * Get marketplace repository URL from config
+ */
+export function getMarketplaceRepoUrl() {
+    const config = loadConfig();
+    return config.marketplace.repoUrl;
+}
+/**
+ * Get marketplace registry from config
+ */
+export function getMarketplaceRegistry() {
+    const config = loadConfig();
+    return config.marketplace.registry;
+}

package/dist/lib/config.spec.js

@@ -35,6 +35,13 @@ 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',
+            },
+            services: {
+                reusePortForwards: false,
+            },
         });
     });
     it('loads and merges configs in order: defaults, user, project', () => {
@@ -66,6 +73,28 @@ 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('loads defaultExportTypes from config file', () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync.mockReturnValue('yaml');
+        mockYaml.parse.mockReturnValue({ defaultExportTypes: ['agents', 'teams'] });
+        const config = loadConfig();
+        expect(config.defaultExportTypes).toEqual(['agents', 'teams']);
+    });
+    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 +125,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.d.ts

@@ -11,6 +11,7 @@ export interface QueryOptions {
     verbose?: boolean;
     outputFormat?: string;
     sessionId?: string;
+    conversationId?: string;
 }
 export declare function executeQuery(options: QueryOptions): Promise<void>;
 /**

package/dist/lib/executeQuery.js

@@ -7,6 +7,8 @@ import chalk from 'chalk';
 import { ExitCodes } from './errors.js';
 import { ArkApiProxy } from './arkApiProxy.js';
 import { ChatClient } from './chatClient.js';
+import { watchEventsLive } from './kubectl.js';
+import { loadConfig } from './config.js';
 export async function executeQuery(options) {
     if (options.outputFormat) {
         return executeQueryWithFormat(options);
@@ -14,7 +16,8 @@ export async function executeQuery(options) {
     let arkApiProxy;
     const spinner = ora('Connecting to Ark API...').start();
     try {
-        arkApiProxy = new ArkApiProxy();
+        const config = loadConfig();
+        arkApiProxy = new ArkApiProxy(undefined, config.services?.reusePortForwards ?? false);
         const arkApiClient = await arkApiProxy.start();
         const chatClient = new ChatClient(arkApiClient);
         spinner.text = 'Executing query...';
@@ -27,9 +30,14 @@ 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) => {
+        const conversationId = options.conversationId || process.env.ARK_CONVERSATION_ID;
+        await chatClient.sendMessage(targetId, messages, {
+            streamingEnabled: true,
+            sessionId,
+            conversationId,
+            queryTimeout: options.timeout,
+        }, (chunk, toolCalls, arkMetadata) => {
             if (firstOutput) {
                 spinner.stop();
                 firstOutput = false;
@@ -105,6 +113,9 @@ async function executeQueryWithFormat(options) {
             ...((options.sessionId || process.env.ARK_SESSION_ID) && {
                 sessionId: options.sessionId || process.env.ARK_SESSION_ID,
             }),
+            ...((options.conversationId || process.env.ARK_CONVERSATION_ID) && {
+                conversationId: options.conversationId || process.env.ARK_CONVERSATION_ID,
+            }),
             targets: [
                 {
                     type: options.targetType,
@@ -118,6 +129,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 +151,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

@@ -6,10 +6,13 @@ interface K8sResource {
 }
 export declare function getResource<T extends K8sResource>(resourceType: string, name: string): Promise<T>;
 export declare function listResources<T extends K8sResource>(resourceType: string, options?: {
+    namespace?: string;
+    labels?: string;
     sortBy?: string;
 }): Promise<T[]>;
 export declare function deleteResource(resourceType: string, name?: string, options?: {
     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', [
@@ -23,6 +25,12 @@ export async function listResources(resourceType, options) {
     if (options?.sortBy) {
         args.push(`--sort-by=${options.sortBy}`);
     }
+    if (options?.namespace) {
+        args.push('-n', options.namespace);
+    }
+    if (options?.labels) {
+        args.push('-l', options.labels);
+    }
     args.push('-o', 'json');
     const result = await execa('kubectl', args, { stdio: 'pipe' });
     const data = JSON.parse(result.stdout);
@@ -45,3 +53,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/kubectl.spec.js

@@ -152,6 +152,22 @@ describe('kubectl', () => {
                 'json',
             ], { stdio: 'pipe' });
         });
+        it('should pass namespace and label filters', async () => {
+            const result = await listResources('queries', {
+                labels: 'app=test',
+                namespace: 'foo'
+            });
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'queries',
+                '-n',
+                'foo',
+                '-l',
+                'app=test',
+                '-o',
+                'json',
+            ], { stdio: 'pipe' });
+        });
         it('should handle kubectl errors when listing resources', async () => {
             mockExeca.mockRejectedValue(new Error('kubectl connection error'));
             await expect(listResources('queries')).rejects.toThrow('kubectl connection error');

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 {};