@agents-at-scale/ark 0.1.36 → 0.1.37

package/dist/lib/timeout.js

@@ -0,0 +1,20 @@
+export function parseTimeoutToSeconds(value) {
+    const match = value.match(/^(\d+)([smh])?$/);
+    if (!match) {
+        throw new Error('Invalid timeout format. Use format like 30s, 2m, or 1h');
+    }
+    const num = parseInt(match[1], 10);
+    const unit = match[2];
+    if (!unit)
+        return num;
+    switch (unit) {
+        case 's':
+            return num;
+        case 'm':
+            return num * 60;
+        case 'h':
+            return num * 3600;
+        default:
+            return num;
+    }
+}

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

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

package/dist/lib/timeout.spec.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } from '@jest/globals';
+import { parseTimeoutToSeconds } from './timeout.js';
+describe('parseTimeoutToSeconds', () => {
+    it('should parse time units correctly', () => {
+        expect(parseTimeoutToSeconds('30s')).toBe(30);
+        expect(parseTimeoutToSeconds('2m')).toBe(120);
+        expect(parseTimeoutToSeconds('1h')).toBe(3600);
+        expect(parseTimeoutToSeconds('60')).toBe(60);
+    });
+    it('should throw error for invalid formats', () => {
+        expect(() => parseTimeoutToSeconds('abc')).toThrow('Invalid timeout format');
+        expect(() => parseTimeoutToSeconds('-5s')).toThrow('Invalid timeout format');
+    });
+});

package/dist/lib/waitForReady.d.ts

@@ -0,0 +1,8 @@
+import type { ArkService } from '../types/arkService.js';
+export interface WaitProgress {
+    serviceName: string;
+    ready: boolean;
+    error?: string;
+}
+export declare function waitForDeploymentReady(deploymentName: string, namespace: string, timeoutSeconds: number): Promise<boolean>;
+export declare function waitForServicesReady(services: ArkService[], timeoutSeconds: number, onProgress?: (progress: WaitProgress) => void): Promise<boolean>;

package/dist/lib/waitForReady.js

