@agents-at-scale/ark 0.1.35 → 0.1.36

package/dist/lib/chatClient.js

@@ -0,0 +1,93 @@
+export class ChatClient {
+    constructor(arkApiClient) {
+        this.arkApiClient = arkApiClient;
+    }
+    async getQueryTargets() {
+        return await this.arkApiClient.getQueryTargets();
+    }
+    /**
+     * Send a chat completion request
+     */
+    async sendMessage(targetId, messages, config, onChunk, signal) {
+        const shouldStream = config.streamingEnabled && !!onChunk;
+        const params = {
+            model: targetId,
+            messages: messages,
+            signal: signal,
+        };
+        if (shouldStream) {
+            let fullResponse = '';
+            const toolCallsById = new Map();
+            const stream = this.arkApiClient.createChatCompletionStream(params);
+            for await (const chunk of stream) {
+                if (signal?.aborted) {
+                    break;
+                }
+                const delta = chunk.choices[0]?.delta;
+                // Extract ARK metadata if present
+                const arkMetadata = chunk.ark;
+                // Handle regular content
+                const content = delta?.content || '';
+                if (content) {
+                    fullResponse += content;
+                    if (onChunk) {
+                        onChunk(content, undefined, arkMetadata);
+                    }
+                }
+                // Handle tool calls
+                if (delta?.tool_calls) {
+                    for (const toolCallDelta of delta.tool_calls) {
+                        const index = toolCallDelta.index;
+                        // Initialize tool call if this is the first chunk for this index
+                        if (!toolCallsById.has(index)) {
+                            toolCallsById.set(index, {
+                                id: toolCallDelta.id || '',
+                                type: toolCallDelta.type || 'function',
+                                function: {
+                                    name: toolCallDelta.function?.name || '',
+                                    arguments: '',
+                                },
+                            });
+                        }
+                        // Accumulate function arguments
+                        const toolCall = toolCallsById.get(index);
+                        if (toolCallDelta.function?.arguments) {
+                            toolCall.function.arguments += toolCallDelta.function.arguments;
+                        }
+                        // Send the current state of all tool calls
+                        if (onChunk) {
+                            const toolCallsArray = Array.from(toolCallsById.values());
+                            onChunk('', toolCallsArray, arkMetadata);
+                        }
+                    }
+                }
+            }
+            return fullResponse;
+        }
+        else {
+            const response = await this.arkApiClient.createChatCompletion(params);
+            const message = response.choices[0]?.message;
+            const content = message?.content || '';
+            // Handle tool calls in non-streaming mode
+            if (message?.tool_calls && message.tool_calls.length > 0) {
+                const toolCalls = message.tool_calls.map((tc) => ({
+                    id: tc.id,
+                    type: tc.type || 'function',
+                    function: {
+                        name: tc.function?.name || '',
+                        arguments: tc.function?.arguments || '',
+                    },
+                }));
+                // Send tool calls first
+                if (onChunk) {
+                    onChunk('', toolCalls);
+                }
+            }
+            // Send content after tool calls
+            if (content && onChunk) {
+                onChunk(content);
+            }
+            return content;
+        }
+    }
+}

package/dist/lib/cluster.d.ts

@@ -2,7 +2,8 @@ export interface ClusterInfo {
     type: 'minikube' | 'kind' | 'k3s' | 'docker-desktop' | 'cloud' | 'unknown';
     ip?: string;
     context?: string;
+    namespace?: string;
     error?: string;
 }
 export declare function detectClusterType(): Promise<ClusterInfo>;
-export declare function getClusterIp(_context?: string): Promise<ClusterInfo>;
+export declare function getClusterInfo(context?: string): Promise<ClusterInfo>;

package/dist/lib/cluster.js

