@agents-at-scale/ark 0.1.31

package/dist/lib/security.js

@@ -0,0 +1,295 @@
+/**
+ * Security utilities for ARK CLI
+ */
+import path from 'path';
+import fs from 'fs';
+import { ValidationError } from './errors.js';
+export class SecurityUtils {
+    /**
+     * Validate that a path is safe and doesn't contain directory traversal attempts
+     */
+    static validatePath(filePath, context = 'path') {
+        if (!filePath || typeof filePath !== 'string') {
+            throw new ValidationError(`Invalid ${context}: path must be a non-empty string`, 'path', ['Provide a valid file path']);
+        }
+        // Normalize the path to resolve any relative components
+        const normalizedPath = path.normalize(filePath);
+        // Check for directory traversal attempts
+        if (normalizedPath.includes('..') || normalizedPath.includes('~')) {
+            throw new ValidationError(`Unsafe ${context}: contains directory traversal sequences`, 'path', [
+                'Use absolute paths or simple relative paths',
+                'Remove parent directory references (..)',
+                'Remove home directory references (~)',
+            ]);
+        }
+        // Check for absolute paths that go outside expected directories
+        if (path.isAbsolute(normalizedPath)) {
+            const dangerous = ['/etc', '/var', '/usr', '/bin', '/sbin', '/root'];
+            if (dangerous.some((dangerousPath) => normalizedPath.startsWith(dangerousPath))) {
+                throw new ValidationError(`Unsafe ${context}: attempts to access system directory`, 'path', [
+                    'Use project-relative paths',
+                    'Avoid system directories',
+                    'Use a safe working directory',
+                ]);
+            }
+        }
+        // Check for null bytes and other dangerous characters
+        if (normalizedPath.includes('\0') || normalizedPath.includes('\u0000')) {
+            throw new ValidationError(`Invalid ${context}: contains null bytes`, 'path', ['Remove null bytes from the path']);
+        }
+    }
+    /**
+     * Ensure a directory path is safe to create/write to
+     */
+    static validateOutputPath(outputPath, baseDir) {
+        this.validatePath(outputPath, 'output path');
+        this.validatePath(baseDir, 'base directory');
+        const resolvedOutput = path.resolve(outputPath);
+        const resolvedBase = path.resolve(baseDir);
+        // Ensure the output path is within the base directory
+        if (!resolvedOutput.startsWith(resolvedBase)) {
+            throw new ValidationError('Output path is outside the allowed directory', 'outputPath', [
+                `Ensure output path is within: ${resolvedBase}`,
+                'Use relative paths within the project',
+                'Check for directory traversal in the path',
+            ]);
+        }
+    }
+    /**
+     * Sanitize file names to prevent issues
+     */
+    static sanitizeFileName(fileName) {
+        if (!fileName || typeof fileName !== 'string') {
+            throw new ValidationError('Invalid file name: must be a non-empty string', 'fileName');
+        }
+        // Standard dotfiles that should be preserved
+        const allowedDotfiles = [
+            '.gitignore',
+            '.gitattributes',
+            '.github',
+            '.gitmodules',
+            '.helmignore',
+            '.dockerignore',
+            '.eslintrc',
+            '.prettierrc',
+            '.editorconfig',
+            '.nvmrc',
+            '.yamllint.yml',
+            '.yamllint.yaml',
+            '.env',
+            '.env.example',
+            '.env.local',
+            '.env.production',
+            '.vscode',
+            '.idea',
+            '.vimrc',
+            '.bashrc',
+            '.zshrc',
+            '.keep',
+        ];
+        // Check if this is an allowed dotfile
+        const isAllowedDotfile = allowedDotfiles.some((allowed) => fileName === allowed || fileName.startsWith(allowed + '.'));
+        // Remove dangerous characters
+        let sanitized = fileName
+            .replace(/[<>:"/\\|?*]/g, '') // Windows forbidden chars
+            .replace(/\s+/g, '-') // Replace spaces with hyphens
+            .replace(/-{2,}/g, '-') // Replace 2+ consecutive hyphens with single hyphen (ReDoS-safe)
+            .replace(/^-/, '') // Remove single leading hyphen (ReDoS-safe)
+            .replace(/-$/, ''); // Remove single trailing hyphen (ReDoS-safe)
+        // Remove leading dots only if not an allowed dotfile
+        if (!isAllowedDotfile) {
+            sanitized = sanitized.replace(/^\\./, ''); // Remove single leading dot (ReDoS-safe)
+        }
+        // Ensure it's not empty after sanitization
+        if (!sanitized) {
+            throw new ValidationError('File name becomes empty after sanitization', 'fileName', ['Use alphanumeric characters and hyphens only']);
+        }
+        // Ensure it's not too long
+        if (sanitized.length > 255) {
+            sanitized = sanitized.substring(0, 255);
+        }
+        // Check for reserved names (Windows)
+        const reservedNames = [
+            'CON',
+            'PRN',
+            'AUX',
+            'NUL',
+            'COM1',
+            'COM2',
+            'COM3',
+            'COM4',
+            'COM5',
+            'COM6',
+            'COM7',
+            'COM8',
+            'COM9',
+            'LPT1',
+            'LPT2',
+            'LPT3',
+            'LPT4',
+            'LPT5',
+            'LPT6',
+            'LPT7',
+            'LPT8',
+            'LPT9',
+        ];
+        if (reservedNames.includes(sanitized.toUpperCase())) {
+            sanitized = `_${sanitized}`;
+        }
+        return sanitized;
+    }
+    /**
+     * Validate template content to prevent code injection
+     */
+    static validateTemplateContent(content, templatePath) {
+        if (!content || typeof content !== 'string') {
+            return; // Empty content is fine
+        }
+        // File types that legitimately need shell/script syntax and should skip validation
+        const exemptFileTypes = [
+            '.sh',
+            '.bash',
+            '.zsh',
+            '.fish', // Shell scripts
+            'Makefile',
+            'makefile',
+            '.mk', // Makefiles
+            '.ps1',
+            '.cmd',
+            '.bat', // Windows scripts
+            '.py',
+            '.js',
+            '.ts',
+            '.rb',
+            '.pl', // Programming languages
+            '.dockerfile',
+            'Dockerfile', // Docker files
+            '.yml',
+            '.yaml', // YAML files (may contain scripts in CI/CD)
+            '.md',
+            '.markdown',
+            '.rst',
+            '.txt', // Documentation files (may contain code examples)
+        ];
+        const fileName = path.basename(templatePath).toLowerCase();
+        const fileExt = path.extname(templatePath).toLowerCase();
+        // Skip validation for exempt file types
+        if (exemptFileTypes.some((exempt) => fileName === exempt.toLowerCase() ||
+            fileName.includes(exempt.toLowerCase()) ||
+            fileExt === exempt.toLowerCase())) {
+            return;
+        }
+        // Check for potentially dangerous patterns
+        const dangerousPatterns = [
+            /\$\{[\w.]{0,100}?\([a-zA-Z0-9_.,\s]{0,100}?\)/, // Function calls in template variables (ReDoS-safe)
+            /\$\([a-zA-Z0-9\s._-]{0,100}?\)/, // Command substitution (ReDoS-safe)
+            /`[a-zA-Z0-9\s._${}()-]{0,500}?`/, // Backticks (ReDoS-safe)
+            /eval\s*\(/, // Eval statements
+            /exec\s*\(/, // Exec statements
+            /require\s*\(/, // Require statements
+            /\bimport\s/, // Import statements (ReDoS-safe - simple detection)
+        ];
+        for (const pattern of dangerousPatterns) {
+            if (pattern.test(content)) {
+                throw new ValidationError(`Template contains potentially dangerous code: ${templatePath}`, 'templateContent', [
+                    'Remove code execution patterns from templates',
+                    'Use only variable substitution',
+                    'Check template for malicious content',
+                ]);
+            }
+        }
+    }
+    /**
+     * Safely create directories with proper permissions
+     */
+    static async createDirectorySafe(dirPath, baseDir) {
+        this.validateOutputPath(dirPath, baseDir);
+        try {
+            await fs.promises.mkdir(dirPath, {
+                recursive: true,
+                mode: 0o755, // Read/write/execute for owner, read/execute for group and others
+            });
+        }
+        catch (error) {
+            throw new ValidationError(`Failed to create directory: ${dirPath}: ${error instanceof Error ? error.message : String(error)}`, 'directory', [
+                'Check file permissions',
+                'Ensure parent directory exists',
+                'Verify disk space availability',
+            ]);
+        }
+    }
+    /**
+     * Safely write files with proper permissions
+     */
+    static async writeFileSafe(filePath, content, baseDir) {
+        this.validateOutputPath(filePath, baseDir);
+        this.validateTemplateContent(content, filePath);
+        const fileName = path.basename(filePath);
+        const sanitizedFileName = this.sanitizeFileName(fileName);
+        if (sanitizedFileName !== fileName) {
+            throw new ValidationError(`File name requires sanitization: "${fileName}" → "${sanitizedFileName}"`, 'fileName', [`Use the sanitized name: "${sanitizedFileName}"`]);
+        }
+        try {
+            await fs.promises.writeFile(filePath, content, {
+                mode: 0o644, // Read/write for owner, read for group and others
+                flag: 'w', // Overwrite if exists
+            });
+        }
+        catch (error) {
+            throw new ValidationError(`Failed to write file: ${filePath}: ${error instanceof Error ? error.message : String(error)}`, 'file', [
+                'Check file permissions',
+                'Ensure directory exists',
+                'Verify disk space availability',
+            ]);
+        }
+    }
+    /**
+     * Validate environment variables for safety
+     */
+    static sanitizeEnvironmentValue(value, varName) {
+        if (!value || typeof value !== 'string') {
+            return '';
+        }
+        // Remove potentially dangerous characters
+        const sanitized = value
+            .replace(/[`$\\]/g, '') // Command injection chars
+            .trim();
+        // Warn if significant changes were made
+        if (sanitized !== value && sanitized.length < value.length * 0.8) {
+            console.warn(`Warning: Environment variable ${varName} was heavily sanitized`);
+        }
+        return sanitized;
+    }
+    /**
+     * Validate API keys and secrets
+     */
+    static validateSecret(secret, secretType) {
+        if (!secret || typeof secret !== 'string') {
+            throw new ValidationError(`Invalid ${secretType}: must be a non-empty string`, 'secret');
+        }
+        // Check for common patterns that suggest it's not a real secret
+        const testPatterns = [
+            /^(test|dummy|fake|placeholder|example)/i,
+            /^(xxx|000|123)/,
+            /^your[_-]?key/i,
+            /^replace[_-]?me/i,
+        ];
+        for (const pattern of testPatterns) {
+            if (pattern.test(secret)) {
+                throw new ValidationError(`${secretType} appears to be a placeholder value`, 'secret', [
+                    `Replace with a real ${secretType}`,
+                    'Check your configuration',
+                    'Ensure secrets are properly set',
+                ]);
+            }
+        }
+        // Basic length validation (most API keys are at least 16 chars)
+        if (secret.length < 16) {
+            throw new ValidationError(`${secretType} appears too short (${secret.length} characters)`, 'secret', [
+                'Ensure you have the complete key',
+                'Check for truncation',
+                'Verify with your provider',
+            ]);
+        }
+    }
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,37 @@
+export interface ArkConfig {
+    defaultModel?: string;
+    defaultAgent?: string;
+    defaultNamespace?: string;
+    apiBaseUrl?: string;
+    kubeconfig?: string;
+    currentContext?: string;
+    kubeNamespace?: string;
+}
+export interface KubernetesConfig {
+    kubeconfig: string;
+    currentContext?: string;
+    namespace?: string;
+    inCluster: boolean;
+}
+export interface ServiceStatus {
+    name: string;
+    status: 'healthy' | 'unhealthy' | 'not installed';
+    url?: string;
+    version?: string;
+    details?: string;
+}
+export interface DependencyStatus {
+    name: string;
+    installed: boolean;
+    version?: string;
+    details?: string;
+}
+export interface StatusData {
+    services: ServiceStatus[];
+    dependencies: DependencyStatus[];
+}
+export interface CommandVersionConfig {
+    command: string;
+    versionArgs: string;
+    versionExtract: (_output: string) => string;
+}

package/dist/lib/types.js

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

package/dist/lib/wrappers/git.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureInArkRepo(expectedRepoName: string, expectedRemoteSubstring?: string): Promise<void>;
+export declare function getRepoProjectRoot(): Promise<string>;

package/dist/lib/wrappers/git.js

@@ -0,0 +1,43 @@
+import * as path from 'path';
+import chalk from 'chalk';
+import { simpleGit } from 'simple-git';
+import { ARK_REPO_ERROR_MESSAGE } from '../consts.js';
+// Initialize simple-git instance
+const git = simpleGit();
+export async function ensureInArkRepo(expectedRepoName, expectedRemoteSubstring) {
+    try {
+        // Get repository root
+        const gitRoot = await git.revparse(['--show-toplevel']);
+        if (path.basename(gitRoot) !== expectedRepoName) {
+            console.error(chalk.red(ARK_REPO_ERROR_MESSAGE));
+            process.exit(1);
+        }
+        if (expectedRemoteSubstring) {
+            try {
+                // Get remote URL
+                const remoteUrl = await git.remote(['get-url', 'origin']);
+                if (!remoteUrl || !remoteUrl.includes(expectedRemoteSubstring)) {
+                    console.error(chalk.red(ARK_REPO_ERROR_MESSAGE));
+                    process.exit(1);
+                }
+            }
+            catch (_error) {
+                console.error(chalk.red(ARK_REPO_ERROR_MESSAGE));
+                process.exit(1);
+            }
+        }
+    }
+    catch (_error) {
+        console.error(chalk.red(ARK_REPO_ERROR_MESSAGE));
+        process.exit(1);
+    }
+}
+export async function getRepoProjectRoot() {
+    try {
+        return await git.revparse(['--show-toplevel']);
+    }
+    catch (_error) {
+        console.error(chalk.red('Failed to determine git repository root path'));
+        process.exit(1);
+    }
+}

package/dist/ui/MainMenu.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const MainMenu: React.FC;
+export default MainMenu;

package/dist/ui/MainMenu.js

@@ -0,0 +1,116 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text, Box, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import * as React from 'react';
+import DashboardCLI from '../components/DashboardCLI.js';
+import GeneratorUI from '../components/GeneratorUI.js';
+import { StatusChecker } from '../components/statusChecker.js';
+import { ConfigManager } from '../config.js';
+import { ArkClient } from '../lib/arkClient.js';
+const EXIT_TIMEOUT_MS = 1000;
+const MainMenu = () => {
+    const [selectedChoice, setSelectedChoice] = React.useState(null);
+    const [statusData, setStatusData] = React.useState(null);
+    const [isLoading, setIsLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const choices = [
+        { label: '🏷️  Dashboard', value: 'dashboard' },
+        { label: '🔍 Status Check', value: 'status' },
+        { label: '🎯 Generate', value: 'generate' },
+        { label: '👋 Exit', value: 'exit' },
+    ];
+    React.useEffect(() => {
+        if (selectedChoice === 'exit') {
+            const timer = setTimeout(() => {
+                process.exit(0);
+            }, EXIT_TIMEOUT_MS);
+            return () => clearTimeout(timer);
+        }
+    }, [selectedChoice]);
+    React.useEffect(() => {
+        if (selectedChoice === 'status' && !statusData && !isLoading) {
+            checkStatus();
+        }
+    }, [selectedChoice, statusData, isLoading]);
+    const checkStatus = async () => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const configManager = new ConfigManager();
+            const apiBaseUrl = await configManager.getApiBaseUrl();
+            const serviceUrls = await configManager.getServiceUrls();
+            const arkClient = new ArkClient(apiBaseUrl);
+            const statusChecker = new StatusChecker(arkClient);
+            const status = await statusChecker.checkAll(serviceUrls, apiBaseUrl);
+            setStatusData(status);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Unknown error occurred');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    useInput((input, key) => {
+        if (selectedChoice && selectedChoice !== 'exit') {
+            if (key.escape || input === 'q' || key.return) {
+                // For generate, only reset on specific key combinations to avoid conflicts
+                if (selectedChoice === 'generate' && !(key.escape || input === 'q')) {
+                    return;
+                }
+                setSelectedChoice(null);
+                setStatusData(null);
+                setError(null);
+            }
+        }
+    });
+    const renderBanner = () => (_jsxs(Box, { flexDirection: "column", alignItems: "center", marginBottom: 1, children: [_jsx(Text, { color: "cyan", bold: true, children: `
+    ╔═══════════════════════════════════════╗
+    ║                                       ║
+    ║         █████╗ ██████╗ ██╗  ██╗       ║
+    ║        ██╔══██╗██╔══██╗██║ ██╔╝       ║
+    ║        ███████║██████╔╝█████╔╝        ║
+    ║        ██╔══██║██╔══██╗██╔═██╗        ║
+    ║        ██║  ██║██║  ██║██║  ██╗       ║
+    ║        ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝       ║
+    ║                                       ║
+    ║        Agents at Scale Platform       ║
+    ║                                       ║
+    ╚═══════════════════════════════════════╝
+        ` }), _jsx(Text, { color: "green", bold: true, children: "Welcome to ARK! \uD83D\uDE80" }), _jsx(Text, { color: "gray", children: "Interactive terminal interface for ARK agents" })] }));
+    const renderServiceStatus = (service) => {
+        const statusColor = service.status === 'healthy'
+            ? 'green'
+            : service.status === 'unhealthy'
+                ? 'red'
+                : 'yellow';
+        const statusIcon = service.status === 'healthy'
+            ? '✓'
+            : service.status === 'unhealthy'
+                ? '✗'
+                : '?';
+        return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsxs(Text, { color: statusColor, children: [statusIcon, " "] }), _jsxs(Text, { bold: true, children: [service.name, ": "] }), _jsx(Text, { color: statusColor, children: service.status })] }), service.url && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "gray", children: ["URL: ", service.url] }) })), service.details && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: service.details }) }))] }, service.name));
+    };
+    const renderDependencyStatus = (dep) => {
+        const statusColor = dep.installed ? 'green' : 'red';
+        const statusIcon = dep.installed ? '✓' : '✗';
+        const statusText = dep.installed ? 'installed' : 'missing';
+        return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsxs(Text, { color: statusColor, children: [statusIcon, " "] }), _jsxs(Text, { bold: true, children: [dep.name, ": "] }), _jsx(Text, { color: statusColor, children: statusText })] }), dep.version && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "gray", children: ["Version: ", dep.version] }) })), dep.details && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: dep.details }) }))] }, dep.name));
+    };
+    const renderStatus = () => {
+        if (isLoading) {
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "\uD83D\uDD0D Checking ARK system status..." }), _jsx(Text, { color: "gray", children: "Please wait while we verify services and dependencies." })] }));
+        }
+        if (error) {
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u274C Error checking status:" }), _jsx(Text, { color: "red", children: error }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Press ESC, 'q', or Enter to return to menu..." }) })] }));
+        }
+        if (!statusData) {
+            return null;
+        }
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDD0D ARK System Status" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDCE1 ARK Services:" }) }), statusData.services.map(renderServiceStatus), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDEE0\uFE0F System Dependencies:" }) }), statusData.dependencies.map(renderDependencyStatus), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Press ESC, 'q', or Enter to return to menu..." }) })] }));
+    };
+    return (_jsxs(_Fragment, { children: [renderBanner(), !selectedChoice && (_jsx(SelectInput, { items: choices, onSelect: (choice) => {
+                    setSelectedChoice(choice.value);
+                } })), selectedChoice === 'status' && renderStatus(), selectedChoice === 'dashboard' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "green", children: "\uD83C\uDFF7\uFE0F Dashboard feature selected" }), _jsx(DashboardCLI, {})] })), selectedChoice === 'generate' && _jsx(GeneratorUI, {}), selectedChoice === 'exit' && _jsx(Text, { color: "yellow", children: "\uD83D\uDC4B Goodbye!" })] }));
+};
+export default MainMenu;

package/dist/ui/statusFormatter.d.ts

@@ -0,0 +1,9 @@
+import { StatusData } from '../lib/types.js';
+export declare class StatusFormatter {
+    /**
+     * Print status check results to console
+     */
+    static printStatus(statusData: StatusData): void;
+    private static printService;
+    private static printDependency;
+}

package/dist/ui/statusFormatter.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+export class StatusFormatter {
+    /**
+     * Print status check results to console
+     */
+    static printStatus(statusData) {
+        console.log(chalk.cyan.bold('\n🔍 ARK System Status Check'));
+        console.log(chalk.gray('Checking ARK services and dependencies...\n'));
+        // Print services status
+        console.log(chalk.cyan.bold('📡 ARK Services:'));
+        for (const service of statusData.services) {
+            StatusFormatter.printService(service);
+        }
+        // Print dependencies status
+        console.log(chalk.cyan.bold('\n🛠️  System Dependencies:'));
+        for (const dep of statusData.dependencies) {
+            StatusFormatter.printDependency(dep);
+        }
+        console.log();
+    }
+    static printService(service) {
+        const statusColor = service.status === 'healthy'
+            ? chalk.green('✓ healthy')
+            : service.status === 'unhealthy'
+                ? chalk.red('✗ unhealthy')
+                : chalk.yellow('? not installed');
+        console.log(`  • ${chalk.bold(service.name)}: ${statusColor}`);
+        if (service.url) {
+            console.log(`    ${chalk.gray(`URL: ${service.url}`)}`);
+        }
+        if (service.details) {
+            console.log(`    ${chalk.gray(service.details)}`);
+        }
+    }
+    static printDependency(dep) {
+        const statusColor = dep.installed
+            ? chalk.green('✓ installed')
+            : chalk.red('✗ missing');
+        console.log(`  • ${chalk.bold(dep.name)}: ${statusColor}`);
+        if (dep.version) {
+            console.log(`    ${chalk.gray(`Version: ${dep.version}`)}`);
+        }
+        if (dep.details) {
+            console.log(`    ${chalk.gray(dep.details)}`);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@agents-at-scale/ark",
+  "version": "0.1.31",
+  "description": "ARK CLI - Interactive terminal interface for ARK agents",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "ark": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "node --loader ts-node/esm src/index.tsx",
+    "start": "node dist/index.js",
+    "clean": "rm -rf dist",
+    "lint": "eslint src/ --fix && prettier --write src/",
+    "lint:check": "eslint src/ && prettier --check src/",
+    "postinstall": "echo \"ARK CLI installed! Run 'ark' to try it out.\""
+  },
+  "keywords": [
+    "ark",
+    "cli",
+    "terminal",
+    "ai",
+    "agents"
+  ],
+  "author": "",
+  "dependencies": {
+    "@kubernetes/client-node": "^1.3.0",
+    "@types/react": "^19.1.8",
+    "axios": "^1.7.7",
+    "chalk": "^4.1.2",
+    "commander": "^12.1.0",
+    "debug": "^4.4.1",
+    "execa": "^9.6.0",
+    "ink": "^6.0.1",
+    "ink-select-input": "^6.2.0",
+    "ink-text-input": "^6.0.0",
+    "inquirer": "^12.1.0",
+    "open": "^10.2.0",
+    "react": "^19.1.0",
+    "simple-git": "^3.28.0",
+    "yaml": "^2.6.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.17.0",
+    "@types/debug": "^4.1.12",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.10.2",
+    "@typescript-eslint/eslint-plugin": "^8.20.0",
+    "@typescript-eslint/parser": "^8.20.0",
+    "eslint": "^9.17.0",
+    "prettier": "^3.6.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}