@agents-at-scale/ark 0.1.71 → 0.1.72

package/dist/commands/status/index.js

@@ -19,6 +19,7 @@ function enrichServiceDetails(service) {
         warning: { icon: '⚠', text: 'warning', color: 'yellow' },
         'not ready': { icon: '○', text: 'not ready', color: 'yellow' },
         'not installed': { icon: '?', text: 'not installed', color: 'yellow' },
+        'no access': { icon: '⊘', text: 'no access', color: 'yellow' },
     };
     const statusInfo = statusMap[service.status] || {
         icon: '?',

package/dist/components/statusChecker.js

@@ -52,8 +52,22 @@ export const getKindVersion = () => ({
         return match ? match[1] : output.trim();
     },
 });
-function createErrorServiceStatus(name, url, error, defaultStatus = 'unhealthy', defaultDetails) {
+function isForbiddenError(error) {
+    return error instanceof Error && /forbidden/i.test(error.message);
+}
+function createErrorServiceStatus(name, url, error, defaultStatus = 'unhealthy', defaultDetails, namespace) {
     const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+    if (isForbiddenError(error)) {
+        return {
+            name,
+            status: 'no access',
+            url,
+            details: namespace
+                ? `No permission to read namespace '${namespace}'`
+                : 'No permission to read this resource',
+            namespace,
+        };
+    }
     return {
         name,
         status: defaultStatus,
@@ -246,7 +260,7 @@ export class StatusChecker {
                     namespace,
                 };
             }
-            return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check deployment: ${errorMessage}`);
+            return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check deployment: ${errorMessage}`, namespace);
         }
     }
     /**
@@ -288,7 +302,7 @@ export class StatusChecker {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check helm status: ${errorMessage}`);
+            return createErrorServiceStatus(serviceName, '', error, 'unhealthy', `Failed to check helm status: ${errorMessage}`, namespace);
         }
     }
     /**

package/dist/lib/cluster.js

@@ -1,4 +1,5 @@
 import { execa } from 'execa';
+import { classifyFailure } from './readinessChecks.js';
 export async function detectClusterType() {
     try {
         const { stdout } = await execa('kubectl', ['config', 'current-context']);
@@ -31,7 +32,59 @@ export async function detectClusterType() {
         };
     }
 }
+const NODE_INTERNAL_IP_JSONPATH = 'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}';
+const NODE_EXTERNAL_IP_JSONPATH = 'jsonpath={.items[0].status.addresses[?(@.type=="ExternalIP")].address}';
+async function getNodeIp(jsonpath) {
+    const { stdout } = await execa('kubectl', ['get', 'nodes', '-o', jsonpath]);
+    return stdout.trim();
+}
+async function getIstioGatewayAddress(field) {
+    const { stdout } = await execa('kubectl', [
+        'get',
+        'svc',
+        '-n',
+        'istio-system',
+        'istio-ingressgateway',
+        '-o',
+        `jsonpath={.status.loadBalancer.ingress[0].${field}}`,
+    ]);
+    return stdout.trim();
+}
+async function resolveClusterIp(type) {
+    switch (type) {
+        case 'minikube':
+            try {
+                const { stdout } = await execa('minikube', ['ip']);
+                return stdout.trim();
+            }
+            catch {
+                return getNodeIp(NODE_INTERNAL_IP_JSONPATH);
+            }
+        case 'docker-desktop':
+            return 'localhost';
+        case 'cloud':
+            try {
+                const ip = await getIstioGatewayAddress('ip');
+                return ip || (await getIstioGatewayAddress('hostname'));
+            }
+            catch {
+                return getNodeIp(NODE_EXTERNAL_IP_JSONPATH);
+            }
+        default:
+            return getNodeIp(NODE_INTERNAL_IP_JSONPATH);
+    }
+}
+function isForbiddenError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const stderr = error.stderr;
+    const text = typeof stderr === 'string' && stderr ? stderr : error.message;
+    return classifyFailure(text) === 'forbidden';
+}
 export async function getClusterInfo(context) {
+    let resolvedContext;
+    let resolvedNamespace;
     try {
         // If context is provided, use it
         const contextArgs = context ? ['--context', context] : [];
@@ -48,6 +101,8 @@ export async function getClusterInfo(context) {
         const currentContext = config['current-context'] || '';
         const contextData = config.contexts?.find((c) => c.name === currentContext);
         const namespace = contextData?.context?.namespace || 'default';
+        resolvedContext = currentContext;
+        resolvedNamespace = namespace;
         // Detect cluster type from context name
         const clusterInfo = await detectClusterType();
         clusterInfo.context = currentContext;
@@ -56,99 +111,22 @@ export async function getClusterInfo(context) {
             return clusterInfo;
         }
         let ip;
-        switch (clusterInfo.type) {
-            case 'minikube':
-                try {
-                    const { stdout } = await execa('minikube', ['ip']);
-                    ip = stdout.trim();
-                }
-                catch {
-                    // Fallback to kubectl if minikube command fails
-                    const { stdout } = await execa('kubectl', [
-                        'get',
-                        'nodes',
-                        '-o',
-                        'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
-                    ]);
-                    ip = stdout.trim();
-                }
-                break;
-            case 'kind': {
-                const { stdout: kindOutput } = await execa('kubectl', [
-                    'get',
-                    'nodes',
-                    '-o',
-                    'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
-                ]);
-                ip = kindOutput.trim();
-                break;
-            }
-            case 'docker-desktop':
-                ip = 'localhost';
-                break;
-            case 'k3s': {
-                const { stdout: k3sOutput } = await execa('kubectl', [
-                    'get',
-                    'nodes',
-                    '-o',
-                    'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
-                ]);
-                ip = k3sOutput.trim();
-                break;
-            }
-            case 'cloud':
-                // For cloud clusters, try to get the external IP or load balancer IP
-                try {
-                    const { stdout: lbOutput } = await execa('kubectl', [
-                        'get',
-                        'svc',
-                        '-n',
-                        'istio-system',
-                        'istio-ingressgateway',
-                        '-o',
-                        'jsonpath={.status.loadBalancer.ingress[0].ip}',
-                    ]);
-                    ip = lbOutput.trim();
-                    if (!ip) {
-                        const { stdout: hostnameOutput } = await execa('kubectl', [
-                            'get',
-                            'svc',
-                            '-n',
-                            'istio-system',
-                            'istio-ingressgateway',
-                            '-o',
-                            'jsonpath={.status.loadBalancer.ingress[0].hostname}',
-                        ]);
-                        ip = hostnameOutput.trim();
-                    }
-                }
-                catch {
-                    // Fallback to node IP
-                    const { stdout: nodeOutput } = await execa('kubectl', [
-                        'get',
-                        'nodes',
-                        '-o',
-                        'jsonpath={.items[0].status.addresses[?(@.type=="ExternalIP")].address}',
-                    ]);
-                    ip = nodeOutput.trim();
-                }
-                break;
-            default: {
-                const { stdout: defaultOutput } = await execa('kubectl', [
-                    'get',
-                    'nodes',
-                    '-o',
-                    'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
-                ]);
-                ip = defaultOutput.trim();
-                break;
+        try {
+            ip = await resolveClusterIp(clusterInfo.type);
+        }
+        catch (error) {
+            if (!isForbiddenError(error)) {
+                throw error;
             }
+            ip = undefined;
         }
         return { ...clusterInfo, ip };
     }
     catch (error) {
         return {
             type: 'unknown',
+            ...(resolvedContext !== undefined && { context: resolvedContext }),
+            ...(resolvedNamespace !== undefined && { namespace: resolvedNamespace }),
             error: error instanceof Error ? error.message : 'Unknown error',
         };
     }

package/dist/lib/readinessChecks.d.ts

@@ -20,6 +20,8 @@ export interface NamespaceMemoryCheck {
     message: string;
 }
 export type ReadinessProgress = (result: ReadinessCheckResult) => void;
+type FailureReason = 'not-found' | 'forbidden' | 'unreachable' | 'undetermined';
+export declare function classifyFailure(stderr: string): FailureReason;
 export declare function describeStorageBackend(): Promise<BackendDetection>;
 /**
  * Report whether the namespace ends up with a Memory the executor can use.
@@ -39,3 +41,4 @@ export declare function describeStorageBackend(): Promise<BackendDetection>;
 export declare function describeNamespaceMemory(namespace: string): Promise<NamespaceMemoryCheck>;
 export declare function detectStorageBackend(): Promise<DetectedBackend>;
 export declare function runReadinessChecks(timeoutSeconds: number, backend: DetectedBackend, onProgress?: ReadinessProgress): Promise<ReadinessCheckResult[]>;
+export {};

package/dist/lib/readinessChecks.js

@@ -19,7 +19,7 @@ async function runKubectl(args, timeoutMs) {
 // aggregated API server serves no arkconfigs, so this is the normal reply
 // there rather than something to retry.
 const UNSERVED_RESOURCE_PATTERN = /doesn't have a resource type|no matches for kind|the server could not find the requested resource/i;
-function classifyFailure(stderr) {
+export function classifyFailure(stderr) {
     if (/not\s*found/i.test(stderr) || UNSERVED_RESOURCE_PATTERN.test(stderr)) {
         return 'not-found';
     }

package/dist/lib/types.d.ts

@@ -16,7 +16,7 @@ export interface KubernetesConfig {
 export type DeploymentStatus = 'available' | 'progressing' | 'replicafailure' | 'failed' | 'not found' | 'unknown';
 export type ServiceStatus = {
     name: string;
-    status: 'healthy' | 'warning' | 'unhealthy' | 'not installed' | 'not ready';
+    status: 'healthy' | 'warning' | 'unhealthy' | 'not installed' | 'not ready' | 'no access';
     deploymentStatus?: DeploymentStatus;
     url?: string;
     version?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.71",
+  "version": "0.1.72",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",
@@ -102,6 +102,7 @@
     "form-data": "^4.0.6",
     "postcss": "^8.5.18",
     "proxy-addr": "^2.0.8",
-    "source-map-js": "^1.2.2"
+    "source-map-js": "^1.2.2",
+    "follow-redirects": "^1.16.1"
   }
 }

package/templates/mcp-server/Dockerfile

@@ -63,7 +63,7 @@ ENTRYPOINT [ "/bin/bash", "-c", "mcp-proxy --debug --port 8080 --host 0.0.0.0 --
 {{- end }}
 
 {{- else if eq .Values.technology "go" }}
-FROM golang:1.26.6-alpine AS go-builder
+FROM golang:1.26.9-alpine AS go-builder
 {{- if .Values.packageSource }}
 {{- if eq .Values.packageSource "go-install" }}
 RUN go install {{ .Values.packageName }}@latest