@agents-at-scale/ark 0.1.36 → 0.1.38

package/dist/components/AsyncOperation.d.ts

@@ -0,0 +1,54 @@
+import * as React from 'react';
+export interface AsyncOperationConfig {
+    /** Message to display during operation */
+    message: string;
+    /** Async function to execute */
+    operation: (signal: AbortSignal) => Promise<void>;
+    /** Optional tip displayed below message */
+    tip?: string;
+    /** Show "(esc to interrupt)" hint */
+    showInterrupt?: boolean;
+    /** Hide UI on success */
+    hideOnSuccess?: boolean;
+    /** Called when operation fails */
+    onError?: (error: Error) => void;
+    /** Error menu options with callbacks */
+    errorOptions?: Array<{
+        label: string;
+        onSelect: () => void;
+    }>;
+}
+interface AsyncOperationState {
+    /** Current operation state - idle: not running/cleared, loading: executing, success: completed, error: failed */
+    status: 'idle' | 'loading' | 'success' | 'error';
+    /** Message shown during loading and success */
+    message: string;
+    /** Optional tip text shown below message during loading */
+    tip?: string;
+    /** Brief error message when status is error */
+    error?: string;
+    /** Full error details/stack trace when status is error */
+    errorDetails?: string;
+    /** Whether to show interrupt hint during loading */
+    showInterrupt: boolean;
+    /** Whether to hide UI after success */
+    hideOnSuccess: boolean;
+    /** Menu options shown when status is error */
+    errorOptions: Array<{
+        label: string;
+        onSelect: () => void;
+    }>;
+}
+export declare function useAsyncOperation(): {
+    state: AsyncOperationState;
+    run: (config: AsyncOperationConfig) => Promise<void>;
+    interrupt: () => void;
+    retry: () => void;
+    clear: () => void;
+};
+export type AsyncOperation = ReturnType<typeof useAsyncOperation>;
+interface AsyncOperationStatusProps {
+    operation: AsyncOperation;
+}
+export declare const AsyncOperationStatus: React.FC<AsyncOperationStatusProps>;
+export {};

package/dist/components/AsyncOperation.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useInput } from 'ink';
+import * as React from 'react';
+import { StatusMessage } from './StatusMessage.js';
+import { SelectMenu } from './SelectMenu.js';
+export function useAsyncOperation() {
+    const [state, setState] = React.useState({
+        status: 'idle',
+        message: '',
+        showInterrupt: false,
+        hideOnSuccess: false,
+        errorOptions: [],
+    });
+    const abortControllerRef = React.useRef(null);
+    const configRef = React.useRef(null);
+    const run = React.useCallback(async (config) => {
+        configRef.current = config;
+        const retry = () => {
+            if (configRef.current) {
+                run(configRef.current);
+            }
+        };
+        const errorOptions = config.errorOptions || [
+            { label: 'Try again', onSelect: retry },
+            { label: 'Quit', onSelect: () => process.exit(0) },
+        ];
+        setState({
+            status: 'loading',
+            message: config.message,
+            tip: config.tip,
+            showInterrupt: config.showInterrupt ?? false,
+            hideOnSuccess: config.hideOnSuccess ?? false,
+            errorOptions,
+        });
+        const controller = new AbortController();
+        abortControllerRef.current = controller;
+        try {
+            await config.operation(controller.signal);
+            setState((prev) => ({ ...prev, status: 'success' }));
+        }
+        catch (err) {
+            if (err instanceof Error && err.name === 'AbortError') {
+                setState((prev) => ({ ...prev, status: 'idle' }));
+                return;
+            }
+            const error = err instanceof Error ? err : new Error(String(err));
+            setState((prev) => ({
+                ...prev,
+                status: 'error',
+                error: error.message,
+                errorDetails: error.stack,
+            }));
+            config.onError?.(error);
+        }
+        finally {
+            abortControllerRef.current = null;
+        }
+    }, []);
+    const interrupt = React.useCallback(() => {
+        abortControllerRef.current?.abort();
+        abortControllerRef.current = null;
+        setState((prev) => ({ ...prev, status: 'idle' }));
+    }, []);
+    const retry = React.useCallback(() => {
+        if (configRef.current) {
+            run(configRef.current);
+        }
+    }, [run]);
+    const clear = React.useCallback(() => {
+        setState({
+            status: 'idle',
+            message: '',
+            showInterrupt: false,
+            hideOnSuccess: false,
+            errorOptions: [],
+        });
+    }, []);
+    return {
+        state,
+        run,
+        interrupt,
+        retry,
+        clear,
+    };
+}
+export const AsyncOperationStatus = ({ operation, }) => {
+    const { state } = operation;
+    useInput((input, key) => {
+        if (state.status === 'loading' && state.showInterrupt && key.escape) {
+            operation.interrupt();
+            return;
+        }
+    });
+    if (state.status === 'idle') {
+        return null;
+    }
+    if (state.status === 'success' && state.hideOnSuccess) {
+        return null;
+    }
+    if (state.status === 'loading') {
+        return (_jsx(StatusMessage, { status: "loading", message: state.message, hint: state.showInterrupt ? '(esc to interrupt)' : undefined, tip: state.tip }));
+    }
+    if (state.status === 'success') {
+        return _jsx(StatusMessage, { status: "success", message: state.message });
+    }
+    if (state.status === 'error') {
+        return (_jsx(StatusMessage, { status: "error", message: state.message, details: state.error, errorMessage: state.errorDetails, children: _jsx(SelectMenu, { items: state.errorOptions }) }));
+    }
+    return null;
+};

