@agents-at-scale/ark 0.1.47 → 0.1.50

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

@@ -0,0 +1,167 @@
+import { jest } from '@jest/globals';
+import output from '../../lib/output.js';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const { createQueriesCommand } = await import('./index.js');
+describe('queries get command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        console.log = jest.fn();
+        jest.spyOn(output, 'warning').mockImplementation(() => { });
+        jest.spyOn(output, 'error').mockImplementation(() => { });
+        jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+    });
+    it('should get query with response in JSON format', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: 'This is the response',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'get', 'test-query']);
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQuery, null, 2));
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should get query with response flag in JSON format', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: 'This is the response content',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--response',
+        ]);
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify(mockQuery.status.response, null, 2));
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should get query with response flag in markdown format', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: '# Heading\n\nThis is markdown content',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--response',
+            '--output',
+            'markdown',
+        ]);
+        expect(console.log).toHaveBeenCalled();
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should get query in markdown format without response flag', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'done',
+                response: {
+                    content: '# Response\n\nMarkdown response',
+                },
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--output',
+            'markdown',
+        ]);
+        expect(console.log).toHaveBeenCalled();
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should warn when query has no response with response flag', async () => {
+        const mockQuery = {
+            metadata: {
+                name: 'test-query',
+            },
+            spec: {
+                input: 'test input',
+                target: { type: 'agent', name: 'test-agent' },
+            },
+            status: {
+                phase: 'running',
+            },
+        };
+        mockExeca.mockResolvedValue({
+            stdout: JSON.stringify(mockQuery),
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'get',
+            'test-query',
+            '--response',
+        ]);
+        expect(output.warning).toHaveBeenCalledWith('No response available');
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+    });
+    it('should handle errors when getting query', async () => {
+        mockExeca.mockRejectedValue(new Error('Query not found'));
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'get', 'nonexistent-query']);
+        expect(output.error).toHaveBeenCalledWith('fetching query:', 'Query not found');
+        expect(process.exit).toHaveBeenCalled();
+    });
+});

package/dist/commands/query/index.js

