@enspirit/emb 0.23.0 → 0.25.0

package/dist/src/kubernetes/operations/GetComponentPodOperation.js

@@ -0,0 +1,77 @@
+import * as z from 'zod';
+import { CliError } from '../../errors.js';
+import { Component } from '../../monorepo/index.js';
+import { AbstractOperation } from '../../operations/index.js';
+const schema = z.object({
+    component: z
+        .instanceof(Component)
+        .describe('The component to get the pod for'),
+    namespace: z.string().describe('The Kubernetes namespace'),
+});
+export class GetComponentPodOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(input) {
+        const { kubernetes, monorepo } = this.context;
+        const { component, namespace } = input;
+        const k8sConfig = component.config.kubernetes;
+        const projectK8sConfig = monorepo.config.defaults?.kubernetes;
+        // Build label selector: use explicit config or default convention
+        // Priority: component.kubernetes.selector > project.kubernetes.selectorLabel > default
+        const selectorLabel = projectK8sConfig?.selectorLabel ?? 'app.kubernetes.io/component';
+        const labelSelector = k8sConfig?.selector ?? `${selectorLabel}=${component.name}`;
+        // List pods matching the selector
+        const res = await kubernetes.core.listNamespacedPod({
+            namespace,
+            labelSelector,
+        });
+        // Filter to ready pods
+        const readyPods = res.items.filter((pod) => {
+            const conditions = pod.status?.conditions ?? [];
+            return conditions.some((c) => c.type === 'Ready' && c.status === 'True');
+        });
+        if (readyPods.length === 0) {
+            throw new CliError('K8S_NO_READY_PODS', `No ready pods found for component "${component.name}" in namespace "${namespace}"`, [
+                `Label selector used: ${labelSelector}`,
+                `Check pod status: kubectl get pods -l ${labelSelector} -n ${namespace}`,
+                `To use a different selector, add kubernetes.selector to component config`,
+            ]);
+        }
+        // Get first ready pod
+        const pod = readyPods[0];
+        // Determine container name
+        const containers = pod.spec?.containers ?? [];
+        if (containers.length === 0) {
+            throw new CliError('K8S_NO_CONTAINERS', `Pod "${pod.metadata?.name}" has no containers`);
+        }
+        let containerName;
+        if (k8sConfig?.container) {
+            // Use explicit container config
+            containerName = k8sConfig.container;
+            const containerExists = containers.some((c) => c.name === containerName);
+            if (!containerExists) {
+                throw new CliError('K8S_CONTAINER_NOT_FOUND', `Container "${containerName}" not found in pod "${pod.metadata?.name}"`, [
+                    `Available containers: ${containers.map((c) => c.name).join(', ')}`,
+                    `Update kubernetes.container in component config if needed`,
+                ]);
+            }
+        }
+        else if (containers.length === 1) {
+            // Single container pod: use it
+            containerName = containers[0].name;
+        }
+        else {
+            // Multi-container pod: require explicit config
+            throw new CliError('K8S_MULTI_CONTAINER', `Pod "${pod.metadata?.name}" has multiple containers, explicit container config required`, [
+                `Available containers: ${containers.map((c) => c.name).join(', ')}`,
+                `Add kubernetes.container to component "${component.name}" config:`,
+                `  components:`,
+                `    ${component.name}:`,
+                `      kubernetes:`,
+                `        container: <container-name>`,
+            ]);
+        }
+        return { pod, container: containerName };
+    }
+}

package/dist/src/kubernetes/operations/GetDeploymentPodsOperation.js

@@ -10,10 +10,12 @@ export class GetDeploymentPodsOperation extends AbstractOperation {
         super(schema);
     }
     async _run(input) {
-        const { kubernetes } = getContext();
+        const { kubernetes, monorepo } = getContext();
+        const selectorLabel = monorepo.config.defaults?.kubernetes?.selectorLabel ??
+            'app.kubernetes.io/component';
         const res = await kubernetes.core.listNamespacedPod({
             namespace: input.namespace,
-            labelSelector: `component=${input.deployment}`,
+            labelSelector: `${selectorLabel}=${input.deployment}`,
         });
         return res.items;
     }

package/dist/src/kubernetes/operations/PodExecOperation.d.ts