package/dist/components/ChatUI.js

@@ -2,16 +2,17 @@ import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-run
 import { Box, Text, useInput, useApp } from 'ink';
 import TextInput from 'ink-text-input';
 import Spinner from 'ink-spinner';
-import chalk from 'chalk';
 import * as React from 'react';
 import { marked } from 'marked';
 // @ts-ignore - no types available
 import TerminalRenderer from 'marked-terminal';
-import { ChatClient, } from '../lib/chatClient.js';
+import { APIError } from 'openai';
 import { AgentSelector } from '../ui/AgentSelector.js';
 import { ModelSelector } from '../ui/ModelSelector.js';
 import { TeamSelector } from '../ui/TeamSelector.js';
 import { ToolSelector } from '../ui/ToolSelector.js';
+import { useAsyncOperation, AsyncOperationStatus } from './AsyncOperation.js';
+import { createConnectingToArkOperation } from '../ui/asyncOperations/connectingToArk.js';
 // Generate a unique ID for messages
 let messageIdCounter = 0;
 const generateMessageId = () => {
@@ -30,13 +31,13 @@ const configureMarkdown = () => {
 };
 const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     const { exit } = useApp();
+    const asyncOp = useAsyncOperation();
     const [messages, setMessages] = React.useState([]);
     const [input, setInput] = React.useState('');
     const [isTyping, setIsTyping] = React.useState(false);
     const [target, setTarget] = React.useState(null);
     const [availableTargets, setAvailableTargets] = React.useState([]);
     const [error, setError] = React.useState(null);
-    const [isLoading, setIsLoading] = React.useState(true);
     const [targetIndex, setTargetIndex] = React.useState(0);
     const [abortController, setAbortController] = React.useState(null);
     const [showCommands, setShowCommands] = React.useState(false);
@@ -64,78 +65,26 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
     }, [outputFormat]);
     // Initialize chat client and fetch targets on mount
     React.useEffect(() => {
-        const initializeChat = async () => {
-            try {
-                // Use the provided ArkApiClient to create ChatClient
-                const client = new ChatClient(arkApiClient);
+        asyncOp.run(createConnectingToArkOperation({
+            arkApiClient,
+            initialTargetId,
+            onSuccess: ({ client, targets, selectedTarget, selectedIndex }) => {
                 chatClientRef.current = client;
-                const targets = await client.getQueryTargets();
                 setAvailableTargets(targets);
-                if (initialTargetId) {
-                    // If initialTargetId is provided, find and set the target
-                    const matchedTarget = targets.find((t) => t.id === initialTargetId);
-                    const matchedIndex = targets.findIndex((t) => t.id === initialTargetId);
-                    if (matchedTarget) {
-                        setTarget(matchedTarget);
-                        setTargetIndex(matchedIndex >= 0 ? matchedIndex : 0);
-                        setChatConfig((prev) => ({ ...prev, currentTarget: matchedTarget }));
-                        setMessages([]);
-                    }
-                    else {
-                        // If target not found, show error and exit
-                        console.error(chalk.red('Error:'), `Target "${initialTargetId}" not found`);
-                        console.error(chalk.gray('Use "ark targets list" to see available targets'));
-                        if (arkApiProxy) {
-                            arkApiProxy.stop();
-                        }
-                        exit();
-                    }
-                }
-                else if (targets.length > 0) {
-                    // No initial target specified - auto-select first available
-                    // Priority: agents > models > tools
-                    const agents = targets.filter((t) => t.type === 'agent');
-                    const models = targets.filter((t) => t.type === 'model');
-                    const tools = targets.filter((t) => t.type === 'tool');
-                    let selectedTarget = null;
-                    let selectedIndex = 0;
-                    if (agents.length > 0) {
-                        selectedTarget = agents[0];
-                        selectedIndex = targets.findIndex((t) => t.id === agents[0].id);
-                    }
-                    else if (models.length > 0) {
-                        selectedTarget = models[0];
-                        selectedIndex = targets.findIndex((t) => t.id === models[0].id);
-                    }
-                    else if (tools.length > 0) {
-                        selectedTarget = tools[0];
-                        selectedIndex = targets.findIndex((t) => t.id === tools[0].id);
-                    }
-                    if (selectedTarget) {
-                        setTarget(selectedTarget);
-                        setTargetIndex(selectedIndex);
-                        setChatConfig((prev) => ({ ...prev, currentTarget: selectedTarget }));
-                        setMessages([]);
-                    }
-                    else {
-                        setError('No targets available');
-                    }
+                if (selectedTarget) {
+                    setTarget(selectedTarget);
+                    setTargetIndex(selectedIndex);
+                    setChatConfig((prev) => ({ ...prev, currentTarget: selectedTarget }));
+                    setMessages([]);
                 }
-                else {
-                    setError('No agents, models, or tools available');
-                }
-                setIsLoading(false);
-            }
-            catch (err) {
-                const errorMessage = err instanceof Error ? err.message : 'Failed to initialize chat';
-                console.error(chalk.red('Error:'), errorMessage);
+            },
+            onQuit: () => {
                 if (arkApiProxy) {
                     arkApiProxy.stop();
                 }
                 exit();
-            }
-        };
-        initializeChat();
+            },
+        }));
         // Cleanup function to close port forward when component unmounts
         return () => {
             if (arkApiProxy) {
@@ -548,7 +497,25 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                 // Request was cancelled, message already updated by Esc handler
                 return;
             }
-            const errorMessage = err instanceof Error ? err.message : 'Failed to send message';
+            let errorMessage = 'Failed to send message';
+            // OpenAI SDK errors include response body in .error property
+            if (err instanceof APIError) {
+                if (err.error && typeof err.error === 'object') {
+                    const errorObj = err.error;
+                    errorMessage = errorObj.message || JSON.stringify(err.error, null, 2);
+                }
+                else {
+                    errorMessage = err.message;
+                }
+            }
+            // Standard JavaScript errors
+            else if (err instanceof Error) {
+                errorMessage = err.message;
+            }
+            // String errors from throw statements
+            else if (typeof err === 'string') {
+                errorMessage = err;
+            }
             setError(errorMessage);
             setIsTyping(false);
             setAbortController(null);
@@ -631,9 +598,9 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
                                     }
                                 })() }) }))] }, toolIndex)))] }));
     };
