@xec-sh/core
Version:
Universal shell execution engine
191 lines • 7.09 kB
JavaScript
import { attachConvenienceMethods } from './utils/convenience.js';
import { ExecutionEngine } from './core/execution-engine.js';
export { pipeUtils } from './utils/pipe.js';
export { isDisposable } from './types/disposable.js';
export { within, withinSync } from './utils/within.js';
export { DockerContainer } from './utils/docker-api.js';
export { LocalAdapter } from './adapters/local-adapter.js';
export { withTempDir, withTempFile } from './utils/temp.js';
export { RuntimeDetector } from './utils/runtime-detect.js';
export { ExecutionEngine } from './core/execution-engine.js';
export { DockerAdapter } from './adapters/docker-adapter.js';
export { parallel, ParallelEngine } from './utils/parallel.js';
export { SSHKeyValidator } from './utils/ssh-key-validator.js';
export { EnhancedEventEmitter } from './utils/event-emitter.js';
export { SecurePasswordHandler } from './utils/secure-password.js';
export { KubernetesAdapter } from './adapters/kubernetes-adapter.js';
export { RemoteDockerAdapter } from './adapters/remote-docker-adapter.js';
export { unifiedConfig, UnifiedConfigLoader } from './config/unified-config.js';
export function createCallableEngine(engine) {
return new Proxy(function () { }, {
apply(target, thisArg, [strings, ...values]) {
return engine.run(strings, ...values);
},
get(target, prop) {
const value = engine[prop];
if (typeof value === 'function') {
if (prop === 'ssh') {
return value.bind(engine);
}
if (prop === 'docker') {
return (...args) => {
const result = value.apply(engine, args);
if (result && typeof result.start === 'function') {
return result;
}
return createCallableEngine(result);
};
}
const chainableMethods = [
'with', 'k8s', 'remoteDocker',
'local', 'cd', 'env', 'timeout', 'shell', 'retry', 'defaults', 'raw'
];
if (chainableMethods.includes(prop)) {
return (...args) => {
const newEngine = value.apply(engine, args);
return createCallableEngine(newEngine);
};
}
return value.bind(engine);
}
return value;
}
});
}
let defaultEngine = null;
let defaultEngineInstance = null;
export const $ = new Proxy(function () { }, {
get(target, prop) {
if (!defaultEngine) {
defaultEngineInstance = attachConvenienceMethods(new ExecutionEngine());
defaultEngine = createCallableEngine(defaultEngineInstance);
}
return defaultEngine[prop];
},
apply(target, thisArg, args) {
if (!defaultEngine) {
defaultEngineInstance = attachConvenienceMethods(new ExecutionEngine());
defaultEngine = createCallableEngine(defaultEngineInstance);
}
return defaultEngine(...args);
}
});
let isConfiguringPromise = null;
export function configure(config) {
if (defaultEngineInstance) {
const oldInstance = defaultEngineInstance;
defaultEngineInstance = attachConvenienceMethods(new ExecutionEngine(config));
defaultEngine = createCallableEngine(defaultEngineInstance);
isConfiguringPromise = (async () => {
try {
if (typeof oldInstance.dispose === 'function') {
await oldInstance.dispose();
}
}
catch (error) {
}
finally {
isConfiguringPromise = null;
}
})();
}
else {
defaultEngineInstance = attachConvenienceMethods(new ExecutionEngine(config));
defaultEngine = createCallableEngine(defaultEngineInstance);
}
}
async function cleanupEngine() {
if (defaultEngineInstance) {
try {
if (typeof defaultEngineInstance.dispose === 'function') {
await defaultEngineInstance.dispose();
}
}
catch (error) {
}
finally {
defaultEngineInstance = null;
defaultEngine = null;
}
}
}
export async function dispose() {
if (isConfiguringPromise) {
await isConfiguringPromise;
}
await cleanupEngine();
}
let cleanupRegistered = false;
function registerCleanupHandlers() {
if (cleanupRegistered)
return;
cleanupRegistered = true;
process.on('exit', () => {
if (defaultEngineInstance) {
cleanupEngine().catch(() => {
});
}
});
process.on('SIGINT', async () => {
try {
await cleanupEngine();
}
catch {
}
finally {
if (process.env['NODE_ENV'] !== 'test') {
process.exit(0);
}
}
});
process.on('SIGTERM', async () => {
try {
await cleanupEngine();
}
catch {
}
finally {
if (process.env['NODE_ENV'] !== 'test') {
process.exit(0);
}
}
});
if (process.env['NODE_ENV'] !== 'test' && !process.env['JEST_WORKER_ID']) {
process.on('uncaughtException', async (error) => {
try {
await cleanupEngine();
}
catch {
}
finally {
process.exit(1);
}
});
process.on('unhandledRejection', async (reason, promise) => {
const isXecPromise = promise.__isXecPromise ||
(reason && reason.code === 'COMMAND_FAILED') ||
(reason && reason.constructor && reason.constructor.name === 'CommandError');
if (isXecPromise) {
return;
}
console.error('Unhandled Rejection at:', promise, 'reason:', reason);
try {
await cleanupEngine();
}
catch {
}
finally {
process.exit(1);
}
});
}
}
registerCleanupHandlers();
export { ConvenienceAPI, attachConvenienceMethods } from './utils/convenience.js';
export { RetryError, withExecutionRetry as retry } from './utils/retry-adapter.js';
export { DockerFluentAPI, DockerFluentBuildAPI } from './utils/docker-fluent-api.js';
export { SSHAdapter } from './adapters/ssh-adapter.js';
export { findSimilar, CommandRegistry, checkForCommandTypo, getCommandCompletions, defaultCommandRegistry } from './utils/suggestions.js';
export { DockerError, CommandError, TimeoutError, AdapterError, ExecutionError, ConnectionError, KubernetesError } from './core/error.js';
export { enhanceError, EnhancedCommandError, EnhancedTimeoutError, EnhancedExecutionError, EnhancedConnectionError } from './core/enhanced-error.js';
//# sourceMappingURL=index.js.map