@@ -0,0 +1,20 @@
+import { Writable } from 'node:stream';
+import * as z from 'zod';
+import { AbstractOperation } from '../../operations/index.js';
+declare const schema: z.ZodObject<{
+    namespace: z.ZodString;
+    podName: z.ZodString;
+    container: z.ZodOptional<z.ZodString>;
+    script: z.ZodString;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    interactive: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    tty: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    workingDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare class PodExecOperation extends AbstractOperation<typeof schema, void> {
+    protected out?: Writable | undefined;
+    constructor(out?: Writable | undefined);
+    protected _run(input: z.input<typeof schema>): Promise<void>;
+    private wrapError;
+}
+export {};

package/dist/src/kubernetes/operations/PodExecOperation.js

@@ -0,0 +1,158 @@
+import { Exec } from '@kubernetes/client-node';
+import * as z from 'zod';
+import { CliError } from '../../errors.js';
+import { AbstractOperation } from '../../operations/index.js';
+const schema = z.object({
+    namespace: z.string().describe('The namespace of the pod'),
+    podName: z.string().describe('The name of the pod'),
+    container: z
+        .string()
+        .optional()
+        .describe('The container name (required for multi-container pods)'),
+    script: z.string().describe('Command to run, as a string'),
+    env: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe('Environment variables to pass to the command'),
+    interactive: z
+        .boolean()
+        .default(false)
+        .optional()
+        .describe('Whether the command is interactive'),
+    tty: z.boolean().default(false).optional().describe('Allocate a pseudo-TTY'),
+    workingDir: z
+        .string()
+        .optional()
+        .describe('The working directory for the command'),
+});
+export class PodExecOperation extends AbstractOperation {
+    out;
+    constructor(out) {
+        super(schema);
+        this.out = out;
+    }
+    async _run(input) {
+        const { kubernetes } = this.context;
+        const exec = new Exec(kubernetes.config);
+        const isInteractive = input.interactive || input.tty;
+        // Build the command with optional workdir and env vars
+        let { script } = input;
+        // Handle working directory by wrapping the command
+        if (input.workingDir) {
+            script = `cd ${JSON.stringify(input.workingDir)} && ${script}`;
+        }
+        // Build environment variable exports
+        const envExports = Object.entries(input.env || {})
+            .map(([key, value]) => `export ${key}=${JSON.stringify(value)}`)
+            .join('; ');
+        if (envExports) {
+            script = `${envExports}; ${script}`;
+        }
+        const command = ['sh', '-c', script];
+        // Determine container name
+        const containerName = input.container;
+        if (!containerName) {
+            throw new CliError('K8S_NO_CONTAINER', 'Container name is required', [
+                'Specify kubernetes.container in component config:',
+                '  components:',
+                '    <component>:',
+                '      kubernetes:',
+                '        container: <container-name>',
+            ]);
+        }
+        const stdout = isInteractive ? process.stdout : (this.out ?? null);
+        const stderr = isInteractive ? process.stderr : (this.out ?? null);
+        const stdin = isInteractive ? process.stdin : null;
+        return new Promise((resolve, reject) => {
+            let exitCode = 0;
+            let ws;
+            let sigintHandler;
+            const cleanup = () => {
+                // Restore stdin raw mode
+                if (isInteractive && process.stdin.isTTY) {
+                    process.stdin.setRawMode?.(false);
+                }
+                // Remove SIGINT handler
+                if (sigintHandler) {
+                    process.off('SIGINT', sigintHandler);
+                }
+            };
+            const statusCallback = (status) => {
+                if (status.status === 'Success') {
+                    exitCode = 0;
+                }
+                else if (status.status === 'Failure') {
+                    // Try to extract exit code from the status message
+                    const match = status.message?.match(/command terminated with exit code (\d+)/);
+                    exitCode = match ? Number.parseInt(match[1], 10) : 1;
+                }
+            };
+            // Set raw mode for interactive sessions
+            if (isInteractive && process.stdin.isTTY) {
+                process.stdin.setRawMode?.(true);
+                // Handle Ctrl+C gracefully
+                sigintHandler = () => {
+                    cleanup();
+                    if (ws) {
+                        ws.close();
+                    }
+                    reject(new Error('Interrupted'));
+                };
+                process.on('SIGINT', sigintHandler);
+            }
+            exec
+                .exec(input.namespace, input.podName, containerName, command, stdout, stderr, stdin, isInteractive ?? false, statusCallback)
+                .then((websocket) => {
+                ws = websocket;
+                websocket.on('close', () => {
+                    cleanup();
+                    if (exitCode === 0) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`command failed (exit ${exitCode})`));
+                    }
+                });
+                websocket.on('error', (error) => {
+                    cleanup();
+                    reject(this.wrapError(error, input));
+                });
+            })
+                .catch((error) => {
+                cleanup();
+                reject(this.wrapError(error, input));
+            });
+        });
+    }
+    wrapError(error, input) {
+        const message = error.message || String(error);
+        // Handle common Kubernetes API errors
+        if (message.includes('not found') || message.includes('404')) {
+            return new CliError('K8S_POD_NOT_FOUND', `Pod "${input.podName}" not found in namespace "${input.namespace}"`, [
+                `Check pod exists: kubectl get pod ${input.podName} -n ${input.namespace}`,
+                `List pods: kubectl get pods -n ${input.namespace}`,
+            ]);
+        }
+        if (message.includes('Forbidden') || message.includes('403')) {
+            return new CliError('K8S_FORBIDDEN', `Access denied to pod "${input.podName}" in namespace "${input.namespace}"`, [
+                `Check permissions: kubectl auth can-i create pods/exec -n ${input.namespace}`,
+                'Ensure your kubeconfig has the correct context and credentials',
+            ]);
+        }
+        if (message.includes('Unauthorized') || message.includes('401')) {
+            return new CliError('K8S_UNAUTHORIZED', 'Kubernetes authentication failed', [
+                'Check your kubeconfig: kubectl config view',
+                'Try re-authenticating: kubectl auth login',
+            ]);
+        }
+        if (message.includes('connection refused') ||
+            message.includes('ECONNREFUSED')) {
+            return new CliError('K8S_CONNECTION_REFUSED', 'Cannot connect to Kubernetes cluster', [
+                'Check cluster is running: kubectl cluster-info',
+                'Verify kubeconfig context: kubectl config current-context',
+            ]);
+        }
+        // Return original error if not a known type
+        return error;
+    }
+}

