@agents-at-scale/ark 0.1.37 → 0.1.39

package/dist/arkServices.js

@@ -69,6 +69,15 @@ const defaultArkServices = {
         k8sDeploymentName: 'ark-controller',
         k8sDevDeploymentName: 'ark-controller-devspace',
     },
+    'ark-tenant': {
+        name: 'ark-tenant',
+        helmReleaseName: 'ark-tenant',
+        description: 'Tenant provisioning with RBAC and resource quotas',
+        enabled: true,
+        category: 'core',
+        chartPath: `${REGISTRY_BASE}/ark-tenant`,
+        installArgs: [],
+    },
     'ark-api': {
         name: 'ark-api',
         helmReleaseName: 'ark-api',

package/dist/commands/chat/index.js

@@ -13,14 +13,13 @@ export function createChatCommand(config) {
         // Direct target argument (e.g., "agent/sample-agent")
         const initialTargetId = targetArg;
         // Config is passed from main
-        // Initialize proxy first - no spinner, just let ChatUI handle loading state
         try {
             const proxy = new ArkApiProxy();
             const arkApiClient = await proxy.start();
-            // Pass the initialized client and config to ChatUI
             render(_jsx(ChatUI, { initialTargetId: initialTargetId, arkApiClient: arkApiClient, arkApiProxy: proxy, config: config }));
         }
         catch (error) {
+            // Handle proxy startup failure or other errors
             output.error(error instanceof Error ? error.message : 'ARK API connection failed');
             process.exit(1);
         }

package/dist/commands/generate/generators/project.js

@@ -46,7 +46,7 @@ class ProjectGenerator {
             spinner.succeed('Prerequisites validated');
             // Get project configuration
             spinner.start('Gathering project configuration');
-            const config = await this.getProjectConfig(name, destination, options);
+            const config = await this.getProjectConfig(name, destination, options, spinner);
             spinner.succeed(`Project "${config.name}" configured`);
             // Discover and configure models (only if not skipped)
             if (config.configureModels) {
@@ -104,25 +104,28 @@ class ProjectGenerator {
             console.log(chalk.cyan('💡 Tip: Install kubectl and helm later to deploy your project to a cluster'));
         }
     }
-    async getProjectConfig(name, destination, options) {
-        console.log(chalk.gray(`\n${'─'.repeat(50)}`));
-        console.log(chalk.cyan('Project Configuration'));
-        console.log(chalk.gray(`${'─'.repeat(50)}\n`));
-        // Use command line options if provided, otherwise prompt
+    async getProjectConfig(name, destination, options, spinner) {
+        // Use command line options if provided
         let projectType = options.projectType;
         let parentDir = destination;
-        let namespace = options.namespace || name;
+        let namespace = options.namespace;
         // Validate project type if provided
         if (projectType &&
             projectType !== 'empty' &&
             projectType !== 'with-samples') {
             throw new Error(`Invalid project type: ${projectType}. Must be 'empty' or 'with-samples'`);
         }
-        // Validate and normalize namespace
-        namespace = toKebabCase(namespace);
-        validateNameStrict(namespace, 'namespace');
-        // Only prompt if in interactive mode and missing required options
-        if (options.interactive || !options.projectType || !options.namespace) {
+        // Default to interactive mode unless all required options are provided
+        // or explicitly set to non-interactive
+        const shouldPrompt = options.interactive !== false &&
+            (!options.projectType || !options.namespace);
+        if (shouldPrompt) {
+            // Stop spinner before showing prompts
+            spinner.stop();
+            // Show configuration header only when prompting
+            console.log(chalk.gray(`\n${'─'.repeat(50)}`));
+            console.log(chalk.cyan('Project Configuration'));
+            console.log(chalk.gray(`${'─'.repeat(50)}\n`));
             const prompts = [];
             if (!options.projectType) {
                 prompts.push({
@@ -160,11 +163,19 @@ class ProjectGenerator {
                 parentDir = answers.parentDir || parentDir;
                 namespace = answers.namespace || namespace;
             }
+            // Restart spinner after prompts
+            spinner.start('Finalizing configuration');
         }
-        // Ensure projectType has a value
+        // Use defaults for missing options
         if (!projectType) {
-            throw new Error('Project type is required. Use --project-type <empty|with-samples> or run in interactive mode.');
+            projectType = GENERATOR_DEFAULTS.projectType; // 'with-samples'
         }
+        if (!namespace) {
+            namespace = name; // Default namespace to project name
+        }
+        // Validate and normalize namespace
+        namespace = toKebabCase(namespace);
+        validateNameStrict(namespace, 'namespace');
         const projectPath = path.join(parentDir, name);
         // Check if directory exists
         if (fs.existsSync(projectPath)) {
@@ -329,7 +340,10 @@ class ProjectGenerator {
         return descriptions[name] || `Model: ${name}`;
     }
     async configureGit(config) {
-        console.log(chalk.cyan('📋 Git Repository Configuration\n'));
+        // If git setup is explicitly skipped, don't do anything
+        if (!config.initGit) {
+            return;
+        }
         // Check if git is available
         const gitAvailable = await this.isGitAvailable();
         if (!gitAvailable) {
@@ -337,7 +351,7 @@ class ProjectGenerator {
             config.initGit = false;
             return;
         }
-        // Check if git is configured
+        // Check if git is configured (only if we're initializing git)
         try {
             await execa('git', ['config', 'user.name'], { stdio: 'pipe' });
             await execa('git', ['config', 'user.email'], { stdio: 'pipe' });
@@ -345,16 +359,9 @@ class ProjectGenerator {
         catch {
             console.log(chalk.yellow('⚠️  Git user not configured. Run: git config --global user.name "Your Name" && git config --global user.email "your.email@example.com"'));
         }
-        const gitAnswers = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'initGit',
-                message: 'Initialize git repository with initial commit?',
-                default: true,
-            },
-        ]);
-        config.initGit = gitAnswers.initGit;
-        config.createCommit = gitAnswers.initGit; // Always create commit if initializing git
+        // Since initGit is already true from command line options or defaults,
+        // we can proceed without prompting
+        config.createCommit = true; // Always create commit if initializing git
     }
     async generateProject(config) {
         console.log(chalk.cyan(CLI_CONFIG.messages.generatingProject));

package/dist/commands/generate/index.js

@@ -214,9 +214,9 @@ ${chalk.cyan('Use Cases:')}
             : 'Working directory (default: current directory)', type === 'project' || type === 'marketplace'
             ? getDefaultDestination()
             : undefined)
-            .option('-i, --interactive', type === 'marketplace'
+            .option('--no-interactive', type === 'marketplace'
             ? 'Not supported for marketplace'
-            : 'Force additional configuration prompts (generators prompt by default when info is missing)', false);
+            : 'Skip interactive prompts and use defaults (prompts by default)');
         if (helpText?.examples) {
             subCommand.addHelpText('after', helpText.examples);
         }

package/dist/commands/generate/templateDiscovery.js

@@ -3,11 +3,20 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 export class TemplateDiscovery {
     constructor() {
-        // Get the path to the templates directory relative to the ark CLI
-        // Navigate from tools/ark-cli/src/commands/generate/templateDiscovery.js to agents-at-scale/templates
+        // Get the path to the templates directory
+        // This handles both development and production scenarios
         const currentFile = fileURLToPath(import.meta.url);
-        const arkRoot = path.resolve(path.dirname(currentFile), '../../../../../');
-        this.templatesPath = path.join(arkRoot, 'templates');
+        // Try production path first (templates included in npm package)
+        const packageRoot = path.resolve(path.dirname(currentFile), '../../../');
+        const productionTemplatesPath = path.join(packageRoot, 'templates');
+        if (fs.existsSync(productionTemplatesPath)) {
+            this.templatesPath = productionTemplatesPath;
+        }
+        else {
+            // Fall back to development path (relative to ARK project root)
+            const arkRoot = path.resolve(path.dirname(currentFile), '../../../../../');
+            this.templatesPath = path.join(arkRoot, 'templates');
+        }
     }
     /**
      * Discover all available templates in the templates directory

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,17 +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 { APIError } from 'openai';
-import { ChatClient, } from '../lib/chatClient.js';
 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 = () => {
@@ -31,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);
@@ -65,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');
-                    }
-                }
-                else {
-                    setError('No agents, models, or tools available');
+                if (selectedTarget) {
+                    setTarget(selectedTarget);
+                    setTargetIndex(selectedIndex);
+                    setChatConfig((prev) => ({ ...prev, currentTarget: selectedTarget }));
+                    setMessages([]);
                 }
-                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) {
@@ -553,7 +501,8 @@ const ChatUI = ({ initialTargetId, arkApiClient, arkApiProxy, config, }) => {
             // OpenAI SDK errors include response body in .error property
             if (err instanceof APIError) {
                 if (err.error && typeof err.error === 'object') {
-                    errorMessage = JSON.stringify(err.error, null, 2);
+                    const errorObj = err.error;
+                    errorMessage = errorObj.message || JSON.stringify(err.error, null, 2);
                 }
                 else {
                     errorMessage = err.message;
@@ -649,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/ui/asyncOperations/connectingToArk.d.ts

@@ -0,0 +1,15 @@
+import { AsyncOperationConfig } from '../../components/AsyncOperation.js';
+import { ArkApiClient } from '../../lib/arkApiClient.js';
+import { ChatClient, QueryTarget } from '../../lib/chatClient.js';
+export interface ConnectingToArkParams {
+    arkApiClient: ArkApiClient;
+    initialTargetId?: string;
+    onSuccess: (data: {
+        client: ChatClient;
+        targets: QueryTarget[];
+        selectedTarget: QueryTarget | null;
+        selectedIndex: number;
+    }) => void;
+    onQuit: () => void;
+}
+export declare function createConnectingToArkOperation(params: ConnectingToArkParams): AsyncOperationConfig;

package/dist/ui/asyncOperations/connectingToArk.js

@@ -0,0 +1,63 @@
+import { ChatClient } from '../../lib/chatClient.js';
+export function createConnectingToArkOperation(params) {
+    return {
+        message: 'Connecting to Ark...',
+        operation: async (_signal) => {
+            const client = new ChatClient(params.arkApiClient);
+            const targets = await client.getQueryTargets();
+            let selectedTarget = null;
+            let selectedIndex = 0;
+            if (params.initialTargetId) {
+                const matchedTarget = targets.find((t) => t.id === params.initialTargetId);
+                const matchedIndex = targets.findIndex((t) => t.id === params.initialTargetId);
+                if (matchedTarget) {
+                    selectedTarget = matchedTarget;
+                    selectedIndex = matchedIndex >= 0 ? matchedIndex : 0;
+                }
+                else {
+                    throw new Error(`Target "${params.initialTargetId}" not found. Use "ark targets list" to see available targets.`);
+                }
+            }
+            else if (targets.length > 0) {
+                const agents = targets.filter((t) => t.type === 'agent');
+                const models = targets.filter((t) => t.type === 'model');
+                const tools = targets.filter((t) => t.type === 'tool');
+                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);
+                }
+                else {
+                    throw new Error('No targets available');
+                }
+            }
+            else {
+                throw new Error('No agents, models, or tools available');
+            }
+            params.onSuccess({
+                client,
+                targets,
+                selectedTarget,
+                selectedIndex,
+            });
+        },
+        hideOnSuccess: true,
+        errorOptions: [
+            { label: 'Try again', onSelect: () => { } },
+            {
+                label: 'Check status',
+                onSelect: () => {
+                    console.log('Status command not yet implemented');
+                },
+            },
+            { label: 'Quit', onSelect: params.onQuit },
+        ],
+    };
+}