@@ -11,6 +11,7 @@ export function createQueryCommand(config) {
         .option('-o, --output <format>', 'Output format: yaml, json, name or events (shows structured event data)')
         .option('--timeout <timeout>', 'Query timeout (e.g., 30s, 5m, 1h)')
         .option('--session-id <sessionId>', 'Session ID to associate with the query for conversation continuity')
+        .option('--conversation-id <conversationId>', 'Conversation ID to associate with the query for memory continuity')
         .action(async (target, message, options) => {
         const parsed = parseTarget(target);
         if (!parsed) {
@@ -24,6 +25,7 @@ export function createQueryCommand(config) {
             outputFormat: options.output,
             timeout: options.timeout || config.queryTimeout,
             sessionId: options.sessionId,
+            conversationId: options.conversationId,
         });
     });
     return queryCommand;

package/dist/components/ChatUI.js

@@ -467,11 +467,11 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
             }
             // Send message and get response with abort signal
             const fullResponse = await chatClientRef.current.sendMessage(target.id, apiMessages, { ...chatConfig, a2aContextId: a2aContextIdRef.current }, (chunk, toolCalls, arkMetadata) => {
-                // Extract A2A context ID from first response
-                // Chat TUI always queries a single target, so contextId is in responses[0]
-                if (arkMetadata?.completedQuery?.status?.responses?.[0]?.a2a?.contextId) {
+                // Extract A2A context ID from response
+                // Chat TUI always queries a single target, so contextId is in response
+                if (arkMetadata?.completedQuery?.status?.response?.a2a?.contextId) {
                     a2aContextIdRef.current =
-                        arkMetadata.completedQuery.status.responses[0].a2a.contextId;
+                        arkMetadata.completedQuery.status.response.a2a.contextId;
                 }
                 // Update message progressively as chunks arrive
                 setMessages((prev) => {

package/dist/index.js

@@ -14,7 +14,9 @@ import { createCompletionCommand } from './commands/completion/index.js';
 import { createDashboardCommand } from './commands/dashboard/index.js';
 import { createDocsCommand } from './commands/docs/index.js';
 import { createEvaluationCommand } from './commands/evaluation/index.js';
+import { createExportCommand } from './commands/export/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
+import { createImportCommand } from './commands/import/index.js';
 import { createInstallCommand } from './commands/install/index.js';
 import { createMarketplaceCommand } from './commands/marketplace/index.js';
 import { createMemoryCommand } from './commands/memory/index.js';
@@ -48,7 +50,9 @@ async function main() {
     program.addCommand(createDashboardCommand(config));
     program.addCommand(createDocsCommand(config));
     program.addCommand(createEvaluationCommand(config));
+    program.addCommand(createExportCommand(config));
     program.addCommand(createGenerateCommand(config));
+    program.addCommand(createImportCommand(config));
     program.addCommand(createInstallCommand(config));
     program.addCommand(createMarketplaceCommand(config));
     program.addCommand(createMemoryCommand(config));

package/dist/lib/arkApiProxy.d.ts

@@ -1,7 +1,7 @@
 import { ArkApiClient } from './arkApiClient.js';
 export declare class ArkApiProxy {
     private serviceProxy;
-    constructor(localPort?: number);
+    constructor(localPort?: number, reusePortForwards?: boolean);
     start(): Promise<ArkApiClient>;
     stop(): void;
     isRunning(): boolean;

package/dist/lib/arkApiProxy.js

@@ -2,9 +2,9 @@ import { ArkApiClient } from './arkApiClient.js';
 import { ArkServiceProxy } from './arkServiceProxy.js';
 import { arkServices } from '../arkServices.js';
 export class ArkApiProxy {
-    constructor(localPort) {
+    constructor(localPort, reusePortForwards = false) {
         const arkApiService = arkServices['ark-api'];
-        this.serviceProxy = new ArkServiceProxy(arkApiService, localPort);
+        this.serviceProxy = new ArkServiceProxy(arkApiService, localPort, reusePortForwards);
     }
     async start() {
         const arkApiUrl = await this.serviceProxy.start();

package/dist/lib/arkServiceProxy.d.ts

@@ -1,11 +1,13 @@
 import { ArkService } from '../arkServices.js';
 export declare class ArkServiceProxy {
+    private reusePortForwards;
     private kubectlProcess?;
     private localPort;
     private isReady;
     private service;
-    constructor(service: ArkService, localPort?: number);
+    constructor(service: ArkService, localPort?: number, reusePortForwards?: boolean);
     private getRandomPort;
+    private checkExistingPortForward;
     start(): Promise<string>;
     stop(): void;
     isRunning(): boolean;

package/dist/lib/arkServiceProxy.js

@@ -1,6 +1,10 @@
 import { spawn } from 'child_process';
+import find from 'find-process';
+import Debug from 'debug';
+const debug = Debug('ark:service-proxy');
 export class ArkServiceProxy {
-    constructor(service, localPort) {
+    constructor(service, localPort, reusePortForwards = false) {
+        this.reusePortForwards = reusePortForwards;
         this.isReady = false;
         this.service = service;
         this.localPort =
@@ -9,10 +13,39 @@ export class ArkServiceProxy {
     getRandomPort() {
         return Math.floor(Math.random() * (65535 - 1024) + 1024);
     }
+    async checkExistingPortForward() {
+        try {
+            const processes = await find('port', this.localPort);
+            if (processes.length === 0) {
+                return false;
+            }
+            const kubectlProcess = processes.find((proc) => proc.cmd?.includes('kubectl') && proc.cmd?.includes('port-forward'));
+            if (kubectlProcess) {
+                debug(`Reusing existing kubectl port-forward on port ${this.localPort} (PID: ${kubectlProcess.pid})`);
+                this.isReady = true;
+                return true;
+            }
+            const processInfo = processes[0];
+            throw new Error(`${this.service.name} port forward failed: port ${this.localPort} is already in use by ${processInfo.name} (PID: ${processInfo.pid})`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('already in use')) {
+                throw error;
+            }
+            debug(`Error checking for existing port-forward: ${error}`);
+            return false;
+        }
+    }
     async start() {
         if (!this.service.k8sServiceName || !this.service.k8sServicePort) {
             throw new Error(`${this.service.name} service configuration missing k8sServiceName or k8sServicePort`);
         }
+        if (this.reusePortForwards) {
+            const isReused = await this.checkExistingPortForward();
+            if (isReused) {
+                return `http://localhost:${this.localPort}`;
+            }
+        }
         return new Promise((resolve, reject) => {
             const args = [
                 'port-forward',

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

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

package/dist/lib/arkServiceProxy.spec.js

@@ -0,0 +1,100 @@
+import { jest } from '@jest/globals';
+import { Buffer } from 'buffer';
+const mockFind = jest.fn();
+jest.unstable_mockModule('find-process', () => ({
+    default: mockFind,
+}));
+const mockSpawn = jest.fn();
+const mockChildProcess = {
+    spawn: mockSpawn,
+};
+jest.unstable_mockModule('child_process', () => ({
+    ...mockChildProcess,
+    spawn: mockSpawn,
+}));
+const { ArkServiceProxy } = await import('./arkServiceProxy.js');
+describe('ArkServiceProxy', () => {
+    const mockService = {
+        name: 'test-service',
+        helmReleaseName: 'test-service',
+        description: 'Test service',
+        k8sServiceName: 'test-service-k8s',
+        k8sServicePort: 8080,
+        namespace: 'default',
+        enabled: true,
+        category: 'test',
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('port-forward reuse', () => {
+        it('creates new port-forward when reuse is disabled', async () => {
+            const proxy = new ArkServiceProxy(mockService, 3000, false);
+            const mockProcess = {
+                stdout: { on: jest.fn() },
+                stderr: { on: jest.fn() },
+                on: jest.fn(),
+                kill: jest.fn(),
+            };
+            mockSpawn.mockReturnValue(mockProcess);
+            setTimeout(() => {
+                const stdoutCallback = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
+                if (stdoutCallback) {
+                    stdoutCallback(Buffer.from('Forwarding from 127.0.0.1:3000'));
+                }
+            }, 10);
+            const url = await proxy.start();
+            expect(url).toBe('http://localhost:3000');
+            expect(mockFind).not.toHaveBeenCalled();
+            expect(mockSpawn).toHaveBeenCalledWith('kubectl', ['port-forward', 'service/test-service-k8s', '3000:8080', '--namespace', 'default'], expect.any(Object));
+        });
+        it('reuses existing kubectl port-forward when reuse is enabled', async () => {
+            mockFind.mockResolvedValue([
+                {
+                    pid: 12345,
+                    name: 'kubectl',
+                    cmd: 'kubectl port-forward service/test-service-k8s 3000:8080',
+                },
+            ]);
+            const proxy = new ArkServiceProxy(mockService, 3000, true);
+            const url = await proxy.start();
+            expect(url).toBe('http://localhost:3000');
+            expect(mockFind).toHaveBeenCalledWith('port', 3000);
+            expect(mockSpawn).not.toHaveBeenCalled();
+        });
+        it('creates new port-forward when port is not in use', async () => {
+            mockFind.mockResolvedValue([]);
+            const proxy = new ArkServiceProxy(mockService, 3000, true);
+            const mockProcess = {
+                stdout: { on: jest.fn() },
+                stderr: { on: jest.fn() },
+                on: jest.fn(),
+                kill: jest.fn(),
+            };
+            mockSpawn.mockReturnValue(mockProcess);
+            setTimeout(() => {
+                const stdoutCallback = mockProcess.stdout.on.mock.calls.find((call) => call[0] === 'data')?.[1];
+                if (stdoutCallback) {
+                    stdoutCallback(Buffer.from('Forwarding from 127.0.0.1:3000'));
+                }
+            }, 10);
+            const url = await proxy.start();
+            expect(url).toBe('http://localhost:3000');
+            expect(mockFind).toHaveBeenCalledWith('port', 3000);
+            expect(mockSpawn).toHaveBeenCalled();
+        });
+        it('throws error when port is in use by non-kubectl process', async () => {
+            mockFind.mockResolvedValue([
+                {
+                    pid: 54321,
+                    name: 'node',
+                    cmd: 'node server.js',
+                },
+            ]);
+            const proxy = new ArkServiceProxy(mockService, 3000, true);
+            await expect(proxy.start()).rejects.toThrow('test-service port forward failed: port 3000 is already in use by node (PID: 54321)');
+            expect(mockFind).toHaveBeenCalledWith('port', 3000);
+            expect(mockSpawn).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/lib/chatClient.d.ts

@@ -6,6 +6,7 @@ export interface ChatConfig {
     currentTarget?: QueryTarget;
     a2aContextId?: string;
     sessionId?: string;
+    conversationId?: string;
     queryTimeout?: string;
 }
 export interface ToolCall {

package/dist/lib/chatClient.js

@@ -17,11 +17,17 @@ export class ChatClient {
             signal: signal,
         };
         // Build metadata object - only add if we have something to include
-        if (config.sessionId || config.a2aContextId || config.queryTimeout) {
+        if (config.sessionId ||
+            config.conversationId ||
+            config.a2aContextId ||
+            config.queryTimeout) {
             params.metadata = {};
             if (config.sessionId) {
                 params.metadata.sessionId = config.sessionId;
             }
+            if (config.conversationId) {
+                params.metadata.conversationId = config.conversationId;
+            }
             if (config.queryTimeout) {
                 params.metadata.timeout = config.queryTimeout;
             }

package/dist/lib/config.d.ts

@@ -12,9 +12,11 @@ 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;
 }
 /**

package/dist/lib/config.js

@@ -20,6 +20,9 @@ export function loadConfig() {
             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');
@@ -48,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 || {};
@@ -70,6 +71,11 @@ export function loadConfig() {
         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;
 }
 /**
@@ -96,16 +102,24 @@ function mergeConfig(target, source) {
     }
     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

package/dist/lib/config.spec.js

@@ -39,6 +39,9 @@ describe('config', () => {
                 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', () => {
@@ -77,6 +80,13 @@ describe('config', () => {
         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');

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

@@ -8,6 +8,7 @@ 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);
@@ -15,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...';
@@ -29,7 +31,13 @@ export async function executeQuery(options) {
         let headerShown = false;
         let firstOutput = true;
         const sessionId = options.sessionId || process.env.ARK_SESSION_ID;
-        await chatClient.sendMessage(targetId, messages, { streamingEnabled: true, sessionId, queryTimeout: options.timeout }, (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,12 +113,13 @@ async function executeQueryWithFormat(options) {
             ...((options.sessionId || process.env.ARK_SESSION_ID) && {
                 sessionId: options.sessionId || process.env.ARK_SESSION_ID,
             }),
-            targets: [
-                {
-                    type: options.targetType,
-                    name: options.targetName,
-                },
-            ],
+            ...((options.conversationId || process.env.ARK_CONVERSATION_ID) && {
+                conversationId: options.conversationId || process.env.ARK_CONVERSATION_ID,
+            }),
+            target: {
+                type: options.targetType,
+                name: options.targetName,
+            },
         },
     };
     try {

package/dist/lib/kubectl.d.ts

@@ -6,6 +6,8 @@ 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?: {

package/dist/lib/kubectl.js

@@ -25,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);

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');