package/dist/src/kubernetes/operations/index.d.ts

@@ -1 +1,4 @@
+export * from './GetComponentPodOperation.js';
+export * from './GetDeploymentPodsOperation.js';
+export * from './PodExecOperation.js';
 export * from './RestartPodsOperation.js';

package/dist/src/kubernetes/operations/index.js

@@ -1 +1,4 @@
+export * from './GetComponentPodOperation.js';
+export * from './GetDeploymentPodsOperation.js';
+export * from './PodExecOperation.js';
 export * from './RestartPodsOperation.js';

package/dist/src/kubernetes/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './resolveNamespace.js';

package/dist/src/kubernetes/utils/index.js

@@ -0,0 +1 @@
+export * from './resolveNamespace.js';

package/dist/src/kubernetes/utils/resolveNamespace.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Resolves the Kubernetes namespace to use for operations.
+ *
+ * Resolution order (first non-empty value wins):
+ * 1. CLI flag (--namespace)
+ * 2. Environment variable (K8S_NAMESPACE)
+ * 3. Config file (kubernetes.namespace in .emb.yml)
+ * 4. Default: "default"
+ */
+export declare function resolveNamespace(options: {
+    cliFlag?: string;
+    config?: string;
+}): string;

package/dist/src/kubernetes/utils/resolveNamespace.js

@@ -0,0 +1,12 @@
+/**
+ * Resolves the Kubernetes namespace to use for operations.
+ *
+ * Resolution order (first non-empty value wins):
+ * 1. CLI flag (--namespace)
+ * 2. Environment variable (K8S_NAMESPACE)
+ * 3. Config file (kubernetes.namespace in .emb.yml)
+ * 4. Default: "default"
+ */
+export function resolveNamespace(options) {
+    return (options.cliFlag || process.env.K8S_NAMESPACE || options.config || 'default');
+}

package/dist/src/monorepo/operations/resources/PublishResourcesOperation.d.ts

