@agents-at-scale/ark 0.1.61 → 0.1.63

package/dist/arkServices.d.ts

@@ -13,6 +13,7 @@ export declare const arkDependencies: DependencyCollection;
  */
 export declare const arkServices: ServiceCollection;
 /**
- * Get services that can be installed via Helm charts (only enabled services)
+ * Get services that can be installed via Helm charts (only enabled services).
+ * When a backend is specified, services with a non-matching requiresBackend are excluded.
  */
-export declare function getInstallableServices(): ServiceCollection;
+export declare function getInstallableServices(backend?: 'etcd' | 'postgresql'): ServiceCollection;

package/dist/arkServices.js

@@ -221,14 +221,17 @@ function applyConfigOverrides(defaults) {
  */
 export const arkServices = applyConfigOverrides(defaultArkServices);
 /**
- * Get services that can be installed via Helm charts (only enabled services)
+ * Get services that can be installed via Helm charts (only enabled services).
+ * When a backend is specified, services with a non-matching requiresBackend are excluded.
  */
-export function getInstallableServices() {
+export function getInstallableServices(backend = 'etcd') {
     const installable = {};
     for (const [key, service] of Object.entries(arkServices)) {
-        if (service.enabled && service.chartPath) {
-            installable[key] = service;
-        }
+        if (!service.enabled || !service.chartPath)
+            continue;
+        if (service.requiresBackend && service.requiresBackend !== backend)
+            continue;
+        installable[key] = service;
     }
     return installable;
 }

package/dist/commands/install/index.d.ts

@@ -6,5 +6,6 @@ export declare function installArk(config: ArkConfig, serviceNames?: string[], o
     verbose?: boolean;
     arkVersion?: string;
     marketplaceVersion?: string;
+    backend?: string;
 }): Promise<void>;
 export declare function createInstallCommand(config: ArkConfig): Command;

package/dist/commands/install/index.js

@@ -10,6 +10,43 @@ import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
 import { waitForServicesReady, } from '../../lib/waitForReady.js';
 import { parseTimeoutToSeconds } from '../../lib/timeout.js';
+import { runReadinessChecks } from '../../lib/readinessChecks.js';
+function validatePostgresConfig(pg) {
+    if (!pg) {
+        throw new Error("missing 'storage.postgresql' block in .arkrc.yaml");
+    }
+    for (const key of ['host', 'user', 'passwordSecretName']) {
+        if (!pg[key]) {
+            throw new Error(`missing required field storage.postgresql.${key} in .arkrc.yaml`);
+        }
+    }
+    return pg;
+}
+function backendInstallArgs(service, backend, values) {
+    if (backend === 'etcd')
+        return [];
+    if (!values)
+        return [];
+    if (service.helmReleaseName === 'ark-controller') {
+        return ['--set', 'storage.backend=postgresql'];
+    }
+    if (service.helmReleaseName === 'ark-apiserver') {
+        const args = [];
+        args.push('--set', `postgresql.host=${values.host}`);
+        if (values.port !== undefined)
+            args.push('--set', `postgresql.port=${values.port}`);
+        if (values.database)
+            args.push('--set', `postgresql.database=${values.database}`);
+        args.push('--set', `postgresql.user=${values.user}`);
+        args.push('--set', `postgresql.passwordSecretName=${values.passwordSecretName}`);
+        if (values.passwordSecretKey)
+            args.push('--set', `postgresql.passwordSecretKey=${values.passwordSecretKey}`);
+        if (values.sslMode)
+            args.push('--set', `postgresql.sslMode=${values.sslMode}`);
+        return args;
+    }
+    return [];
+}
 function isValidVersion(version) {
     return /^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/.test(version);
 }
@@ -75,7 +112,7 @@ async function checkAndCleanFailedRelease(releaseName, namespace, verbose = fals
         // Ignore errors - prerequisite may not exist
     }
 }
