@agents-at-scale/ark 0.1.31

package/dist/lib/kubernetes.js

@@ -0,0 +1,122 @@
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import * as k8s from '@kubernetes/client-node';
+export class KubernetesConfigManager {
+    constructor() {
+        this.kc = new k8s.KubeConfig();
+    }
+    /**
+     * Get the KubeConfig instance for API client creation
+     */
+    getKubeConfig() {
+        return this.kc;
+    }
+    /**
+     * Initialize Kubernetes configuration similar to fark's approach
+     * Priority: in-cluster config > KUBECONFIG env > ~/.kube/config
+     */
+    async initializeConfig() {
+        let kubeconfig;
+        let currentContext;
+        let namespace;
+        let inCluster = false;
+        // Check if we're explicitly in a Kubernetes pod environment
+        const isInPod = process.env.KUBERNETES_SERVICE_HOST &&
+            process.env.KUBERNETES_SERVICE_PORT &&
+            process.env.POD_NAMESPACE;
+        if (isInPod) {
+            try {
+                // Try in-cluster config only if we're definitely in a pod
+                this.kc.loadFromCluster();
+                inCluster = true;
+                kubeconfig = '/var/run/secrets/kubernetes.io/serviceaccount';
+                namespace = process.env.POD_NAMESPACE || 'default';
+            }
+            catch (error) {
+                throw new Error(`Failed to load in-cluster Kubernetes configuration: ${error}`);
+            }
+        }
+        else {
+            // Use kubeconfig file for local development
+            try {
+                kubeconfig =
+                    process.env.KUBECONFIG || join(homedir(), '.kube', 'config');
+                // Check if kubeconfig file exists
+                await fs.access(kubeconfig);
+                this.kc.loadFromFile(kubeconfig);
+                // Get current context and namespace
+                currentContext = this.kc.currentContext;
+                // Simplified namespace detection - just use default for now
+                // Complex namespace detection can be added later if needed
+                namespace = 'default';
+            }
+            catch (error) {
+                throw new Error(`Failed to load Kubernetes configuration: ${error}`);
+            }
+        }
+        return {
+            kubeconfig,
+            currentContext,
+            namespace,
+            inCluster,
+        };
+    }
+    /**
+     * Get the API server URL for the current cluster
+     */
+    getClusterApiUrl() {
+        const cluster = this.kc.getCurrentCluster();
+        if (!cluster) {
+            throw new Error('No current cluster found in kubeconfig');
+        }
+        return cluster.server;
+    }
+    /**
+     * Detect ark-api service URL in the cluster
+     * This mimics how fark discovers services
+     */
+    async getArkApiUrl(namespace = 'default') {
+        const k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
+        try {
+            // Try to find ark-api service
+            const service = await k8sApi.readNamespacedService({
+                name: 'ark-api',
+                namespace,
+            });
+            if (service.spec?.type === 'LoadBalancer' &&
+                service.status?.loadBalancer?.ingress?.[0]) {
+                const ingress = service.status.loadBalancer.ingress[0];
+                const host = ingress.ip || ingress.hostname;
+                const port = service.spec.ports?.[0]?.port || 8080;
+                return `http://${host}:${port}`;
+            }
+            if (service.spec?.type === 'NodePort' && service.spec.ports?.[0]) {
+                const nodePort = service.spec.ports[0].nodePort;
+                const clusterUrl = this.getClusterApiUrl();
+                const clusterHost = new URL(clusterUrl).hostname;
+                return `http://${clusterHost}:${nodePort}`;
+            }
+            // Default to port-forward style access
+            const port = service.spec?.ports?.[0]?.port || 8080;
+            return `http://localhost:${port}`;
+        }
+        catch (error) {
+            // Service not found or not accessible
+            throw new Error(`ark-api service not found or not accessible in namespace '${namespace}': ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    /**
+     * Check if we can access the cluster
+     */
+    async testClusterAccess() {
+        try {
+            const k8sApi = this.kc.makeApiClient(k8s.CoreV1Api);
+            await k8sApi.listNamespace();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/lib/progress.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Progress indicators and user experience utilities for ARK CLI
+ */
+export interface ProgressStep {
+    name: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+    message?: string;
+    duration?: number;
+}
+export declare class ProgressIndicator {
+    private title;
+    private steps;
+    private startTime;
+    constructor(title: string);
+    /**
+     * Add a step to the progress indicator
+     */
+    addStep(name: string, message?: string): void;
+    /**
+     * Start a step
+     */
+    startStep(name: string, message?: string): void;
+    /**
+     * Complete a step
+     */
+    completeStep(name: string, message?: string): void;
+    /**
+     * Fail a step
+     */
+    failStep(name: string, message?: string): void;
+    /**
+     * Skip a step
+     */
+    skipStep(name: string, message?: string): void;
+    /**
+     * Render the current progress
+     */
+    private renderProgress;
+    /**
+     * Complete the progress indicator
+     */
+    complete(message?: string): void;
+    /**
+     * Get status icon for a step
+     */
+    private getStatusIcon;
+    /**
+     * Get status color for a step
+     */
+    private getStatusColor;
+}
+/**
+ * Simple spinner for long-running operations
+ */
+export declare class Spinner {
+    private frames;
+    private index;
+    private interval;
+    private message;
+    constructor(message: string);
+    start(): void;
+    stop(finalMessage?: string): void;
+    fail(errorMessage?: string): void;
+}
+/**
+ * Enhanced prompts with better validation and user guidance
+ */
+export declare class EnhancedPrompts {
+    /**
+     * Show a helpful tip to the user
+     */
+    static showTip(message: string): void;
+    /**
+     * Show a warning to the user
+     */
+    static showWarning(message: string): void;
+    /**
+     * Show information to the user
+     */
+    static showInfo(message: string): void;
+    /**
+     * Show a success message
+     */
+    static showSuccess(message: string): void;
+    /**
+     * Show available options for a choice
+     */
+    static showChoiceHelp(title: string, choices: Array<{
+        name: string;
+        description: string;
+    }>): void;
+    /**
+     * Show next steps after completion
+     */
+    static showNextSteps(title: string, steps: string[]): void;
+    /**
+     * Show a separator for better visual organization
+     */
+    static showSeparator(title?: string): void;
+}
+/**
+ * Utility for consistent formatting of output
+ */
+export declare class OutputFormatter {
+    /**
+     * Format a list of key-value pairs
+     */
+    static formatKeyValueList(items: Array<{
+        key: string;
+        value: string;
+        highlight?: boolean;
+    }>): void;
+    /**
+     * Format a file list with icons
+     */
+    static formatFileList(files: Array<{
+        path: string;
+        type: 'file' | 'directory';
+        description?: string;
+    }>): void;
+    /**
+     * Format command examples
+     */
+    static formatCommands(title: string, commands: Array<{
+        command: string;
+        description: string;
+    }>): void;
+}

package/dist/lib/progress.js

@@ -0,0 +1,273 @@
+/**
+ * Progress indicators and user experience utilities for ARK CLI
+ */
+import chalk from 'chalk';
+export class ProgressIndicator {
+    constructor(title) {
+        this.title = title;
+        this.steps = [];
+        this.startTime = Date.now();
+        console.log(chalk.blue(`\n🚀 ${this.title}\n`));
+    }
+    /**
+     * Add a step to the progress indicator
+     */
+    addStep(name, message) {
+        this.steps.push({
+            name,
+            status: 'pending',
+            message,
+        });
+    }
+    /**
+     * Start a step
+     */
+    startStep(name, message) {
+        const step = this.steps.find((s) => s.name === name);
+        if (step) {
+            step.status = 'running';
+            step.message = message;
+            this.renderProgress();
+        }
+    }
+    /**
+     * Complete a step
+     */
+    completeStep(name, message) {
+        const step = this.steps.find((s) => s.name === name);
+        if (step) {
+            step.status = 'completed';
+            step.message = message;
+            this.renderProgress();
+        }
+    }
+    /**
+     * Fail a step
+     */
+    failStep(name, message) {
+        const step = this.steps.find((s) => s.name === name);
+        if (step) {
+            step.status = 'failed';
+            step.message = message;
+            this.renderProgress();
+        }
+    }
+    /**
+     * Skip a step
+     */
+    skipStep(name, message) {
+        const step = this.steps.find((s) => s.name === name);
+        if (step) {
+            step.status = 'skipped';
+            step.message = message;
+            this.renderProgress();
+        }
+    }
+    /**
+     * Render the current progress
+     */
+    renderProgress() {
+        // Clear previous output (simple version)
+        process.stdout.write('\r\x1b[K');
+        for (const step of this.steps) {
+            const icon = this.getStatusIcon(step.status);
+            const color = this.getStatusColor(step.status);
+            const statusText = step.message || step.name;
+            console.log(`${icon} ${chalk[color](statusText)}`);
+        }
+        // Move cursor back up to overwrite on next update
+        if (this.steps.length > 1) {
+            process.stdout.write(`\x1b[${this.steps.length}A`);
+        }
+    }
+    /**
+     * Complete the progress indicator
+     */
+    complete(message) {
+        // Clear any remaining progress rendering
+        process.stdout.write('\r\x1b[K');
+        // Only print failed or skipped steps - hide successful validation
+        const importantSteps = this.steps.filter((step) => step.status === 'failed' || step.status === 'skipped');
+        for (const step of importantSteps) {
+            const icon = this.getStatusIcon(step.status);
+            const color = this.getStatusColor(step.status);
+            const statusText = step.message || step.name;
+            console.log(`${icon} ${chalk[color](statusText)}`);
+        }
+        const duration = Date.now() - this.startTime;
+        const durationText = duration > 1000 ? `${(duration / 1000).toFixed(1)}s` : `${duration}ms`;
+        // Only show completion message if there were issues or if verbose
+        if (importantSteps.length > 0) {
+            console.log(chalk.green(`\n✅ ${message || this.title} completed in ${durationText}\n`));
+        }
+    }
+    /**
+     * Get status icon for a step
+     */
+    getStatusIcon(status) {
+        switch (status) {
+            case 'pending':
+                return chalk.gray('⏳');
+            case 'running':
+                return chalk.blue('🔄');
+            case 'completed':
+                return chalk.green('✅');
+            case 'failed':
+                return chalk.red('❌');
+            case 'skipped':
+                return chalk.yellow('⏭️');
+            default:
+                return '❓';
+        }
+    }
+    /**
+     * Get status color for a step
+     */
+    getStatusColor(status) {
+        switch (status) {
+            case 'pending':
+                return 'gray';
+            case 'running':
+                return 'blue';
+            case 'completed':
+                return 'green';
+            case 'failed':
+                return 'red';
+            case 'skipped':
+                return 'yellow';
+            default:
+                return 'gray';
+        }
+    }
+}
+/**
+ * Simple spinner for long-running operations
+ */
+export class Spinner {
+    constructor(message) {
+        this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        this.index = 0;
+        this.interval = null;
+        this.message = message;
+    }
+    start() {
+        this.interval = setInterval(() => {
+            process.stdout.write(`\r${chalk.blue(this.frames[this.index])} ${this.message}`);
+            this.index = (this.index + 1) % this.frames.length;
+        }, 100);
+    }
+    stop(finalMessage) {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        process.stdout.write(`\r\x1b[K${finalMessage ? chalk.green(`✅ ${finalMessage}`) : ''}\n`);
+    }
+    fail(errorMessage) {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        process.stdout.write(`\r\x1b[K${errorMessage ? chalk.red(`❌ ${errorMessage}`) : ''}\n`);
+    }
+}
+/**
+ * Enhanced prompts with better validation and user guidance
+ */
+export class EnhancedPrompts {
+    /**
+     * Show a helpful tip to the user
+     */
+    static showTip(message) {
+        console.log(chalk.cyan(`💡 Tip: ${message}`));
+    }
+    /**
+     * Show a warning to the user
+     */
+    static showWarning(message) {
+        console.log(chalk.yellow(`⚠️  Warning: ${message}`));
+    }
+    /**
+     * Show information to the user
+     */
+    static showInfo(message) {
+        console.log(chalk.blue(`ℹ️  ${message}`));
+    }
+    /**
+     * Show a success message
+     */
+    static showSuccess(message) {
+        console.log(chalk.green(`✅ ${message}`));
+    }
+    /**
+     * Show available options for a choice
+     */
+    static showChoiceHelp(title, choices) {
+        console.log(chalk.cyan(`\n📋 ${title}:`));
+        choices.forEach((choice) => {
+            console.log(chalk.gray(`  • ${chalk.white(choice.name)}: ${choice.description}`));
+        });
+        console.log();
+    }
+    /**
+     * Show next steps after completion
+     */
+    static showNextSteps(title, steps) {
+        console.log(chalk.cyan(`\n📋 ${title}:`));
+        steps.forEach((step, index) => {
+            console.log(chalk.gray(`  ${index + 1}. ${step}`));
+        });
+        console.log();
+    }
+    /**
+     * Show a separator for better visual organization
+     */
+    static showSeparator(title) {
+        if (title) {
+            console.log(chalk.gray(`\n${'─'.repeat(50)}`));
+            console.log(chalk.cyan(`${title}`));
+            console.log(chalk.gray(`${'─'.repeat(50)}\n`));
+        }
+        else {
+            console.log(chalk.gray(`${'─'.repeat(50)}`));
+        }
+    }
+}
+/**
+ * Utility for consistent formatting of output
+ */
+export class OutputFormatter {
+    /**
+     * Format a list of key-value pairs
+     */
+    static formatKeyValueList(items) {
+        const maxKeyLength = Math.max(...items.map((item) => item.key.length));
+        items.forEach((item) => {
+            const paddedKey = item.key.padEnd(maxKeyLength);
+            const color = item.highlight ? 'cyan' : 'gray';
+            console.log(`  ${chalk[color](paddedKey)}: ${chalk.white(item.value)}`);
+        });
+    }
+    /**
+     * Format a file list with icons
+     */
+    static formatFileList(files) {
+        files.forEach((file) => {
+            const icon = file.type === 'directory' ? '📁' : '📄';
+            const description = file.description
+                ? chalk.gray(` - ${file.description}`)
+                : '';
+            console.log(`  ${icon} ${chalk.white(file.path)}${description}`);
+        });
+    }
+    /**
+     * Format command examples
+     */
+    static formatCommands(title, commands) {
+        console.log(chalk.cyan(`\n${title}:`));
+        commands.forEach((cmd) => {
+            console.log(`  ${chalk.yellow(cmd.command)}`);
+            console.log(chalk.gray(`    ${cmd.description}\n`));
+        });
+    }
+}

package/dist/lib/security.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Security utilities for ARK CLI
+ */
+export declare class SecurityUtils {
+    /**
+     * Validate that a path is safe and doesn't contain directory traversal attempts
+     */
+    static validatePath(filePath: string, context?: string): void;
+    /**
+     * Ensure a directory path is safe to create/write to
+     */
+    static validateOutputPath(outputPath: string, baseDir: string): void;
+    /**
+     * Sanitize file names to prevent issues
+     */
+    static sanitizeFileName(fileName: string): string;
+    /**
+     * Validate template content to prevent code injection
+     */
+    static validateTemplateContent(content: string, templatePath: string): void;
+    /**
+     * Safely create directories with proper permissions
+     */
+    static createDirectorySafe(dirPath: string, baseDir: string): Promise<void>;
+    /**
+     * Safely write files with proper permissions
+     */
+    static writeFileSafe(filePath: string, content: string, baseDir: string): Promise<void>;
+    /**
+     * Validate environment variables for safety
+     */
+    static sanitizeEnvironmentValue(value: string, varName: string): string;
+    /**
+     * Validate API keys and secrets
+     */
+    static validateSecret(secret: string, secretType: string): void;
+}