@@ -0,0 +1,32 @@
+import { execa } from 'execa';
+export async function waitForDeploymentReady(deploymentName, namespace, timeoutSeconds) {
+    try {
+        await execa('kubectl', [
+            'wait',
+            '--for=condition=available',
+            `deployment/${deploymentName}`,
+            '-n',
+            namespace,
+            `--timeout=${timeoutSeconds}s`,
+        ], { timeout: timeoutSeconds * 1000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function waitForServicesReady(services, timeoutSeconds, onProgress) {
+    const validServices = services.filter((s) => s.k8sDeploymentName && s.namespace);
+    const checkPromises = validServices.map(async (service) => {
+        const isReady = await waitForDeploymentReady(service.k8sDeploymentName, service.namespace, timeoutSeconds);
+        if (onProgress) {
+            onProgress({
+                serviceName: service.name,
+                ready: isReady,
+            });
+        }
+        return isReady;
+    });
+    const results = await Promise.all(checkPromises);
+    return results.every((ready) => ready);
+}

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

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

package/dist/lib/waitForReady.spec.js

@@ -0,0 +1,104 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
+}));
+const { execa } = await import('execa');
+const { waitForDeploymentReady, waitForServicesReady } = await import('./waitForReady.js');
+const mockedExeca = execa;
+describe('waitForDeploymentReady', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('returns true when deployment is ready', async () => {
+        mockedExeca.mockResolvedValueOnce({
+            stdout: 'deployment.apps/ark-controller condition met',
+            stderr: '',
+            exitCode: 0,
+        });
+        const result = await waitForDeploymentReady('ark-controller', 'ark-system', 30);
+        expect(result).toBe(true);
+        expect(mockedExeca).toHaveBeenCalledWith('kubectl', [
+            'wait',
+            '--for=condition=available',
+            'deployment/ark-controller',
+            '-n',
+            'ark-system',
+            '--timeout=30s',
+        ], { timeout: 30000 });
+    });
+    it('returns false on error', async () => {
+        mockedExeca.mockRejectedValueOnce(new Error('kubectl error'));
+        const result = await waitForDeploymentReady('ark-api', 'default', 10);
+        expect(result).toBe(false);
+    });
+});
+describe('waitForServicesReady', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    const service1 = {
+        name: 'ark-controller',
+        helmReleaseName: 'ark-controller',
+        description: 'Core controller',
+        enabled: true,
+        category: 'core',
+        namespace: 'ark-system',
+        k8sDeploymentName: 'ark-controller',
+    };
+    const service2 = {
+        name: 'ark-api',
+        helmReleaseName: 'ark-api',
+        description: 'API service',
+        enabled: true,
+        category: 'service',
+        namespace: 'default',
+        k8sDeploymentName: 'ark-api',
+    };
+    it('returns true when all services are ready', async () => {
+        mockedExeca.mockResolvedValue({
+            stdout: 'condition met',
+            stderr: '',
+            exitCode: 0,
+        });
+        const result = await waitForServicesReady([service1, service2], 30);
+        expect(result).toBe(true);
+        expect(mockedExeca).toHaveBeenCalledTimes(2);
+    });
+    it('returns false when any service fails', async () => {
+        mockedExeca
+            .mockResolvedValueOnce({ stdout: 'ok', stderr: '', exitCode: 0 })
+            .mockRejectedValueOnce(new Error('timeout'));
+        const result = await waitForServicesReady([service1, service2], 30);
+        expect(result).toBe(false);
+    });
+    it('calls progress callback', async () => {
+        mockedExeca.mockResolvedValue({
+            stdout: 'ok',
+            stderr: '',
+            exitCode: 0,
+        });
+        const onProgress = jest.fn();
+        await waitForServicesReady([service1], 30, onProgress);
+        expect(onProgress).toHaveBeenCalledWith({
+            serviceName: 'ark-controller',
+            ready: true,
+        });
+    });
+    it('skips services without deployment info', async () => {
+        const incompleteService = {
+            name: 'incomplete',
+            helmReleaseName: 'incomplete',
+            description: 'No deployment info',
+            enabled: true,
+            category: 'service',
+        };
+        mockedExeca.mockResolvedValue({
+            stdout: 'ok',
+            stderr: '',
+            exitCode: 0,
+        });
+        const result = await waitForServicesReady([service1, incompleteService], 30);
+        expect(result).toBe(true);
+        expect(mockedExeca).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/types/arkService.d.ts

@@ -0,0 +1,27 @@
+export interface ArkService {
+    name: string;
+    helmReleaseName: string;
+    description: string;
+    enabled: boolean;
+    category: string;
+    namespace?: string;
+    chartPath?: string;
+    installArgs?: string[];
+    k8sServiceName?: string;
+    k8sServicePort?: number;
+    k8sPortForwardLocalPort?: number;
+    k8sDeploymentName?: string;
+    k8sDevDeploymentName?: string;
+}
+export interface ServiceCollection {
+    [key: string]: ArkService;
+}
+export interface ArkDependency {
+    name: string;
+    command: string;
+    args: string[];
+    description: string;
+}
+export interface DependencyCollection {
+    [key: string]: ArkDependency;
+}

package/dist/types/arkService.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.36",
-  "description": "ARK CLI - Interactive terminal interface for ARK agents",
+  "version": "0.1.37",
+  "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "lint": "eslint src/ --fix && prettier --write src/",
     "lint:check": "eslint src/ && prettier --check src/",
     "test": "NODE_OPTIONS=\"--experimental-vm-modules\" jest --coverage --coverageDirectory=./artifacts/coverage --coverageReporters=text --coverageReporters=lcov --coverageReporters=text-summary",
-    "postinstall": "echo \"ARK CLI installed! Run 'ark' to try it out.\""
+    "postinstall": "echo \"Ark CLI installed. Run 'ark' to try it out.\""
   },
   "keywords": [
     "ark",