-    // Show loading state
-    if (isLoading) {
-        return (_jsx(Box, { flexDirection: "column", children: _jsxs(Text, { color: "yellow", children: [_jsx(Spinner, { type: "dots" }), " Loading available targets..."] }) }));
+    // Show async operation status (connection, etc.)
+    if (asyncOp.state.status === 'loading' || asyncOp.state.status === 'error') {
+        return _jsx(AsyncOperationStatus, { operation: asyncOp });
     }
     // Show error if no targets available
     if (!target && error) {

package/dist/components/SelectMenu.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+export interface SelectMenuItem {
+    /** Menu item label */
+    label: string;
+    /** Optional description shown in gray */
+    description?: string;
+    /** Called when item is selected */
+    onSelect: () => void;
+}
+interface SelectMenuProps {
+    /** Menu items to display */
+    items: SelectMenuItem[];
+    /** Initial selected index (default: 0) */
+    initialIndex?: number;
+}
+export declare const SelectMenu: React.FC<SelectMenuProps>;
+export {};

package/dist/components/SelectMenu.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import * as React from 'react';
+export const SelectMenu = ({ items, initialIndex = 0, }) => {
+    const [selectedIndex, setSelectedIndex] = React.useState(initialIndex);
+    useInput((input, key) => {
+        if (key.upArrow || input === 'k') {
+            setSelectedIndex((prev) => (prev > 0 ? prev - 1 : items.length - 1));
+        }
+        else if (key.downArrow || input === 'j') {
+            setSelectedIndex((prev) => (prev < items.length - 1 ? prev + 1 : 0));
+        }
+        else if (key.return) {
+            items[selectedIndex].onSelect();
+        }
+    });
+    return (_jsx(Box, { flexDirection: "column", children: items.map((item, index) => {
+            const isSelected = index === selectedIndex;
+            return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: isSelected ? 'green' : 'gray', children: isSelected ? '❯ ' : '  ' }), _jsx(Text, { color: isSelected ? 'green' : 'white', children: item.label }), item.description && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: "gray", children: item.description })] }))] }, index));
+        }) }));
+};