@@ -1,10 +1,7 @@
-import { executeCommand } from './exec.js';
+import { execa } from 'execa';
 export async function detectClusterType() {
     try {
-        const { stdout } = await executeCommand('kubectl', [
-            'config',
-            'current-context',
-        ]);
+        const { stdout } = await execa('kubectl', ['config', 'current-context']);
         const context = stdout.trim();
         if (context.includes('minikube')) {
             return { type: 'minikube', context };
@@ -28,12 +25,33 @@ export async function detectClusterType() {
         }
     }
     catch (error) {
-        return { type: 'unknown', error: error.message };
+        return {
+            type: 'unknown',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
     }
 }
-export async function getClusterIp(_context) {
+export async function getClusterInfo(context) {
     try {
+        // If context is provided, use it
+        const contextArgs = context ? ['--context', context] : [];
+        // Get all config info in one command
+        const { stdout: configJson } = await execa('kubectl', [
+            'config',
+            'view',
+            '--minify',
+            '-o',
+            'json',
+            ...contextArgs,
+        ]);
+        const config = JSON.parse(configJson);
+        const currentContext = config['current-context'] || '';
+        const contextData = config.contexts?.find((c) => c.name === currentContext);
+        const namespace = contextData?.context?.namespace || 'default';
+        // Detect cluster type from context name
         const clusterInfo = await detectClusterType();
+        clusterInfo.context = currentContext;
+        clusterInfo.namespace = namespace;
         if (clusterInfo.error) {
             return clusterInfo;
         }
@@ -41,12 +59,12 @@ export async function getClusterIp(_context) {
         switch (clusterInfo.type) {
             case 'minikube':
                 try {
-                    const { stdout } = await executeCommand('minikube', ['ip']);
+                    const { stdout } = await execa('minikube', ['ip']);
                     ip = stdout.trim();
                 }
                 catch {
                     // Fallback to kubectl if minikube command fails
-                    const { stdout } = await executeCommand('kubectl', [
+                    const { stdout } = await execa('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -56,7 +74,7 @@ export async function getClusterIp(_context) {
                 }
                 break;
             case 'kind': {
-                const { stdout: kindOutput } = await executeCommand('kubectl', [
+                const { stdout: kindOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -69,7 +87,7 @@ export async function getClusterIp(_context) {
                 ip = 'localhost';
                 break;
             case 'k3s': {
-                const { stdout: k3sOutput } = await executeCommand('kubectl', [
+                const { stdout: k3sOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -81,7 +99,7 @@ export async function getClusterIp(_context) {
             case 'cloud':
                 // For cloud clusters, try to get the external IP or load balancer IP
                 try {
-                    const { stdout: lbOutput } = await executeCommand('kubectl', [
+                    const { stdout: lbOutput } = await execa('kubectl', [
                         'get',
                         'svc',
                         '-n',
@@ -92,7 +110,7 @@ export async function getClusterIp(_context) {
                     ]);
                     ip = lbOutput.trim();
                     if (!ip) {
-                        const { stdout: hostnameOutput } = await executeCommand('kubectl', [
+                        const { stdout: hostnameOutput } = await execa('kubectl', [
                             'get',
                             'svc',
                             '-n',
@@ -106,7 +124,7 @@ export async function getClusterIp(_context) {
                 }
                 catch {
                     // Fallback to node IP
-                    const { stdout: nodeOutput } = await executeCommand('kubectl', [
+                    const { stdout: nodeOutput } = await execa('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -116,7 +134,7 @@ export async function getClusterIp(_context) {
                 }
                 break;
             default: {
-                const { stdout: defaultOutput } = await executeCommand('kubectl', [
+                const { stdout: defaultOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -129,6 +147,9 @@ export async function getClusterIp(_context) {
         return { ...clusterInfo, ip };
     }
     catch (error) {
-        return { type: 'unknown', error: error.message };
+        return {
+            type: 'unknown',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
     }
 }

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

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

package/dist/lib/cluster.spec.js

@@ -0,0 +1,338 @@
+import { jest } from '@jest/globals';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const { getClusterInfo, detectClusterType } = await import('./cluster.js');
+describe('cluster', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('detectClusterType', () => {
+        it('detects minikube cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'minikube' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'minikube', context: 'minikube' });
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'config',
+                'current-context',
+            ]);
+        });
+        it('detects kind cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'kind-kind' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'kind', context: 'kind-kind' });
+        });
+        it('detects k3s cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'k3s-default' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'k3s', context: 'k3s-default' });
+        });
+        it('detects docker-desktop cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'docker-desktop' });
+            const result = await detectClusterType();
+            expect(result).toEqual({
+                type: 'docker-desktop',
+                context: 'docker-desktop',
+            });
+        });
+        it('detects gke cloud cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'gke_project_zone_cluster' });
+            const result = await detectClusterType();
+            expect(result).toEqual({
+                type: 'cloud',
+                context: 'gke_project_zone_cluster',
+            });
+        });
+        it('detects eks cloud cluster', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'arn:aws:eks:region:account:cluster/name',
+            });
+            const result = await detectClusterType();
+            expect(result).toEqual({
+                type: 'cloud',
+                context: 'arn:aws:eks:region:account:cluster/name',
+            });
+        });
+        it('detects aks cloud cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'aks-cluster-name' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'cloud', context: 'aks-cluster-name' });
+        });
+        it('returns unknown for unrecognized cluster', async () => {
+            mockExeca.mockResolvedValue({ stdout: 'some-other-cluster' });
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'unknown', context: 'some-other-cluster' });
+        });
+        it('handles kubectl error', async () => {
+            mockExeca.mockRejectedValue(new Error('kubectl not found'));
+            const result = await detectClusterType();
+            expect(result).toEqual({ type: 'unknown', error: 'kubectl not found' });
+        });
+    });
+    describe('getClusterInfo', () => {
+        const mockConfig = {
+            'current-context': 'minikube',
+            contexts: [
+                {
+                    name: 'minikube',
+                    context: {
+                        namespace: 'default',
+                    },
+                },
+            ],
+        };
+        it('gets minikube cluster info with IP', async () => {
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(mockConfig) })
+                .mockResolvedValueOnce({ stdout: 'minikube' })
+                .mockResolvedValueOnce({ stdout: '192.168.49.2' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'minikube',
+                context: 'minikube',
+                namespace: 'default',
+                ip: '192.168.49.2',
+            });
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'config',
+                'view',
+                '--minify',
+                '-o',
+                'json',
+            ]);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'config',
+                'current-context',
+            ]);
+            expect(mockExeca).toHaveBeenCalledWith('minikube', ['ip']);
+        });
+        it('falls back to kubectl for minikube IP if minikube command fails', async () => {
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(mockConfig) })
+                .mockResolvedValueOnce({ stdout: 'minikube' })
+                .mockRejectedValueOnce(new Error('minikube not found'))
+                .mockResolvedValueOnce({ stdout: '192.168.49.2' });
+            const result = await getClusterInfo();
+            expect(result.ip).toBe('192.168.49.2');
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'nodes',
+                '-o',
+                'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
+            ]);
+        });
+        it('gets kind cluster info with IP', async () => {
+            const kindConfig = {
+                'current-context': 'kind-kind',
+                contexts: [
+                    {
+                        name: 'kind-kind',
+                        context: {
+                            namespace: 'kube-system',
+                        },
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(kindConfig) })
+                .mockResolvedValueOnce({ stdout: 'kind-kind' })
+                .mockResolvedValueOnce({ stdout: '172.18.0.2' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'kind',
+                context: 'kind-kind',
+                namespace: 'kube-system',
+                ip: '172.18.0.2',
+            });
+        });
+        it('gets docker-desktop cluster info', async () => {
+            const dockerConfig = {
+                'current-context': 'docker-desktop',
+                contexts: [
+                    {
+                        name: 'docker-desktop',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(dockerConfig) })
+                .mockResolvedValueOnce({ stdout: 'docker-desktop' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'docker-desktop',
+                context: 'docker-desktop',
+                namespace: 'default',
+                ip: 'localhost',
+            });
+        });
+        it('gets cloud cluster info with load balancer IP', async () => {
+            const cloudConfig = {
+                'current-context': 'gke_project_zone_cluster',
+                contexts: [
+                    {
+                        name: 'gke_project_zone_cluster',
+                        context: {
+                            namespace: 'production',
+                        },
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(cloudConfig) })
+                .mockResolvedValueOnce({ stdout: 'gke_project_zone_cluster' })
+                .mockResolvedValueOnce({ stdout: '35.201.125.17' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'cloud',
+                context: 'gke_project_zone_cluster',
+                namespace: 'production',
+                ip: '35.201.125.17',
+            });
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'svc',
+                '-n',
+                'istio-system',
+                'istio-ingressgateway',
+                '-o',
+                'jsonpath={.status.loadBalancer.ingress[0].ip}',
+            ]);
+        });
+        it('falls back to hostname for cloud cluster if no IP', async () => {
+            const cloudConfig = {
+                'current-context': 'eks-cluster',
+                contexts: [
+                    {
+                        name: 'eks-cluster',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(cloudConfig) })
+                .mockResolvedValueOnce({ stdout: 'eks-cluster' })
+                .mockResolvedValueOnce({ stdout: '' })
+                .mockResolvedValueOnce({ stdout: 'a1234.elb.amazonaws.com' });
+            const result = await getClusterInfo();
+            expect(result.ip).toBe('a1234.elb.amazonaws.com');
+        });
+        it('falls back to external node IP for cloud cluster', async () => {
+            const cloudConfig = {
+                'current-context': 'gke-cluster',
+                contexts: [
+                    {
+                        name: 'gke-cluster',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(cloudConfig) })
+                .mockResolvedValueOnce({ stdout: 'gke-cluster' })
+                .mockRejectedValueOnce(new Error('service not found'))
+                .mockResolvedValueOnce({ stdout: '35.201.125.18' });
+            const result = await getClusterInfo();
+            expect(result.ip).toBe('35.201.125.18');
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'nodes',
+                '-o',
+                'jsonpath={.items[0].status.addresses[?(@.type=="ExternalIP")].address}',
+            ]);
+        });
+        it('gets k3s cluster info', async () => {
+            const k3sConfig = {
+                'current-context': 'k3s-default',
+                contexts: [
+                    {
+                        name: 'k3s-default',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(k3sConfig) })
+                .mockResolvedValueOnce({ stdout: 'k3s-default' })
+                .mockResolvedValueOnce({ stdout: '10.0.0.5' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'k3s',
+                context: 'k3s-default',
+                namespace: 'default',
+                ip: '10.0.0.5',
+            });
+        });
+        it('uses provided context parameter', async () => {
+            const multiConfig = {
+                'current-context': 'kind-staging',
+                contexts: [
+                    {
+                        name: 'kind-staging',
+                        context: {
+                            namespace: 'staging-ns',
+                        },
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(multiConfig) })
+                .mockResolvedValueOnce({ stdout: 'kind-staging' })
+                .mockResolvedValueOnce({ stdout: '172.18.0.3' });
+            const result = await getClusterInfo('kind-staging');
+            expect(result.context).toBe('kind-staging');
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'config',
+                'view',
+                '--minify',
+                '-o',
+                'json',
+                '--context',
+                'kind-staging',
+            ]);
+        });
+        it('handles unknown cluster type', async () => {
+            const unknownConfig = {
+                'current-context': 'custom-cluster',
+                contexts: [
+                    {
+                        name: 'custom-cluster',
+                        context: {},
+                    },
+                ],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(unknownConfig) })
+                .mockResolvedValueOnce({ stdout: 'custom-cluster' })
+                .mockResolvedValueOnce({ stdout: '10.0.0.1' });
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'unknown',
+                context: 'custom-cluster',
+                namespace: 'default',
+                ip: '10.0.0.1',
+            });
+        });
+        it('handles kubectl config error', async () => {
+            mockExeca.mockRejectedValue(new Error('kubectl not configured'));
+            const result = await getClusterInfo();
+            expect(result).toEqual({
+                type: 'unknown',
+                error: 'kubectl not configured',
+            });
+        });
+        it('handles missing context in config', async () => {
+            const emptyConfig = {
+                contexts: [],
+            };
+            mockExeca
+                .mockResolvedValueOnce({ stdout: JSON.stringify(emptyConfig) })
+                .mockResolvedValueOnce({ stdout: '' })
+                .mockResolvedValueOnce({ stdout: '10.0.0.1' });
+            const result = await getClusterInfo();
+            expect(result.context).toBe('');
+            expect(result.namespace).toBe('default');
+        });
+    });
+});

package/dist/lib/commands.d.ts

@@ -0,0 +1,16 @@
+import { type Options } from 'execa';
+/**
+ * Check if a command exists and is executable by running it with specified args
+ */
+export declare function checkCommandExists(command: string, args?: string[]): Promise<boolean>;
+export { checkCommandExists as isCommandAvailable };
+/**
+ * Execute a command with optional verbose output
+ * @param command The command to execute
+ * @param args Array of arguments
+ * @param execaOptions Standard execa options
+ * @param additionalOptions Additional options for execute (e.g., verbose)
+ */
+export declare function execute(command: string, args?: string[], execaOptions?: Options, additionalOptions?: {
+    verbose?: boolean;
+}): Promise<import("execa").Result<Options>>;

package/dist/lib/commands.js

@@ -0,0 +1,29 @@
+import { execa } from 'execa';
+import chalk from 'chalk';
+/**
+ * Check if a command exists and is executable by running it with specified args
+ */
+export async function checkCommandExists(command, args = ['--version']) {
+    try {
+        await execa(command, args);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export { checkCommandExists as isCommandAvailable };
+/**
+ * Execute a command with optional verbose output
+ * @param command The command to execute
+ * @param args Array of arguments
+ * @param execaOptions Standard execa options
+ * @param additionalOptions Additional options for execute (e.g., verbose)
+ */
+export async function execute(command, args = [], execaOptions = {}, additionalOptions = {}) {
+    const { verbose = false } = additionalOptions;
+    if (verbose) {
+        console.log(chalk.gray(`$ ${command} ${args.join(' ')}`));
+    }
+    return await execa(command, args, execaOptions);
+}

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

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