-async function installService(service, verbose = false, arkVersionOverride, marketplaceVersionOverride) {
+async function installService(service, verbose = false, arkVersionOverride, marketplaceVersionOverride, extraArgs) {
     await uninstallPrerequisites(service, verbose);
     await checkAndCleanFailedRelease(service.helmReleaseName, service.namespace, verbose);
     let chartPath = service.chartPath;
@@ -111,6 +148,8 @@ async function installService(service, verbose = false, arkVersionOverride, mark
     }
     // Add any additional install args
     helmArgs.push(...(service.installArgs || []));
+    if (extraArgs)
+        helmArgs.push(...extraArgs);
     await execute('helm', helmArgs, {
         stdout: 'inherit',
         stderr: 'pipe',
@@ -140,6 +179,22 @@ export async function installArk(config, serviceNames = [], options = {}) {
     // Show cluster info
     output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
     console.log(); // Add blank line after cluster info
+    const requestedBackend = options.backend ?? config.storage?.backend ?? 'etcd';
+    if (requestedBackend !== 'etcd' && requestedBackend !== 'postgresql') {
+        output.error(`Invalid backend value: ${requestedBackend}. Expected 'etcd' or 'postgresql'.`);
+        process.exit(1);
+    }
+    const backend = requestedBackend;
+    let postgresValues;
+    if (backend === 'postgresql') {
+        try {
+            postgresValues = validatePostgresConfig(config.storage?.postgresql);
+        }
+        catch (err) {
+            output.error(`${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    }
     // If specific services are requested, install only those services
     if (serviceNames.length > 0) {
         for (const serviceName of serviceNames) {
@@ -174,7 +229,7 @@ export async function installArk(config, serviceNames = [], options = {}) {
                 }
                 output.info(`installing marketplace item ${service.name}...`);
                 try {
-                    await installService(service, options.verbose, options.arkVersion, options.marketplaceVersion);
+                    await installService(service, options.verbose, options.arkVersion, options.marketplaceVersion, []);
                     output.success(`${service.name} installed successfully`);
                 }
                 catch (error) {
@@ -185,7 +240,7 @@ export async function installArk(config, serviceNames = [], options = {}) {
                 continue;
             }
             // Core ARK service
-            const services = getInstallableServices();
+            const services = getInstallableServices(backend);
             const service = Object.values(services).find((s) => s.name === serviceName);
             if (!service) {
                 output.error(`service '${serviceName}' not found`);
@@ -197,8 +252,26 @@ export async function installArk(config, serviceNames = [], options = {}) {
             }
             output.info(`installing ${service.name}...`);
             try {
-                await installService(service, options.verbose, options.arkVersion, options.marketplaceVersion);
+                await installService(service, options.verbose, options.arkVersion, options.marketplaceVersion, backendInstallArgs(service, backend, postgresValues));
                 output.success(`${service.name} installed successfully`);
+                // Wait for ark-apiserver to be ready before continuing to other services
+                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 failed = results.find((r) => !r.passed);
+                        if (failed) {
+                            spinner.fail(`ark-apiserver readiness check failed: ${failed.message || 'unknown error'}`);
+                            output.error('ark-apiserver is not ready. Stopping installation.');
+                            process.exit(1);
+                        }
+                        spinner.succeed('ark-apiserver is ready');
+                    }
+                    catch (error) {
+                        spinner.fail('Failed to check ark-apiserver readiness');
+                        throw error;
+                    }
+                }
             }
             catch (error) {
                 if (handleInstallError(error, service, options)) {
@@ -210,11 +283,19 @@ export async function installArk(config, serviceNames = [], options = {}) {
     }
     // If not using -y flag, show checklist interface
     if (!options.yes) {
+        const backendMatch = (s) => !s.requiresBackend || s.requiresBackend === backend;
         const coreServices = Object.values(arkServices)
-            .filter((s) => s.category === 'core')
-            .sort((a, b) => a.name.localeCompare(b.name));
+            .filter((s) => s.category === 'core' && backendMatch(s))
+            .sort((a, b) => {
+            // Ensure ark-controller is always first
+            if (a.name === 'ark-controller')
+                return -1;
+            if (b.name === 'ark-controller')
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
         const otherServices = Object.values(arkServices)
-            .filter((s) => s.category === 'service')
+            .filter((s) => s.category === 'service' && backendMatch(s))
             .sort((a, b) => a.name.localeCompare(b.name));
         const mandatoryServiceNames = [...coreServices, ...otherServices]
             .filter((s) => s.mandatory)
@@ -331,7 +412,25 @@ export async function installArk(config, serviceNames = [], options = {}) {
             }
             output.info(`installing ${service.name}...`);
             try {
-                await installService(service, options.verbose, options.arkVersion, options.marketplaceVersion);
+                await installService(service, options.verbose, options.arkVersion, options.marketplaceVersion, backendInstallArgs(service, backend, postgresValues));
+                // Wait for ark-apiserver to be ready before continuing to other services
+                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 failed = results.find((r) => !r.passed);
+                        if (failed) {
+                            spinner.fail(`ark-apiserver readiness check failed: ${failed.message || 'unknown error'}`);
+                            output.error('ark-apiserver is not ready. Stopping installation.');
+                            process.exit(1);
+                        }
+                        spinner.succeed('ark-apiserver is ready');
+                    }
+                    catch (error) {
+                        spinner.fail('Failed to check ark-apiserver readiness');
+                        throw error;
+                    }
+                }
                 console.log(); // Add blank line after command output
             }
             catch (error) {
@@ -361,11 +460,19 @@ export async function installArk(config, serviceNames = [], options = {}) {
             }
         }
         // Install all services
-        const services = getInstallableServices();
-        for (const service of Object.values(services)) {
+        const services = getInstallableServices(backend);
+        const sortedServices = Object.values(services).sort((a, b) => {
+            // Ensure ark-controller is always first
+            if (a.name === 'ark-controller')
+                return -1;
+            if (b.name === 'ark-controller')
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        for (const service of sortedServices) {
             output.info(`installing ${service.name}...`);
             try {
-                await installService(service, options.verbose, options.arkVersion, options.marketplaceVersion);
+                await installService(service, options.verbose, options.arkVersion, options.marketplaceVersion, backendInstallArgs(service, backend, postgresValues));
                 console.log(); // Add blank line after command output
             }
             catch (error) {
@@ -388,7 +495,8 @@ export async function installArk(config, serviceNames = [], options = {}) {
             const servicesToWait = Object.values(arkServices).filter((s) => s.enabled &&
                 s.category === 'core' &&
                 s.k8sDeploymentName &&
-                s.namespace);
+                s.namespace &&
+                (!s.requiresBackend || s.requiresBackend === backend));
             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));
@@ -428,6 +536,7 @@ export function createInstallCommand(config) {
         .option('--ark-version <version>', 'ARK version to install (e.g., 0.1.50, defaults to CLI version)')
         .option('--marketplace-version <version>', 'Marketplace item version to install (e.g., 0.1.5)')
         .option('--wait-for-ready <timeout>', 'wait for Ark to be ready after installation (e.g., 30s, 2m)')
+        .option('--backend <type>', "storage backend: 'etcd' (default) or 'postgresql' (overrides storage.backend in .arkrc.yaml)")
         .option('-v, --verbose', 'show commands being executed')
         .action(async (services, options) => {
         await installArk(config, services, options);

package/dist/lib/config.d.ts

@@ -8,6 +8,19 @@ export interface MarketplaceConfig {
     repoUrl?: string;
     registry?: string;
 }
+export interface PostgresStorageConfig {
+    host: string;
+    port?: number | string;
+    database?: string;
+    user: string;
+    passwordSecretName: string;
+    passwordSecretKey?: string;
+    sslMode?: string;
+}
+export interface StorageConfig {
+    backend?: 'etcd' | 'postgresql';
+    postgresql?: PostgresStorageConfig;
+}
 export interface ArkConfig {
     chat?: ChatConfig;
     marketplace?: MarketplaceConfig;
@@ -15,6 +28,7 @@ export interface ArkConfig {
         reusePortForwards?: boolean;
         [serviceName: string]: Partial<ArkService> | boolean | undefined;
     };
+    storage?: StorageConfig;
     queryTimeout?: string;
     defaultExportTypes?: string[];
     clusterInfo?: ClusterInfo;

package/dist/lib/config.js

@@ -80,6 +80,13 @@ export function loadConfig() {
         config.services.reusePortForwards =
             process.env.ARK_SERVICES_REUSE_PORT_FORWARDS === '1';
     }
+    if (process.env.ARK_STORAGE_BACKEND !== undefined) {
+        const backend = process.env.ARK_STORAGE_BACKEND;
+        if (backend === 'etcd' || backend === 'postgresql') {
+            config.storage = config.storage || {};
+            config.storage.backend = backend;
+        }
+    }
     return config;
 }
 /**
@@ -119,6 +126,18 @@ function mergeConfig(target, source) {
             }
         }
     }
+    if (source.storage) {
+        target.storage = target.storage || {};
+        if (source.storage.backend !== undefined) {
+            target.storage.backend = source.storage.backend;
+        }
+        if (source.storage.postgresql) {
+            target.storage.postgresql = {
+                ...target.storage.postgresql,
+                ...source.storage.postgresql,
+            };
+        }
+    }
     if (source.queryTimeout !== undefined) {
         target.queryTimeout = source.queryTimeout;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.61",
+  "version": "0.1.63",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",
@@ -87,7 +87,7 @@
   "overrides": {
     "minimatch": "^10.2.3",
     "rollup": "4.59.0",
-    "hono": "^4.12.14",
+    "hono": "^4.12.18",
     "@hono/node-server": "^1.19.13",
     "flatted": "^3.4.2",
     "tar": "^7.5.11",

package/templates/tool/uv.lock

@@ -772,11 +772,11 @@ wheels = [
 
 [[package]]
 name = "python-multipart"
-version = "0.0.26"
+version = "0.0.27"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/88/71/b145a380824a960ebd60e1014256dbb7d2253f2316ff2d73dfd8928ec2c3/python_multipart-0.0.26.tar.gz", hash = "sha256:08fadc45918cd615e26846437f50c5d6d23304da32c341f289a617127b081f17", size = 43501, upload-time = "2026-04-10T14:09:59.473Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/69/9b/f23807317a113dc36e74e75eb265a02dd1a4d9082abc3c1064acd22997c4/python_multipart-0.0.27.tar.gz", hash = "sha256:9870a6a8c5a20a5bf4f07c017bd1489006ff8836cff097b6933355ee2b49b602", size = 44043, upload-time = "2026-04-27T10:51:26.649Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9a/22/f1925cdda983ab66fc8ec6ec8014b959262747e58bdca26a4e3d1da29d56/python_multipart-0.0.26-py3-none-any.whl", hash = "sha256:c0b169f8c4484c13b0dcf2ef0ec3a4adb255c4b7d18d8e420477d2b1dd03f185", size = 28847, upload-time = "2026-04-10T14:09:58.131Z" },
+    { url = "https://files.pythonhosted.org/packages/99/78/4126abcbdbd3c559d43e0db7f7b9173fc6befe45d39a2856cc0b8ec2a5a6/python_multipart-0.0.27-py3-none-any.whl", hash = "sha256:6fccfad17a27334bd0193681b369f476eda3409f17381a2d65aa7df3f7275645", size = 29254, upload-time = "2026-04-27T10:51:24.997Z" },
 ]
 
 [[package]]