package/dist/components/StatusMessage.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+export type StatusType = 'loading' | 'success' | 'error' | 'info';
+interface StatusMessageProps {
+    /** Status type determines icon and color */
+    status: StatusType;
+    /** Main message text (bold) */
+    message: string;
+    /** Optional hint shown in gray next to message */
+    hint?: string;
+    /** Optional details shown indented with ⎿ prefix */
+    details?: string;
+    /** Optional full error message shown below details */
+    errorMessage?: string;
+    /** Optional tip shown indented with ⎿ prefix */
+    tip?: string;
+    /** Optional content rendered below message */
+    children?: React.ReactNode;
+}
+export declare const StatusMessage: React.FC<StatusMessageProps>;
+export {};

package/dist/components/StatusMessage.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+export const StatusMessage = ({ status, message, hint, details, errorMessage, tip, children, }) => {
+    const statusConfig = {
+        loading: { icon: _jsx(Spinner, { type: "dots" }), color: 'yellow' },
+        success: { icon: '✓', color: 'green' },
+        error: { icon: '✗', color: 'red' },
+        info: { icon: '●', color: 'cyan' },
+    };
+    const config = statusConfig[status];
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: config.color, children: typeof config.icon === 'string' ? config.icon : config.icon }), _jsx(Text, { children: " " }), _jsx(Text, { color: config.color, bold: true, children: message }), hint && _jsxs(Text, { color: "gray", children: [" ", hint] })] }), details && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "gray", children: ["\u23BF ", details] }) })), errorMessage && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: errorMessage }) })), tip && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "gray", children: ["\u23BF ", tip] }) })), children && _jsx(Box, { marginLeft: 2, children: children })] }));
+};

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env NODE_NO_WARNINGS=1 node
+#!/usr/bin/env node
 export {};

package/dist/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env NODE_NO_WARNINGS=1 node
+#!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Command } from 'commander';
 import { render } from 'ink';

package/dist/lib/arkApiClient.d.ts