@@ -0,0 +1,19 @@
+import * as z from 'zod';
+import { ResourceInfo } from '../../index.js';
+import { AbstractOperation } from '../../../operations/index.js';
+declare const schema: z.ZodObject<{
+    resources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    silent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PublishResourceMeta = {
+    resource: ResourceInfo;
+    reference: string;
+    skipped?: boolean;
+    skipReason?: string;
+};
+export declare class PublishResourcesOperation extends AbstractOperation<typeof schema, Record<string, PublishResourceMeta>> {
+    constructor();
+    protected _run(input: z.input<typeof schema>): Promise<Record<string, PublishResourceMeta>>;
+}
+export {};

package/dist/src/monorepo/operations/resources/PublishResourcesOperation.js

@@ -0,0 +1,120 @@
+import { PRESET_TIMER } from 'listr2';
+import * as z from 'zod';
+import { CliError } from '../../../errors.js';
+import { EMBCollection, findRunOrder, ResourceFactory, } from '../../index.js';
+import { AbstractOperation } from '../../../operations/index.js';
+const schema = z.object({
+    resources: z
+        .array(z.string())
+        .describe('The list of resources to publish')
+        .optional(),
+    dryRun: z
+        .boolean()
+        .optional()
+        .describe('Do not publish, just show what would be published'),
+    silent: z
+        .boolean()
+        .optional()
+        .describe('Do not produce any output on the terminal'),
+});
+export class PublishResourcesOperation extends AbstractOperation {
+    constructor() {
+        super(schema);
+    }
+    async _run(input) {
+        const { monorepo } = this.context;
+        const manager = monorepo.taskManager();
+        // Filter to only publishable resources (publish: true)
+        const publishableResources = monorepo.resources.filter((r) => r.publish === true);
+        // Return early if no publishable resources
+        if (publishableResources.length === 0) {
+            return {};
+        }
+        // If specific resources requested, filter to those
+        let targetResources;
+        if (input.resources && input.resources.length > 0) {
+            const collection = new EMBCollection(publishableResources, {
+                idField: 'id',
+                depField: 'dependencies',
+            });
+            targetResources = findRunOrder(input.resources, collection);
+        }
+        else {
+            // All publishable resources
+            const collection = new EMBCollection(publishableResources, {
+                idField: 'id',
+                depField: 'dependencies',
+            });
+            targetResources = findRunOrder(publishableResources.map((r) => r.id), collection);
+        }
+        // Verify each resource's builder supports publish
+        for (const resource of targetResources) {
+            const component = monorepo.component(resource.component);
+            const builder = ResourceFactory.factor(resource.type, {
+                config: resource,
+                monorepo,
+                component,
+            });
+            if (typeof builder.publish !== 'function') {
+                throw new CliError('PUBLISH_NOT_SUPPORTED', `Resource "${resource.id}" has publish: true but resource type "${resource.type}" does not support publishing.`, [
+                    `Remove "publish: true" from the resource configuration`,
+                    `Use a different resource type that supports publishing (e.g., docker/image)`,
+                ]);
+            }
+        }
+        const tasks = targetResources.map((resource) => {
+            return {
+                title: `Publish ${resource.id}`,
+                async task(ctx, task) {
+                    const component = monorepo.component(resource.component);
+                    const builder = ResourceFactory.factor(resource.type, {
+                        config: resource,
+                        monorepo,
+                        component,
+                    });
+                    const reference = await builder.getReference();
+                    ctx[resource.id] = {
+                        resource,
+                        reference,
+                    };
+                    if (input.dryRun) {
+                        ctx[resource.id].skipped = true;
+                        ctx[resource.id].skipReason = 'dry run';
+                        task.title = `[dry run] ${resource.id} → ${reference}`;
+                        return task.skip();
+                    }
+                    task.title = `Publishing ${resource.id} → ${reference}`;
+                    await builder.publish(resource, task.stdout());
+                },
+            };
+        });
+        if (tasks.length === 0) {
+            return {};
+        }
+        return manager.run([
+            {
+                title: 'Publish resources',
+                async task(_ctx, task) {
+                    return task.newListr(tasks, {
+                        rendererOptions: {
+                            collapseSubtasks: false,
+                            collapseSkips: true,
+                        },
+                    });
+                },
+            },
+        ], {
+            silentRendererCondition() {
+                return Boolean(input.silent);
+            },
+            rendererOptions: {
+                collapseSkips: true,
+                collapseSubtasks: true,
+                timer: {
+                    ...PRESET_TIMER,
+                },
+            },
+            ctx: {},
+        });
+    }
+}

package/dist/src/monorepo/operations/tasks/RunTasksOperation.d.ts

@@ -3,6 +3,7 @@ import { TaskInfo } from '../../index.js';
 import { IOperation } from '../../../operations/index.js';
 export declare enum ExecutorType {
     container = "container",
+    kubernetes = "kubernetes",
     local = "local"
 }
 export type RunTasksOperationParams = {
@@ -22,6 +23,7 @@ export declare class RunTasksOperation implements IOperation<RunTasksOperationPa
     run(params: RunTasksOperationParams): Promise<Array<TaskInfo>>;
     protected runDocker(task: TaskWithScriptAndComponent, out?: Writable): Promise<void>;
     protected runLocal(task: TaskWithScript, _out: Writable): Promise<import("stream").Readable>;
+    protected runKubernetes(task: TaskWithScriptAndComponent, out?: Writable): Promise<void>;
     private defaultExecutorFor;
     private ensureExecutorValid;
     private availableExecutorsFor;

package/dist/src/monorepo/operations/tasks/RunTasksOperation.js

@@ -3,11 +3,14 @@ import { input } from '@inquirer/prompts';
 import { ListrInquirerPromptAdapter } from '@listr2/prompt-adapter-inquirer';
 import { PassThrough } from 'node:stream';
 import { ContainerExecOperation } from '../../../docker/index.js';
+import { GetComponentPodOperation, PodExecOperation, } from '../../../kubernetes/operations/index.js';
+import { resolveNamespace } from '../../../kubernetes/utils/index.js';
 import { EMBCollection, findRunOrder } from '../../index.js';
 import { ExecuteLocalCommandOperation } from '../index.js';
 export var ExecutorType;
 (function (ExecutorType) {
     ExecutorType["container"] = "container";
+    ExecutorType["kubernetes"] = "kubernetes";
     ExecutorType["local"] = "local";
 })(ExecutorType || (ExecutorType = {}));
 export class RunTasksOperation {
@@ -59,6 +62,9 @@ export class RunTasksOperation {
                         case ExecutorType.container: {
                             return this.runDocker(task, tee);
                         }
+                        case ExecutorType.kubernetes: {
+                            return this.runKubernetes(task, tee);
+                        }
                         case ExecutorType.local: {
                             return this.runLocal(task, tee);
                         }
@@ -94,6 +100,30 @@ export class RunTasksOperation {
             env: await monorepo.expand(task.vars || {}),
         });
     }
+    async runKubernetes(task, out) {
+        const { monorepo } = getContext();
+        const component = monorepo.component(task.component);
+        const namespace = resolveNamespace({
+            config: monorepo.config.defaults?.kubernetes?.namespace,
+        });
+        // Resolve the pod and container for this component
+        const { pod, container } = await monorepo.run(new GetComponentPodOperation(), {
+            component,
+            namespace,
+        });
+        const podName = pod.metadata?.name;
+        if (!podName) {
+            throw new Error('Pod has no name');
+        }
+        return monorepo.run(new PodExecOperation(task.interactive ? undefined : out), {
+            namespace,
+            podName,
+            container,
+            script: task.script,
+            interactive: task.interactive || false,
+            env: await monorepo.expand(task.vars || {}),
+        });
+    }
     async defaultExecutorFor(task) {
         const available = await this.availableExecutorsFor(task);
         if (available.length === 0) {
@@ -112,8 +142,18 @@ export class RunTasksOperation {
         if (task.executors) {
             return task.executors;
         }
-        return task.component && (await compose.isService(task.component))
-            ? [ExecutorType.container, ExecutorType.local]
-            : [ExecutorType.local];
+        // For tasks with a component, check what executors are available
+        if (task.component) {
+            const available = [ExecutorType.local];
+            // Container executor available if component is a docker-compose service
+            if (await compose.isService(task.component)) {
+                available.unshift(ExecutorType.container);
+            }
+            // Kubernetes executor is always available for component tasks
+            // (actual availability checked at runtime when --executor kubernetes is used)
+            available.push(ExecutorType.kubernetes);
+            return available;
+        }
+        return [ExecutorType.local];
     }
 }