@xec-sh/core/dist/utils/kubernetes-api.js

Universal shell execution engine

function createK8sPod(engine, adapter, name, namespace, baseOptions) {
    const exec = (strings, ...values) => {
        const k8sEngine = engine.with({
            adapter: 'kubernetes',
            adapterOptions: {
                type: 'kubernetes',
                ...baseOptions,
                pod: name,
                namespace
            }
        });
        return k8sEngine.run(strings, ...values);
    };
    const raw = (strings, ...values) => {
        const k8sEngine = engine.with({
            adapter: 'kubernetes',
            adapterOptions: {
                type: 'kubernetes',
                ...baseOptions,
                pod: name,
                namespace
            }
        });
        return k8sEngine.raw(strings, ...values);
    };
    return {
        name,
        namespace,
        exec,
        raw,
        async portForward(localPort, remotePort) {
            const pf = await adapter.portForward(name, localPort, remotePort, { namespace });
            await pf.open();
            return pf;
        },
        async portForwardDynamic(remotePort) {
            const pf = await adapter.portForward(name, 0, remotePort, {
                namespace,
                dynamicLocalPort: true
            });
            await pf.open();
            return pf;
        },
        async logs(options) {
            const args = ['logs', '-n', namespace];
            if (options?.container) {
                args.push('-c', options.container);
            }
            if (options?.tail !== undefined) {
                args.push('--tail', String(options.tail));
            }
            if (options?.previous) {
                args.push('--previous');
            }
            if (options?.timestamps) {
                args.push('--timestamps');
            }
            args.push(name);
            const result = await adapter.executeKubectl(args, { throwOnNonZeroExit: true });
            return result.stdout;
        },
        async streamLogs(onData, options) {
            return adapter.streamLogs(name, onData, {
                namespace,
                ...options
            });
        },
        async follow(onData, options) {
            return this.streamLogs(onData, { ...options, follow: true });
        },
        async copyTo(localPath, remotePath, container) {
            const podPath = container ? `${name}:${remotePath} -c ${container}` : `${name}:${remotePath}`;
            await adapter.copyFiles(localPath, podPath, {
                namespace,
                container,
                direction: 'to'
            });
        },
        async copyFrom(remotePath, localPath, container) {
            const podPath = container ? `${name}:${remotePath} -c ${container}` : `${name}:${remotePath}`;
            await adapter.copyFiles(podPath, localPath, {
                namespace,
                container,
                direction: 'from'
            });
        }
    };
}
export function createK8sExecutionContext(engine, k8sOptions) {
    const adapter = engine.getAdapter('kubernetes');
    if (!adapter) {
        throw new Error('Kubernetes adapter not available');
    }
    const exec = (strings, ...values) => {
        if (!k8sOptions.pod) {
            throw new Error('Pod must be specified for direct execution');
        }
        const k8sEngine = engine.with({
            adapter: 'kubernetes',
            adapterOptions: {
                type: 'kubernetes',
                pod: k8sOptions.pod,
                ...(k8sOptions.namespace && { namespace: k8sOptions.namespace }),
                ...(k8sOptions.container && { container: k8sOptions.container }),
                ...(k8sOptions.execFlags && { execFlags: k8sOptions.execFlags }),
                ...(k8sOptions.tty !== undefined && { tty: k8sOptions.tty }),
                ...(k8sOptions.stdin !== undefined && { stdin: k8sOptions.stdin })
            }
        });
        return k8sEngine.run(strings, ...values);
    };
    const raw = (strings, ...values) => {
        if (!k8sOptions.pod) {
            throw new Error('Pod must be specified for direct execution');
        }
        const k8sEngine = engine.with({
            adapter: 'kubernetes',
            adapterOptions: {
                type: 'kubernetes',
                pod: k8sOptions.pod,
                ...(k8sOptions.namespace && { namespace: k8sOptions.namespace }),
                ...(k8sOptions.container && { container: k8sOptions.container }),
                ...(k8sOptions.execFlags && { execFlags: k8sOptions.execFlags }),
                ...(k8sOptions.tty !== undefined && { tty: k8sOptions.tty }),
                ...(k8sOptions.stdin !== undefined && { stdin: k8sOptions.stdin })
            }
        });
        return k8sEngine.raw(strings, ...values);
    };
    const context = Object.assign(exec, {
        exec,
        raw,
        pod(name) {
            const namespace = k8sOptions.namespace || 'default';
            return createK8sPod(engine, adapter, name, namespace, k8sOptions);
        }
    });
    return context;
}
//# sourceMappingURL=kubernetes-api.js.map