@@ -40,8 +40,7 @@ export interface Team {
 export declare class ArkApiClient {
     private openai;
     private baseUrl;
-    private namespace;
-    constructor(arkApiUrl: string, namespace?: string);
+    constructor(arkApiUrl: string);
     getBaseUrl(): string;
     getQueryTargets(): Promise<QueryTarget[]>;
     getAgents(): Promise<Agent[]>;

package/dist/lib/arkApiClient.js

@@ -1,8 +1,7 @@
 import OpenAI from 'openai';
 export class ArkApiClient {
-    constructor(arkApiUrl, namespace = 'default') {
+    constructor(arkApiUrl) {
         this.baseUrl = arkApiUrl;
-        this.namespace = namespace;
         this.openai = new OpenAI({
             baseURL: `${arkApiUrl}/openai/v1`,
             apiKey: 'dummy', // ark-api doesn't require an API key
@@ -34,7 +33,7 @@ export class ArkApiClient {
     }
     async getAgents() {
         try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/agents`);
+            const response = await fetch(`${this.baseUrl}/v1/agents`);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
@@ -47,7 +46,7 @@ export class ArkApiClient {
     }
     async getModels() {
         try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/models`);
+            const response = await fetch(`${this.baseUrl}/v1/models`);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
@@ -60,7 +59,7 @@ export class ArkApiClient {
     }
     async getTools() {
         try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/tools`);
+            const response = await fetch(`${this.baseUrl}/v1/tools`);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
@@ -73,7 +72,7 @@ export class ArkApiClient {
     }
     async getTeams() {
         try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/teams`);
+            const response = await fetch(`${this.baseUrl}/v1/teams`);
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }

package/dist/lib/config.d.ts

@@ -1,10 +1,14 @@
 import type { ClusterInfo } from './cluster.js';
+import type { ArkService } from '../types/arkService.js';
 export interface ChatConfig {
     streaming?: boolean;
     outputFormat?: 'text' | 'markdown';
 }
 export interface ArkConfig {
     chat?: ChatConfig;
+    services?: {
+        [serviceName: string]: Partial<ArkService>;
+    };
     clusterInfo?: ClusterInfo;
 }
 /**

package/dist/lib/config.js

@@ -70,6 +70,15 @@ function mergeConfig(target, source) {
             target.chat.outputFormat = source.chat.outputFormat;
         }
     }
+    if (source.services) {
+        target.services = target.services || {};
+        for (const [serviceName, overrides] of Object.entries(source.services)) {
+            target.services[serviceName] = {
+                ...target.services[serviceName],
+                ...overrides,
+            };
+        }
+    }
 }
 /**
  * Get the paths checked for config files

package/dist/lib/nextSteps.js

@@ -4,7 +4,7 @@ import chalk from 'chalk';
  */
 export function printNextSteps() {
     console.log();
-    console.log(chalk.green.bold('✓ ARK installed successfully!'));
+    console.log(chalk.green.bold('✓ Installation complete'));
     console.log();
     console.log(chalk.gray('Next steps:'));
     console.log();

package/dist/lib/nextSteps.spec.js

@@ -15,7 +15,7 @@ describe('printNextSteps', () => {
     it('prints successful installation message', () => {
         printNextSteps();
         const fullOutput = output.join('\n');
-        expect(fullOutput).toContain('ARK installed successfully!');
+        expect(fullOutput).toContain('✓ Installation complete');
     });
     it('includes all required commands', () => {
         printNextSteps();

package/dist/lib/security.js

@@ -9,6 +9,10 @@ export class SecurityUtils {
      * Validate that a path is safe and doesn't contain directory traversal attempts
      */
     static validatePath(filePath, context = 'path') {
+        // Skip validation for internal template paths - they're always safe
+        if (context === 'template path') {
+            return;
+        }
         if (!filePath || typeof filePath !== 'string') {
             throw new ValidationError(`Invalid ${context}: path must be a non-empty string`, 'path', ['Provide a valid file path']);
         }

package/dist/lib/startup.js

@@ -52,7 +52,9 @@ export function showNoClusterError() {
  */
 async function hasKubernetesContext() {
     try {
-        const { stdout } = await execa('kubectl', ['config', 'current-context']);
+        const { stdout } = await execa('kubectl', ['config', 'current-context'], {
+            timeout: 5000,
+        });
         return stdout.trim().length > 0;
     }
     catch {
@@ -72,7 +74,9 @@ export async function startup() {
     const hasContext = await hasKubernetesContext();
     if (hasContext) {
         try {
-            const { stdout } = await execa('kubectl', ['config', 'current-context']);
+            const { stdout } = await execa('kubectl', ['config', 'current-context'], {
+                timeout: 5000,
+            });
             config.clusterInfo = {
                 type: 'unknown', // We don't detect cluster type here - too slow
                 context: stdout.trim(),

package/dist/lib/startup.spec.js

@@ -138,7 +138,7 @@ describe('startup', () => {
             type: 'unknown',
             context: 'minikube',
         });
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['config', 'current-context']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['config', 'current-context'], { timeout: 5000 });
     });
     it('handles missing kubectl context gracefully', async () => {
         mockCheckCommandExists.mockResolvedValue(true);

package/dist/lib/timeout.d.ts

@@ -0,0 +1 @@
+export declare function parseTimeoutToSeconds(value: string): number;

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