@agents-at-scale/ark 0.1.64 → 0.1.67

package/dist/commands/agents/index.js

@@ -1,7 +1,9 @@
 import { Command } from 'commander';
 import { execa } from 'execa';
+import chalk from 'chalk';
 import output from '../../lib/output.js';
-import { executeQuery } from '../../lib/executeQuery.js';
+import { executeQuery, parseParameters } from '../../lib/executeQuery.js';
+import { ExitCodes } from '../../lib/errors.js';
 async function listAgents(options) {
     try {
         // Use kubectl to get agents
@@ -55,12 +57,22 @@ export function createAgentsCommand(config) {
         .argument('<name>', 'Agent name')
         .argument('<message>', 'Message to send')
         .option('--timeout <timeout>', 'Query timeout (e.g., 30s, 5m, 1h)')
+        .option('-p, --parameter <name=value>', 'Template parameter in name=value format (can be used multiple times)', (val, acc) => [...acc, val], [])
         .action(async (name, message, options) => {
+        let parameters;
+        try {
+            parameters = parseParameters(options.parameter || []);
+        }
+        catch (error) {
+            console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+            process.exit(ExitCodes.CliError);
+        }
         await executeQuery({
             targetType: 'agent',
             targetName: name,
             message,
             timeout: options.timeout || config.queryTimeout,
+            parameters,
         });
     });
     return agentsCommand;

package/dist/commands/import/index.js

@@ -1,27 +1,62 @@
 import { Command } from 'commander';
 import { execa } from 'execa';
 import output from '../../lib/output.js';
-async function importResources(filepath) {
-    try {
-        output.info(`importing ark resources from ${filepath}...`);
-        const args = ['create', '-f', filepath];
-        await execa('kubectl', args, {
-            stdio: 'pipe',
-        });
-        output.success(`imported resources from ${filepath}`);
+function countApplied(stdout) {
+    const counts = { created: 0, configured: 0, unchanged: 0 };
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.endsWith(' created')) {
+            counts.created++;
+        }
+        else if (trimmed.endsWith(' configured')) {
+            counts.configured++;
+        }
+        else if (trimmed.endsWith(' unchanged')) {
+            counts.unchanged++;
+        }
     }
-    catch (error) {
-        output.error('import failed:', error instanceof Error ? error.message : error);
+    return counts;
+}
+async function importResources(filepath, options) {
+    if (!options.upsert) {
+        try {
+            output.info(`importing ark resources from ${filepath}...`);
+            const args = ['create', '-f', filepath];
+            await execa('kubectl', args, {
+                stdio: 'pipe',
+            });
+            output.success(`imported resources from ${filepath}`);
+        }
+        catch (error) {
+            output.error('import failed:', error instanceof Error ? error.message : error);
+            process.exit(1);
+        }
+        return;
+    }
+    output.info(`importing ark resources from ${filepath} (upsert)...`);
+    const result = await execa('kubectl', ['apply', '-f', filepath], {
+        stdio: 'pipe',
+        reject: false,
+    });
+    const counts = countApplied(result.stdout ?? '');
+    if (result.exitCode !== 0) {
+        output.error(`import failed (${counts.created} created, ${counts.configured} configured, ${counts.unchanged} unchanged before errors):`);
+        const details = (result.stderr || result.stdout || '').trim();
+        if (details) {
+            output.error(details);
+        }
         process.exit(1);
     }
+    output.success(`import complete: ${counts.created} created, ${counts.configured} configured, ${counts.unchanged} unchanged`);
 }
 export function createImportCommand(_) {
     const importCommand = new Command('import');
     importCommand
         .description('import ARK resources from a file')
         .argument('<filepath>', 'input file path')
-        .action(async (filepath) => {
-        await importResources(filepath);
+        .option('--upsert', 'create or update resources (kubectl apply); allows re-import onto a cluster that already has some of these resources')
+        .action(async (filepath, options) => {
+        await importResources(filepath, options);
     });
     return importCommand;
 }

package/dist/commands/install/index.js

@@ -50,7 +50,7 @@ function backendInstallArgs(service, backend, values) {
 function isValidVersion(version) {
     return /^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/.test(version);
 }
-function isVersionNotFoundError(error, options) {
+function notFoundVersion(error, options) {
     let errorMsg = '';
     if (error && typeof error === 'object') {
         const err = error;
@@ -61,24 +61,30 @@ function isVersionNotFoundError(error, options) {
         errorMsg = String(error);
     }
     if (options.arkVersion && errorMsg.includes(`:${options.arkVersion}: not found`)) {
-        return true;
+        return options.arkVersion;
     }
     if (options.marketplaceVersion && errorMsg.includes(`:${options.marketplaceVersion}: not found`)) {
-        return true;
+        return options.marketplaceVersion;
     }
-    return false;
+    return null;
 }
 function handleInstallError(error, service, options) {
-    if (isVersionNotFoundError(error, options)) {
-        const version = options.arkVersion || options.marketplaceVersion;
-        output.warning(`${service.name} version ${version} not found, skipping...`);
-        return true; // should continue to next service
+    const version = notFoundVersion(error, options);
+    if (version !== null) {
+        return version; // should continue to next service
     }
     // Other errors still fail
     output.error(`failed to install ${service.name}`);
     console.error(error);
     process.exit(1);
 }
+function exitIfServicesSkipped(skipped) {
+    if (skipped.length === 0)
+        return;
+    const detail = skipped.map((s) => `${s.name}@${s.version}`).join(', ');
+    output.error(`installation incomplete: ${skipped.length} service(s) skipped because the requested version was not found: ${detail}`);
+    process.exit(1);
+}
 async function uninstallPrerequisites(service, verbose = false) {
     if (!service.prerequisiteUninstalls?.length)
         return;
@@ -185,6 +191,7 @@ export async function installArk(config, serviceNames = [], options = {}) {
         process.exit(1);
     }
     const backend = requestedBackend;
+    const skippedServices = [];
     let postgresValues;
     if (backend === 'postgresql') {
         try {
@@ -233,7 +240,9 @@ export async function installArk(config, serviceNames = [], options = {}) {
                     output.success(`${service.name} installed successfully`);
                 }
                 catch (error) {
-                    if (handleInstallError(error, service, options)) {
+                    const skippedVersion = handleInstallError(error, service, options);
+                    if (skippedVersion) {
+                        skippedServices.push({ name: service.name, version: skippedVersion });
                         continue;
                     }
                 }
@@ -258,7 +267,7 @@ export async function installArk(config, serviceNames = [], options = {}) {
                 if (service.helmReleaseName === 'ark-apiserver' && backend === 'postgresql') {
                     const spinner = ora('Waiting for ark-apiserver to be ready...').start();
                     try {
-                        const results = await runReadinessChecks(120); // 2 minute timeout
+                        const results = await runReadinessChecks(120, backend); // 2 minute timeout
                         const failed = results.find((r) => !r.passed);
                         if (failed) {
                             spinner.fail(`ark-apiserver readiness check failed: ${failed.message || 'unknown error'}`);
@@ -274,11 +283,14 @@ export async function installArk(config, serviceNames = [], options = {}) {
                 }
             }
             catch (error) {
-                if (handleInstallError(error, service, options)) {
+                const skippedVersion = handleInstallError(error, service, options);
+                if (skippedVersion) {
+                    skippedServices.push({ name: service.name, version: skippedVersion });
                     continue;
                 }
             }
         }
+        exitIfServicesSkipped(skippedServices);
         return;
     }
     // If not using -y flag, show checklist interface
@@ -417,7 +429,7 @@ export async function installArk(config, serviceNames = [], options = {}) {
                 if (service.helmReleaseName === 'ark-apiserver' && backend === 'postgresql') {
                     const spinner = ora('Waiting for ark-apiserver to be ready...').start();
                     try {
-                        const results = await runReadinessChecks(120); // 2 minute timeout
+                        const results = await runReadinessChecks(120, backend); // 2 minute timeout
                         const failed = results.find((r) => !r.passed);
                         if (failed) {
                             spinner.fail(`ark-apiserver readiness check failed: ${failed.message || 'unknown error'}`);
@@ -434,7 +446,9 @@ export async function installArk(config, serviceNames = [], options = {}) {
                 console.log(); // Add blank line after command output
             }
             catch (error) {
-                if (handleInstallError(error, service, options)) {
+                const skippedVersion = handleInstallError(error, service, options);
+                if (skippedVersion) {
+                    skippedServices.push({ name: service.name, version: skippedVersion });
                     console.log(); // Add blank line after warning
                     continue;
                 }
@@ -476,7 +490,9 @@ export async function installArk(config, serviceNames = [], options = {}) {
                 console.log(); // Add blank line after command output
             }
             catch (error) {
-                if (handleInstallError(error, service, options)) {
+                const skippedVersion = handleInstallError(error, service, options);
+                if (skippedVersion) {
+                    skippedServices.push({ name: service.name, version: skippedVersion });
                     console.log(); // Add blank line after warning
                     continue;
                 }
@@ -496,7 +512,8 @@ export async function installArk(config, serviceNames = [], options = {}) {
                 s.category === 'core' &&
                 s.k8sDeploymentName &&
                 s.namespace &&
-                (!s.requiresBackend || s.requiresBackend === backend));
+                (!s.requiresBackend || s.requiresBackend === backend) &&
+                !skippedServices.some((sk) => sk.name === s.name));
             const spinner = ora(`Waiting for Ark to be ready (timeout: ${timeoutSeconds}s)...`).start();
             const statusMap = new Map();
             servicesToWait.forEach((s) => statusMap.set(s.name, false));
@@ -526,6 +543,7 @@ export async function installArk(config, serviceNames = [], options = {}) {
             process.exit(1);
         }
     }
+    exitIfServicesSkipped(skippedServices);
 }
 export function createInstallCommand(config) {
     const command = new Command('install');

package/dist/commands/mcp/login.js

@@ -23,6 +23,29 @@ export const defaultDeps = {
 };
 const POLL_INTERVAL_MS = 2000;
 const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const LOOPBACK_LITERALS = new Set(['127.0.0.1', '::1', 'localhost']);
+function warnIfCallbackUnreachable(authorizationUrl, proxyBaseUrl) {
+    let redirect;
+    try {
+        const raw = new URL(authorizationUrl).searchParams.get('redirect_uri');
+        if (!raw)
+            return;
+        redirect = new URL(raw);
+    }
+    catch {
+        return;
+    }
+    const host = redirect.hostname.replace(/^\[|\]$/g, '');
+    if (!LOOPBACK_LITERALS.has(host))
+        return;
+    const proxyPort = new URL(proxyBaseUrl).port;
+    if (redirect.port && proxyPort && redirect.port !== proxyPort) {
+        output.warning(`callback is configured for ${redirect.host} but the CLI port-forward is on ` +
+            `port ${proxyPort}; the browser redirect will not reach ark-api. Set ` +
+            `ARK_API_PUBLIC_CALLBACK_URL to use port ${proxyPort}, or port-forward ` +
+            `ark-api on port ${redirect.port}.`);
+    }
+}
 export async function runLogin(serverName, options, deps = defaultDeps) {
     let timeoutMs = DEFAULT_TIMEOUT_MS;
     if (options.timeout !== undefined) {
@@ -57,6 +80,7 @@ export async function runLogin(serverName, options, deps = defaultDeps) {
             }
             return 1;
         }
+        warnIfCallbackUnreachable(startResponse.authorization_url, proxy.baseUrl);
         console.log(`Authorization URL: ${startResponse.authorization_url}`);
         if (options.open !== false) {
             try {

package/dist/commands/models/kubernetes/manifest-builder.js

@@ -109,34 +109,46 @@ export class KubernetesModelManifestBuilder {
                 region: {
                     value: config.region,
                 },
-                accessKeyId: {
-                    valueFrom: {
-                        secretKeyRef: {
-                            name: config.secretName,
-                            key: 'access-key-id',
-                        },
+            },
+        };
+        const bedrock = bedrockConfig.bedrock;
+        if (config.authMethod === 'api-key') {
+            bedrock.apiKey = {
+                valueFrom: {
+                    secretKeyRef: {
+                        name: config.secretName,
+                        key: 'bedrock-api-key',
                     },
                 },
-                secretAccessKey: {
-                    valueFrom: {
-                        secretKeyRef: {
-                            name: config.secretName,
-                            key: 'secret-access-key',
-                        },
+            };
+        }
+        else {
+            bedrock.accessKeyId = {
+                valueFrom: {
+                    secretKeyRef: {
+                        name: config.secretName,
+                        key: 'access-key-id',
                     },
                 },
-            },
-        };
-        const bedrock = bedrockConfig.bedrock;
-        if (config.sessionToken) {
-            bedrock.sessionToken = {
+            };
+            bedrock.secretAccessKey = {
                 valueFrom: {
                     secretKeyRef: {
                         name: config.secretName,
-                        key: 'session-token',
+                        key: 'secret-access-key',
                     },
                 },
             };
+            if (config.sessionToken) {
+                bedrock.sessionToken = {
+                    valueFrom: {
+                        secretKeyRef: {
+                            name: config.secretName,
+                            key: 'session-token',
+                        },
+                    },
+                };
+            }
         }
         if (config.modelArn) {
             bedrock.modelArn = {

package/dist/commands/models/kubernetes/secret-manager.js

@@ -23,10 +23,15 @@ export class KubernetesSecretManager {
     async createNewSecret(config) {
         const secretArgs = ['create', 'secret', 'generic', config.secretName];
         if (config.type === 'bedrock') {
-            secretArgs.push(`--from-literal=access-key-id=${config.accessKeyId}`);
-            secretArgs.push(`--from-literal=secret-access-key=${config.secretAccessKey}`);
-            if (config.sessionToken) {
-                secretArgs.push(`--from-literal=session-token=${config.sessionToken}`);
+            if (config.authMethod === 'api-key') {
+                secretArgs.push(`--from-literal=bedrock-api-key=${config.apiKey}`);
+            }
+            else {
+                secretArgs.push(`--from-literal=access-key-id=${config.accessKeyId}`);
+                secretArgs.push(`--from-literal=secret-access-key=${config.secretAccessKey}`);
+                if (config.sessionToken) {
+                    secretArgs.push(`--from-literal=session-token=${config.sessionToken}`);
+                }
             }
         }
         else {
@@ -39,10 +44,15 @@ export class KubernetesSecretManager {
     async updateSecret(config) {
         const secretArgs = ['create', 'secret', 'generic', config.secretName];
         if (config.type === 'bedrock') {
-            secretArgs.push(`--from-literal=access-key-id=${config.accessKeyId}`);
-            secretArgs.push(`--from-literal=secret-access-key=${config.secretAccessKey}`);
-            if (config.sessionToken) {
-                secretArgs.push(`--from-literal=session-token=${config.sessionToken}`);
+            if (config.authMethod === 'api-key') {
+                secretArgs.push(`--from-literal=bedrock-api-key=${config.apiKey}`);
+            }
+            else {
+                secretArgs.push(`--from-literal=access-key-id=${config.accessKeyId}`);
+                secretArgs.push(`--from-literal=secret-access-key=${config.secretAccessKey}`);
+                if (config.sessionToken) {
+                    secretArgs.push(`--from-literal=session-token=${config.sessionToken}`);
+                }
             }
         }
         else {

package/dist/commands/models/providers/bedrock.d.ts

@@ -2,11 +2,14 @@ import { BaseProviderConfig, BaseCollectorOptions, ProviderConfigCollector } fro
 /**
  * Configuration for AWS Bedrock models.
  */
+export type BedrockAuthMethod = 'api-key' | 'iam';
 export interface BedrockConfig extends BaseProviderConfig {
     type: 'bedrock';
     region: string;
-    accessKeyId: string;
-    secretAccessKey: string;
+    authMethod: BedrockAuthMethod;
+    apiKey?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
     sessionToken?: string;
     modelArn?: string;
 }
@@ -15,6 +18,8 @@ export interface BedrockConfig extends BaseProviderConfig {
  */
 export interface BedrockCollectorOptions extends BaseCollectorOptions {
     region?: string;
+    authMethod?: BedrockAuthMethod;
+    apiKey?: string;
     accessKeyId?: string;
     secretAccessKey?: string;
     sessionToken?: string;

package/dist/commands/models/providers/bedrock.js

@@ -29,56 +29,103 @@ export class BedrockConfigCollector {
         if (!region) {
             throw new Error('region is required');
         }
-        let accessKeyId = bedrockOptions.accessKeyId;
-        if (!accessKeyId) {
+        let authMethod = bedrockOptions.authMethod;
+        if (!authMethod) {
             const answer = await inquirer.prompt([
                 {
-                    type: 'input',
-                    name: 'accessKeyId',
-                    message: 'AWS access key ID:',
-                    validate: (input) => {
-                        if (!input)
-                            return 'access key ID is required';
-                        return true;
-                    },
+                    type: 'list',
+                    name: 'authMethod',
+                    message: 'Authentication method:',
+                    choices: [
+                        { name: 'API key (bearer token)', value: 'api-key' },
+                        { name: 'IAM credentials', value: 'iam' },
+                    ],
+                    default: 'iam',
                 },
             ]);
-            accessKeyId = answer.accessKeyId;
+            authMethod = answer.authMethod;
         }
-        if (!accessKeyId) {
-            throw new Error('access key ID is required');
+        if (!authMethod) {
+            throw new Error('authentication method is required');
         }
-        let secretAccessKey = bedrockOptions.secretAccessKey;
-        if (!secretAccessKey) {
-            const answer = await inquirer.prompt([
-                {
-                    type: 'password',
-                    name: 'secretAccessKey',
-                    message: 'AWS secret access key:',
-                    mask: '*',
-                    validate: (input) => {
-                        if (!input)
-                            return 'secret access key is required';
-                        return true;
+        let apiKey;
+        let accessKeyId;
+        let secretAccessKey;
+        let sessionToken;
+        if (authMethod === 'api-key') {
+            apiKey = bedrockOptions.apiKey;
+            if (!apiKey) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'password',
+                        name: 'apiKey',
+                        message: 'Bedrock API key:',
+                        mask: '*',
+                        validate: (input) => {
+                            if (!input)
+                                return 'API key is required';
+                            return true;
+                        },
                     },
-                },
-            ]);
-            secretAccessKey = answer.secretAccessKey;
-        }
-        if (!secretAccessKey) {
-            throw new Error('secret access key is required');
+                ]);
+                apiKey = answer.apiKey;
+            }
+            if (!apiKey) {
+                throw new Error('API key is required');
+            }
         }
-        let sessionToken = bedrockOptions.sessionToken;
-        if (!sessionToken) {
-            const answer = await inquirer.prompt([
-                {
-                    type: 'password',
-                    name: 'sessionToken',
-                    message: 'AWS session token (optional, press enter to skip):',
-                    mask: '*',
-                },
-            ]);
-            sessionToken = answer.sessionToken;
+        else {
+            accessKeyId = bedrockOptions.accessKeyId;
+            if (!accessKeyId) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'accessKeyId',
+                        message: 'AWS access key ID:',
+                        validate: (input) => {
+                            if (!input)
+                                return 'access key ID is required';
+                            return true;
+                        },
+                    },
+                ]);
+                accessKeyId = answer.accessKeyId;
+            }
+            if (!accessKeyId) {
+                throw new Error('access key ID is required');
+            }
+            secretAccessKey = bedrockOptions.secretAccessKey;
+            if (!secretAccessKey) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'password',
+                        name: 'secretAccessKey',
+                        message: 'AWS secret access key:',
+                        mask: '*',
+                        validate: (input) => {
+                            if (!input)
+                                return 'secret access key is required';
+                            return true;
+                        },
+                    },
+                ]);
+                secretAccessKey = answer.secretAccessKey;
+            }
+            if (!secretAccessKey) {
+                throw new Error('secret access key is required');
+            }
+            sessionToken = bedrockOptions.sessionToken;
+            if (!sessionToken) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'password',
+                        name: 'sessionToken',
+                        message: 'AWS session token (optional, press enter to skip):',
+                        mask: '*',
+                    },
+                ]);
+                sessionToken = answer.sessionToken;
+            }
         }
         let modelArn = bedrockOptions.modelArn;
         if (!modelArn) {
@@ -96,6 +143,8 @@ export class BedrockConfigCollector {
             modelValue: options.model,
             secretName: '',
             region,
+            authMethod,
+            apiKey,
             accessKeyId,
             secretAccessKey,
             sessionToken: sessionToken || undefined,

package/dist/commands/query/index.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { executeQuery, parseTarget } from '../../lib/executeQuery.js';
+import { executeQuery, parseTarget, parseParameters, } from '../../lib/executeQuery.js';
 import { ExitCodes } from '../../lib/errors.js';
 export function createQueryCommand(config) {
     const queryCommand = new Command('query');
@@ -8,8 +8,9 @@ export function createQueryCommand(config) {
         .description('Execute a single query against a model or agent')
         .argument('<target>', 'Query target (e.g., model/default, agent/my-agent)')
         .argument('<message>', 'Message to send')
-        .option('-o, --output <format>', 'Output format: yaml, json, name or events (shows structured event data)')
+        .option('-o, --output <format>', 'Output format: yaml, json, name, events (structured event data), or events-pretty (events with color-coded reasons and expanded key/value detail)')
         .option('--timeout <timeout>', 'Query timeout (e.g., 30s, 5m, 1h)')
+        .option('-p, --parameter <name=value>', 'Template parameter in name=value format (can be used multiple times)', (val, acc) => [...acc, val], [])
         .option('--session-id <sessionId>', 'Session ID to associate with the query for conversation continuity')
         .option('--conversation-id <conversationId>', 'Conversation ID to associate with the query for memory continuity')
         .action(async (target, message, options) => {
@@ -18,12 +19,21 @@ export function createQueryCommand(config) {
             console.error(chalk.red('Invalid target format. Use: model/name or agent/name etc'));
             process.exit(ExitCodes.CliError);
         }
+        let parameters;
+        try {
+            parameters = parseParameters(options.parameter || []);
+        }
+        catch (error) {
+            console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
+            process.exit(ExitCodes.CliError);
+        }
         await executeQuery({
             targetType: parsed.type,
             targetName: parsed.name,
             message,
             outputFormat: options.output,
             timeout: options.timeout || config.queryTimeout,
+            parameters,
             sessionId: options.sessionId,
             conversationId: options.conversationId,
         });