hostctl 0.1.32

package/dist/bin/hostctl.js

@@ -0,0 +1,4962 @@
+#!/usr/bin/env -S npx tsx
+
+// src/cli.ts
+import process4 from "process";
+import * as cmdr from "commander";
+
+// src/app.ts
+import process3 from "process";
+import * as fs6 from "fs";
+import { homedir as homedir3 } from "os";
+
+// src/handlebars.ts
+import Handlebars from "handlebars";
+Handlebars.registerHelper("join", function(items, block) {
+  var delimiter = block.hash.delimiter || ",", start = block.hash.start || 0, len = items ? items.length : 0, end = block.hash.end || len, out = "";
+  if (end > len) end = len;
+  if ("function" === typeof block) {
+    for (let i = start; i < end; i++) {
+      if (i > start) out += delimiter;
+      if ("string" === typeof items[i]) out += items[i];
+      else out += block(items[i]);
+    }
+    return out;
+  } else {
+    return [].concat(items).slice(start, end).join(delimiter);
+  }
+});
+
+// src/config.ts
+import * as fs4 from "fs";
+
+// src/config-file.ts
+import fsa from "fs/promises";
+import "fs";
+import { globSync as globSync2 } from "glob";
+import { bech32 } from "@scure/base";
+import "rambda";
+import yaml from "js-yaml";
+
+// src/flex/function.ts
+var GeneratorFunction = function* () {
+}.constructor;
+var MethodBag = class {
+  methods;
+  staticMethods;
+  constructor() {
+    this.methods = /* @__PURE__ */ new Map();
+    this.staticMethods = /* @__PURE__ */ new Map();
+  }
+  registerUncurriedFns(fnBag) {
+    Object.entries(fnBag).forEach(([functionName, functionObj]) => {
+      this.methods.set(functionName, [functionObj, 1]);
+    });
+  }
+  registerCurriedFns(fnBag) {
+    Object.entries(fnBag).forEach(([functionName, functionObj]) => {
+      this.methods.set(functionName, [functionObj, 2]);
+    });
+  }
+  registerStatic(fnBag) {
+    Object.entries(fnBag).forEach(([functionName, functionObj]) => {
+      this.staticMethods.set(functionName, functionObj);
+    });
+  }
+  lookup(fnName) {
+    const pair = this.methods.get(fnName);
+    if (!pair) {
+      return void 0;
+    }
+    return pair;
+  }
+  lookupStatic(fnName) {
+    const fn = this.staticMethods.get(fnName);
+    if (!fn) {
+      return void 0;
+    }
+    return fn;
+  }
+};
+function buildWrapperProxy() {
+  const methods = new MethodBag();
+  function func(wrappedValue) {
+    return new Proxy(wrappedValue, {
+      get(target, property, receiver) {
+        const fnArityPair = methods.lookup(property.toString());
+        if (fnArityPair === void 0) {
+          return Reflect.get(target, property, receiver);
+        }
+        const [fn, arity] = fnArityPair;
+        return function(...args) {
+          if (arity === 1) {
+            return fn.call(receiver, target);
+          } else {
+            return fn.apply(receiver, args)(target);
+          }
+        };
+      }
+    });
+  }
+  Object.assign(func, {
+    registerUncurriedFns: (fnBag) => {
+      methods.registerUncurriedFns(fnBag);
+    },
+    registerCurriedFns: (fnBag) => {
+      methods.registerCurriedFns(fnBag);
+    },
+    registerStatic: (fnBag) => {
+      methods.registerStatic(fnBag);
+    }
+  });
+  const funcWithMethods = func;
+  return new Proxy(funcWithMethods, {
+    get(target, property, receiver) {
+      const fn = methods.lookupStatic(property.toString());
+      if (fn === void 0) {
+        return Reflect.get(target, property, receiver);
+      }
+      return fn;
+    }
+  });
+}
+function curry(func) {
+  return function curried(...args) {
+    if (args.length >= func.length) {
+      return func.apply(this, args);
+    } else {
+      return function(...args2) {
+        return curried.apply(this, args.concat(args2));
+      };
+    }
+  };
+}
+function identity(val) {
+  return val;
+}
+function parameters(func) {
+  const ARROW = true;
+  const FUNC_ARGS = ARROW ? /^(function)?\s*[^\(]*\(\s*([^\)]*)\)/m : /^(function)\s*[^\(]*\(\s*([^\)]*)\)/m;
+  const FUNC_ARG_SPLIT = /,/;
+  const FUNC_ARG = /^\s*(_?)(.+?)\1\s*$/;
+  const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+  return ((func || "").toString().replace(STRIP_COMMENTS, "").match(FUNC_ARGS) || ["", "", ""])[2].split(FUNC_ARG_SPLIT).map(function(arg) {
+    return arg.replace(FUNC_ARG, function(all, underscore, name) {
+      return name.split("=")[0].trim();
+    });
+  }).filter(String);
+}
+function thread(...args) {
+  return function(firstArg = void 0) {
+    let pipeline = args;
+    if (firstArg !== void 0) {
+      pipeline.unshift(firstArg);
+    }
+    return pipeline.reduce((arg, fn) => fn(arg));
+  };
+}
+function threadR(...fns) {
+  return function(firstArg = void 0) {
+    let pipeline = fns;
+    if (firstArg !== void 0) {
+      pipeline.push(firstArg);
+    }
+    return pipeline.reduceRight((arg, fn) => fn(arg));
+  };
+}
+var F = buildWrapperProxy();
+F.registerUncurriedFns({ parameters });
+F.registerStatic({
+  curry,
+  identity,
+  parameters,
+  thread,
+  threadR
+});
+
+// src/flex/protocol.ts
+import { Mutex } from "async-mutex";
+
+// src/flex/type.ts
+import { inspect as nodeInspect } from "util";
+var End = class _End {
+  static _instance;
+  constructor() {
+  }
+  static get instance() {
+    if (!this._instance) {
+      this._instance = new _End();
+    }
+    return this._instance;
+  }
+};
+var Undefined = class {
+};
+var Null = class {
+};
+var Class = class {
+};
+function inspect(valueToInspect) {
+  return nodeInspect(valueToInspect, { showProxy: true });
+}
+function isA(predicateType) {
+  return function(value) {
+    return value instanceof predicateType || kind(value) === predicateType || value != null && (value.constructor === predicateType || predicateType.name === "Object" && typeof value === "object");
+  };
+}
+function isAbsent(value) {
+  return value === null || value === void 0;
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+var BUILT_IN_CONSTRUCTORS = [
+  String,
+  Number,
+  Boolean,
+  Array,
+  Object,
+  Function,
+  Date,
+  RegExp,
+  Map,
+  Set,
+  Error,
+  Promise,
+  Symbol,
+  BigInt
+];
+function isClass(fn) {
+  if (typeof fn !== "function") {
+    return false;
+  }
+  if (/^class\s/.test(Function.prototype.toString.call(fn))) {
+    return true;
+  }
+  if (BUILT_IN_CONSTRUCTORS.includes(fn)) {
+    return true;
+  }
+  return false;
+}
+function isObject(val) {
+  return val !== null && (typeof val === "function" || typeof val === "object");
+}
+function isPresent(value) {
+  return !isAbsent(value);
+}
+function kind(value) {
+  if (value === null) {
+    return Null;
+  }
+  switch (typeof value) {
+    case "undefined":
+      return Undefined;
+    case "boolean":
+      return Boolean;
+    case "number":
+      return Number;
+    case "bigint":
+      return BigInt;
+    case "string":
+      return String;
+    case "symbol":
+      return Symbol;
+    case "function":
+      if (isClass(value)) {
+        return Class;
+      } else {
+        return value.constructor;
+      }
+      break;
+    case "object":
+      return value.constructor;
+      break;
+  }
+}
+function klass(objOrClass) {
+  if (isClass(objOrClass)) {
+    return Function;
+  }
+  const proto = Object.getPrototypeOf(objOrClass);
+  if (proto === null || proto === void 0) {
+    return void 0;
+  }
+  return proto.constructor;
+}
+function superclass(objOrClass) {
+  if (objOrClass === Object) {
+    return null;
+  }
+  if (isClass(objOrClass)) {
+    const proto = Object.getPrototypeOf(objOrClass);
+    if (proto === Function.prototype) {
+      return Object;
+    }
+    return proto;
+  } else {
+    const instanceProto = Object.getPrototypeOf(objOrClass);
+    if (instanceProto === null || instanceProto === void 0) {
+      return void 0;
+    }
+    const superProto = Object.getPrototypeOf(instanceProto);
+    if (superProto === null || superProto === void 0) {
+      return superProto === null ? null : void 0;
+    }
+    return superProto.constructor;
+  }
+}
+var Value = class {
+  constructor(value) {
+    this.value = value;
+  }
+  isWrappedValue = true;
+  //   isA(predicateType: any): boolean {
+  //     return isA(predicateType)(this.value);
+  //   }
+  //   isAbsent(value: any) {
+  //     return isAbsent(value);
+  //   }
+  //   isClass(value: unknown) {
+  //     isClass(value);
+  //   }
+  //   isPresent(value: any) {
+  //     return isPresent(value);
+  //   }
+  //   isError(value: unknown): value is Error {
+  //     return isError(value);
+  //   }
+  //   inspect() {
+  //     return inspect(this.value);
+  //   }
+  //   kind() {
+  //     return kind(this.value);
+  //   }
+  //   klass() {
+  //     return klass(this.value);
+  //   }
+  //   superclass() {
+  //     return superclass(this.value);
+  //   }
+};
+function buildValueWrapperProxy() {
+  const methods = new MethodBag();
+  function func(wrappedValue) {
+    if (!isObject(wrappedValue)) {
+      wrappedValue = new Value(wrappedValue);
+    }
+    return new Proxy(wrappedValue, {
+      get(target, property, receiver) {
+        const fnArityPair = methods.lookup(property.toString());
+        if (fnArityPair === void 0) {
+          if (target.isWrappedValue) {
+            return Reflect.get(target.value, property, receiver);
+          } else {
+            return Reflect.get(target, property, receiver);
+          }
+        }
+        const [fn, arity] = fnArityPair;
+        return function(...args) {
+          if (arity === 1) {
+            if (target.isWrappedValue) {
+              return fn.call(receiver, target.value);
+            } else {
+              return fn.call(receiver, target);
+            }
+          } else {
+            if (target.isWrappedValue) {
+              return fn.apply(receiver, args)(target.value);
+            } else {
+              return fn.apply(receiver, args)(target);
+            }
+          }
+        };
+      }
+    });
+  }
+  Object.assign(func, {
+    registerUncurriedFns(fnBag) {
+      return methods.registerUncurriedFns(fnBag);
+    },
+    registerCurriedFns(fnBag) {
+      return methods.registerCurriedFns(fnBag);
+    },
+    registerStatic(fnBag) {
+      return methods.registerStatic(fnBag);
+    }
+  });
+  const funcWithMethods = func;
+  return new Proxy(funcWithMethods, {
+    get(target, property, receiver) {
+      const fn = methods.lookupStatic(property.toString());
+      if (fn === void 0) {
+        return Reflect.get(target, property, receiver);
+      }
+      return fn;
+    }
+  });
+}
+var V = buildValueWrapperProxy();
+V.registerUncurriedFns({
+  isAbsent,
+  isClass,
+  isDefined,
+  isObject,
+  isPresent,
+  inspect,
+  kind,
+  klass,
+  superclass
+});
+V.registerCurriedFns({ isA });
+V.registerStatic({
+  isA,
+  isAbsent,
+  isClass,
+  isDefined,
+  isObject,
+  isPresent,
+  inspect,
+  kind,
+  klass,
+  superclass
+});
+
+// src/flex/protocol.ts
+var NamedImplementations = class {
+  constructor(impls = /* @__PURE__ */ new Map(), defaultImpl = "") {
+    this.impls = impls;
+    this.defaultImpl = defaultImpl;
+  }
+  register(name, implClass, makeDefault = false) {
+    if (this.impls.size === 0 || makeDefault) {
+      this.setDefaultImpl(name);
+    }
+    this.impls.set(name, implClass);
+  }
+  get(name) {
+    return this.impls.get(name || this.defaultImpl);
+  }
+  setDefaultImpl(name) {
+    this.defaultImpl = name;
+  }
+};
+var ImplementationRegistry = class {
+  constructor(name) {
+    this.name = name;
+  }
+  // implementations is a Map of (type constructor function => ProtocolImplGroup) pairs
+  // It stores all the named implementations of the typeclass/protocol associated with the type stored in the key of the map
+  implementations = /* @__PURE__ */ new Map();
+  register(classConstructor, implClass, makeDefault = false) {
+    let protocolImplGroup = this.implementations.get(classConstructor);
+    if (!protocolImplGroup) {
+      protocolImplGroup = new NamedImplementations();
+      this.implementations.set(classConstructor, protocolImplGroup);
+    }
+    protocolImplGroup.register(implClass.name, implClass, makeDefault);
+  }
+  use(classConstructor, implClass) {
+    this.register(classConstructor, implClass, true);
+  }
+  clear() {
+    this.implementations.clear();
+  }
+  // returns a class object that implements the typeclass/protocol - this is an implementation of the typeclass/protocol for a given type
+  get(classConstructor, name) {
+    const protocolImplGroup = this.implementations.get(classConstructor);
+    if (!protocolImplGroup) {
+      throw new Error(`Protocol ${this.name} not implemented by ${classConstructor}`);
+    }
+    const impl = protocolImplGroup.get(name);
+    if (!impl) {
+      throw new Error(
+        `Named implementation '${name || protocolImplGroup.defaultImpl}' of protocol ${this.name} not implemented by ${classConstructor}`
+      );
+    }
+    return impl;
+  }
+};
+var Protocol = class _Protocol {
+  static protocolRegistryLock;
+  static registry;
+  static {
+    _Protocol.protocolRegistryLock = _Protocol.protocolRegistryLock || new Mutex();
+    _Protocol.registry = _Protocol.registry || /* @__PURE__ */ new Map();
+  }
+  static getTypeclass() {
+    if (this.registry.has(this.name)) {
+      return this.registry.get(this.name);
+    } else {
+      const newTypeclass = new ImplementationRegistry(this.name);
+      this.registry.set(this.name, newTypeclass);
+      return newTypeclass;
+    }
+  }
+  // static getTypeclass(): ImplementationRegistry {
+  //   if (global.protocolRegistry.has(this.name)) {
+  //     return global.protocolRegistry.get(this.name) as ImplementationRegistry;
+  //   } else {
+  //     const newTypeclass = new ImplementationRegistry(this.name);
+  //     global.protocolRegistry.set(this.name, newTypeclass);
+  //     return newTypeclass;
+  //   }
+  // }
+  static async register(classConstructor, implClass, makeDefault = false) {
+    await _Protocol.protocolRegistryLock.runExclusive(async () => {
+      let typeclass = this.getTypeclass();
+      typeclass.register(classConstructor, implClass, makeDefault);
+    });
+  }
+  static async use(classConstructor, implClass) {
+    await _Protocol.protocolRegistryLock.runExclusive(async () => {
+      let typeclass = this.getTypeclass();
+      typeclass.use(classConstructor, implClass);
+    });
+  }
+  // returns a class object that implements the typeclass - this is an implementation of the typeclass for a given type
+  static get(classConstructor, name) {
+    const typeclass = this.getTypeclass();
+    return typeclass.get(classConstructor, name);
+  }
+  // returns an instance of the class that implements the typeclass
+  // For example, Enumerable.for([1,2,3]) returns a new instance of the EnumerableArray implementation of the
+  // Enumerable typeclass on the Array type, initialized with [1,2,3] in the constructor
+  static for(instance, explicitImplClass) {
+    let finalImplConstructor;
+    if (explicitImplClass) {
+      finalImplConstructor = explicitImplClass;
+    } else {
+      finalImplConstructor = this.get(
+        kind(instance)
+        // No name needed here for the default lookup via this.get(typeConstructor)
+      );
+    }
+    return new finalImplConstructor(instance);
+  }
+};
+
+// src/flex/compactable.ts
+var Compactable = class extends Protocol {
+  constructor(self) {
+    super();
+    this.self = self;
+  }
+  compact(omit) {
+    throw new Error("not implemented");
+  }
+};
+function compact(omit) {
+  return function(compactableVal) {
+    return Compactable.for(compactableVal).compact(omit);
+  };
+}
+
+// src/flex/enumerator.ts
+var Enumerator = class _Enumerator {
+  constructor(iterator) {
+    this.iterator = iterator;
+  }
+  static for(iterator) {
+    return new _Enumerator(iterator);
+  }
+  all(predFn) {
+    for (const elem of this) {
+      if (!predFn(elem)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  any(predFn) {
+    for (const elem of this) {
+      if (predFn(elem)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  each(visitorFn) {
+    for (const e of this) {
+      visitorFn(e);
+    }
+  }
+  first(predFn = identity, defaultIfAbsesnt = void 0) {
+    for (const e of this) {
+      if (predFn(e)) return e;
+    }
+    return defaultIfAbsesnt;
+  }
+  map(mapFn) {
+    function* gen(iterator) {
+      for (const e of iterator) {
+        yield mapFn(e);
+      }
+    }
+    return _Enumerator.for(gen(this));
+  }
+  // per https://typescript.tv/hands-on/all-you-need-to-know-about-iterators-and-generators/#the-iterator-protocol
+  // implement the IterableIterator interface by implementing [Symbol.iterator]() and next()
+  [Symbol.iterator]() {
+    return this;
+  }
+  // per https://typescript.tv/hands-on/all-you-need-to-know-about-iterators-and-generators/#the-iterator-protocol
+  // implement the IterableIterator interface by implementing [Symbol.iterator]() and next()
+  next() {
+    const val = this.produce();
+    if (val instanceof End) {
+      return { done: true, value: End.instance };
+    }
+    return { done: false, value: val };
+  }
+  // this produces either the next value in the Enumerator, or it returns End
+  produce() {
+    const val = this.iterator.next();
+    if (val.done) {
+      return End.instance;
+    }
+    return val.value;
+  }
+  select(predFn) {
+    function* gen(iterator) {
+      for (const e of iterator) {
+        if (predFn(e)) yield e;
+      }
+    }
+    return _Enumerator.for(gen(this));
+  }
+  toArray() {
+    return Array.from(this);
+  }
+  toMap(kvMapFn) {
+    return new Map(this.map(kvMapFn));
+  }
+  toSet() {
+    return new Set(this);
+  }
+};
+
+// src/flex/enumerable.ts
+var Enumerable = class extends Protocol {
+  constructor(self) {
+    super();
+    this.self = self;
+  }
+  static each = each;
+  each(visitorFn) {
+    return this.toEnumerator().each(visitorFn);
+  }
+  *emit() {
+    throw new Error("emit not implemented");
+  }
+  toArray() {
+    return this.toEnumerator().toArray();
+  }
+  toEnumerator() {
+    return Enumerator.for(this.emit());
+  }
+  toSet() {
+    return this.toEnumerator().toSet();
+  }
+};
+function each(visitorFn) {
+  return function(enumerableVal, implClass) {
+    return Enumerable.for(enumerableVal, implClass).each(visitorFn);
+  };
+}
+
+// src/flex/mappable.ts
+var Mappable = class extends Protocol {
+  constructor(self) {
+    super();
+    this.self = self;
+  }
+  map(mapFn) {
+    throw new Error("not implemented");
+  }
+};
+function map(mapFn) {
+  return function(mappableVal, explicitImplClass) {
+    return Mappable.for(mappableVal, explicitImplClass).map(mapFn);
+  };
+}
+var AsyncMappable = class extends Protocol {
+  constructor(self) {
+    super();
+    this.self = self;
+  }
+  async map(mapFn) {
+    throw new Error("not implemented");
+  }
+};
+function asyncMap(mapFn) {
+  return async function(mappableVal, explicitImplClass) {
+    return await AsyncMappable.for(mappableVal, explicitImplClass).map(mapFn);
+  };
+}
+
+// src/flex/selectable.ts
+var Selectable = class extends Protocol {
+  constructor(self) {
+    super();
+    this.self = self;
+  }
+  select(predFn) {
+    throw new Error("not implemented");
+  }
+};
+function select(predFn) {
+  return function(selectableVal, implClass) {
+    return Selectable.for(selectableVal, implClass).select(predFn);
+  };
+}
+
+// src/flex/array-protocols.ts
+var CompactableArray = class extends Compactable {
+  compact(omit) {
+    omit ||= [null, void 0];
+    const omitSet = toSet(omit);
+    const newArr = [];
+    for (const val of this.self) {
+      if (!omitSet.has(val)) {
+        newArr.push(val);
+      }
+    }
+    return newArr;
+  }
+};
+await Compactable.register(Array, CompactableArray, true);
+var MappableArray = class extends Mappable {
+  map(mapFn) {
+    return this.self.map(mapFn);
+  }
+};
+await Mappable.register(Array, MappableArray, true);
+var AsyncMappableArray = class extends AsyncMappable {
+  async map(mapFn) {
+    const arr = [];
+    for await (const v of this.self) {
+      const mappedValue = await mapFn(v);
+      arr.push(mappedValue);
+    }
+    return arr;
+  }
+};
+await AsyncMappable.register(Array, AsyncMappableArray, true);
+var EnumerableArray = class extends Enumerable {
+  *emit() {
+    for (const e of this.self) yield e;
+  }
+};
+await Enumerable.register(Array, EnumerableArray, true);
+var SelectableArray = class extends Selectable {
+  select(predFn) {
+    return this.self.filter(predFn);
+  }
+};
+await Selectable.register(Array, SelectableArray, true);
+
+// src/flex/map.ts
+function each2(eachFn) {
+  return function(map6) {
+    map6.forEach((value, key) => {
+      eachFn([key, value]);
+    });
+  };
+}
+function isEmpty(map6) {
+  return map6.size === 0;
+}
+function keys(map6) {
+  return Array.from(map6.keys());
+}
+function map2(mapFn) {
+  return function(map6) {
+    const m = /* @__PURE__ */ new Map();
+    map6.forEach((value, key) => {
+      const [newKey, newValue] = mapFn([key, value]);
+      m.set(newKey, newValue);
+    });
+    return m;
+  };
+}
+function select2(predFn) {
+  return function(map6) {
+    const newMap = /* @__PURE__ */ new Map();
+    map6.forEach((value, key) => {
+      if (predFn([key, value])) {
+        newMap.set(key, value);
+      }
+    });
+    return newMap;
+  };
+}
+function toObject(map6) {
+  return Object.fromEntries(map6.entries());
+}
+function values(map6) {
+  return Array.from(map6.values());
+}
+var M = buildWrapperProxy();
+M.registerUncurriedFns({ isEmpty, keys, toObject, values });
+M.registerCurriedFns({ each: each2, map: map2, select: select2 });
+M.registerStatic({
+  each: each2,
+  isEmpty,
+  keys,
+  map: map2,
+  select: select2,
+  toObject,
+  values
+});
+
+// src/flex/map-protocols.ts
+var MapToMap = class extends Mappable {
+  map(mapFn) {
+    const m = /* @__PURE__ */ new Map();
+    this.self.forEach((value, key) => {
+      const [newKey, newValue] = mapFn([key, value]);
+      m.set(newKey, newValue);
+    });
+    return m;
+  }
+};
+var MapToArray = class extends Mappable {
+  map(mapFn) {
+    const arr = [];
+    this.self.forEach((value, key) => {
+      const mappedValue = mapFn([key, value]);
+      arr.push(mappedValue);
+    });
+    return arr;
+  }
+};
+await Mappable.register(Map, MapToMap, true);
+await Mappable.register(Map, MapToArray);
+var AsyncMapToMap = class extends AsyncMappable {
+  async map(mapFn) {
+    const m = /* @__PURE__ */ new Map();
+    for await (const [key, value] of this.self) {
+      const [newKey, newValue] = await mapFn([key, value]);
+      m.set(newKey, newValue);
+    }
+    return m;
+  }
+};
+var AsyncMapToArray = class extends AsyncMappable {
+  async map(mapFn) {
+    const arr = [];
+    for await (const [key, value] of this.self) {
+      const mappedValue = await mapFn([key, value]);
+      arr.push(mappedValue);
+    }
+    return arr;
+  }
+};
+await AsyncMappable.register(Map, AsyncMapToMap, true);
+await AsyncMappable.register(Map, AsyncMapToArray);
+var EnumerablePair = class extends Enumerable {
+  *emit() {
+    for (const [k, v] of this.self.entries()) {
+      yield [k, v];
+    }
+  }
+};
+var EnumerableKey = class extends Enumerable {
+  *emit() {
+    for (const k of this.self.keys()) {
+      yield k;
+    }
+  }
+};
+var EnumerableValue = class extends Enumerable {
+  *emit() {
+    for (const v of this.self.values()) {
+      yield v;
+    }
+  }
+};
+await Enumerable.register(Map, EnumerablePair, true);
+await Enumerable.register(Map, EnumerableKey);
+await Enumerable.register(Map, EnumerableValue);
+var SelectableMap = class extends Selectable {
+  select(predFn) {
+    return M(this.self).select(predFn);
+  }
+};
+await Selectable.register(Map, SelectableMap, true);
+
+// src/flex/object.ts
+function each3(eachFn) {
+  return function(object) {
+    Object.entries(object).forEach((kvPair) => {
+      eachFn(kvPair);
+    });
+  };
+}
+function keys2(object) {
+  return Object.keys(object);
+}
+function map3(mapFn) {
+  return function(object) {
+    const obj = {};
+    Object.entries(object).forEach((kvPair) => {
+      const [newKey, newValue] = mapFn(kvPair);
+      obj[newKey] = newValue;
+    });
+    return obj;
+  };
+}
+function pick(keysToPick) {
+  return select3(([key, _]) => keysToPick.has(key));
+}
+function select3(predFn) {
+  return function(object) {
+    const obj = {};
+    Object.entries(object).forEach((kvPair) => {
+      if (predFn(kvPair)) {
+        const [k, v] = kvPair;
+        obj[k] = v;
+      }
+    });
+    return obj;
+  };
+}
+function toMap(object) {
+  return new Map(Object.entries(object));
+}
+function values2(object) {
+  return Object.values(object);
+}
+var O = buildWrapperProxy();
+O.registerUncurriedFns({ keys: keys2, toMap, values: values2 });
+O.registerCurriedFns({ each: each3, map: map3, pick, select: select3 });
+O.registerStatic({
+  each: each3,
+  // (eachFn)(obj) => ...
+  keys: keys2,
+  // (obj) => ...
+  map: map3,
+  pick,
+  select: select3,
+  toMap,
+  values: values2
+});
+
+// src/flex/object-protocols.ts
+var SelectableObject = class extends Selectable {
+  select(predFn) {
+    return O(this.self).select(predFn);
+  }
+};
+await Selectable.register(Object, SelectableObject, true);
+
+// src/flex/path.ts
+import { copyFile, cp } from "fs/promises";
+import { existsSync, lstatSync } from "fs";
+import { win32, posix } from "path";
+import { homedir } from "os";
+import { globSync } from "glob";
+
+// src/flex/platform.ts
+import { platform as nodePlatform } from "process";
+function isWindows() {
+  return platform() == "win32";
+}
+function platform() {
+  return nodePlatform;
+}
+
+// src/flex/string.ts
+function isEmpty2(str) {
+  return str.length == 0;
+}
+function isNumeric(str) {
+  if (typeof str !== "string") return false;
+  const trimmedStr = str.trim();
+  if (trimmedStr === "") return false;
+  const num = Number(trimmedStr);
+  return !isNaN(num) && isFinite(num) && String(num) === trimmedStr;
+}
+function matches(regexp) {
+  const globalRegex = regexp.global ? regexp : new RegExp(regexp.source, regexp.flags + "g");
+  return function(str) {
+    const matches2 = [...str.matchAll(globalRegex)];
+    if (matches2.length == 0) return null;
+    return matches2;
+  };
+}
+var StringProxy = class {
+  constructor(str) {
+    this.str = str;
+  }
+  // Add common string properties/methods for TypeScript
+  get length() {
+    return this.str.length;
+  }
+  toUpperCase() {
+    return this.str.toUpperCase();
+  }
+  isEmpty() {
+    return isEmpty2(this.str);
+  }
+  isNumeric() {
+    return isNumeric(this.str);
+  }
+  matches(regexp) {
+    return matches(regexp)(this.str);
+  }
+  trimPrefix(prefix) {
+    if (this.str.startsWith(prefix)) {
+      return this.str.slice(prefix.length);
+    }
+    return this.str;
+  }
+  trimSuffix(suffix) {
+    if (this.str.endsWith(suffix)) {
+      return this.str.slice(0, this.str.length - suffix.length);
+    }
+    return this.str;
+  }
+};
+var Str = function(str) {
+  const handler = {
+    get(target, property, receiver) {
+      const propOnTarget = Reflect.get(target, property, receiver);
+      if (V.isPresent(propOnTarget)) {
+        return propOnTarget;
+      }
+      const underlyingString = target.str;
+      const valueFromPrimitive = underlyingString[property];
+      if (typeof valueFromPrimitive === "function") {
+        return valueFromPrimitive.bind(underlyingString);
+      }
+      return valueFromPrimitive;
+    }
+  };
+  return new Proxy(new StringProxy(str), handler);
+};
+Object.assign(Str, {
+  isEmpty: isEmpty2,
+  isNumeric,
+  matches
+});
+
+// src/flex/range.ts
+var Range = class _Range {
+  constructor(start, end, inclusive = true) {
+    this.start = start;
+    this.end = end;
+    this.inclusive = inclusive;
+  }
+  static new(start, end, inclusive = true) {
+    return new _Range(start, end, inclusive);
+  }
+  each(visitorFn) {
+    const exclusiveEnd = this.inclusive ? this.end + 1 : this.end;
+    for (let i = this.start; i < exclusiveEnd; i++) {
+      visitorFn(i);
+    }
+  }
+  equals(other) {
+    if (!(other instanceof _Range)) {
+      return false;
+    }
+    return this.start === other.start && this.end === other.end && this.inclusive === other.inclusive;
+  }
+  map(mapFn) {
+    const arr = [];
+    this.each((num) => {
+      arr.push(mapFn(num));
+    });
+    return arr;
+  }
+  toArray() {
+    return Enumerable.for(this).toArray();
+  }
+};
+
+// src/flex/equal.ts
+var Equal = class extends Protocol {
+  constructor(self) {
+    super();
+    this.self = self;
+  }
+  equal(val) {
+    throw new Error("equal not implemented");
+  }
+  notEqual(val) {
+    return !this.equal(val);
+  }
+  eq(val) {
+    return this.equal(val);
+  }
+  neq(val) {
+    return this.notEqual(val);
+  }
+};
+
+// src/flex/path.ts
+var Path = class _Path {
+  constructor(path3, isWindowsPath = isWindows()) {
+    this.path = path3;
+    this.isWindowsPath = isWindowsPath;
+  }
+  static new(path3, isWindowsPath = isWindows()) {
+    if (path3 instanceof _Path) {
+      return path3;
+    }
+    return new _Path(path3, isWindowsPath);
+  }
+  static cwd() {
+    return _Path.new(process.cwd());
+  }
+  static homeDir() {
+    return _Path.new(homedir());
+  }
+  static sep(isWindowsPath = isWindows()) {
+    if (isWindowsPath) {
+      return win32.sep;
+    } else {
+      return posix.sep;
+    }
+  }
+  absolute() {
+    return this.resolve();
+  }
+  ancestors() {
+    if (this.isRoot()) {
+      return [];
+    }
+    const ancestors = [];
+    let current = this.directory();
+    while (true) {
+      ancestors.push(current);
+      if (current.isRoot()) {
+        break;
+      }
+      current = current.parent();
+    }
+    return ancestors;
+  }
+  basename(suffix) {
+    if (this.isWindowsPath) {
+      return this.build(win32.basename(this.path, suffix));
+    } else {
+      return this.build(posix.basename(this.path, suffix));
+    }
+  }
+  build(path3) {
+    return new _Path(path3, this.isWindowsPath);
+  }
+  // returns the path to the destination on success; null otherwise
+  async copy(destPath, mode) {
+    destPath = _Path.new(destPath).normalize();
+    try {
+      if (this.isDirectory()) {
+        await cp(this.toString(), destPath.toString(), { mode, recursive: true });
+      } else {
+        await copyFile(this.toString(), destPath.toString(), mode);
+      }
+      return destPath;
+    } catch (e) {
+      return null;
+    }
+  }
+  dirContains(filename) {
+    return this.isDirectory() && this.glob(filename).length > 0;
+  }
+  directory() {
+    return this.absolute().dirname();
+  }
+  // given a path like "bar/bas", this method converts the path to an absolute path (e.g. "/foo/bar/bas"),
+  // and then returns the directory tree as an array of the form ["foo", "bar", "bas"]
+  directorySegments() {
+    return this.absolute().dirname().split();
+  }
+  dirname() {
+    if (this.isWindowsPath) {
+      return this.build(win32.dirname(this.path));
+    } else {
+      return this.build(posix.dirname(this.path));
+    }
+  }
+  equals(other) {
+    if (!(other instanceof _Path)) {
+      return false;
+    }
+    return this.path === other.path && this.isWindowsPath === other.isWindowsPath;
+  }
+  exists() {
+    return existsSync(this.path);
+  }
+  ext() {
+    return this.parse().ext;
+  }
+  glob(pattern) {
+    const cwd = this.absolute().toString();
+    return globSync(pattern, { cwd }).map((path3) => this.build(path3));
+  }
+  isAbsolute() {
+    if (this.isWindowsPath) {
+      return win32.isAbsolute(this.path);
+    } else {
+      return posix.isAbsolute(this.path);
+    }
+  }
+  isDirectory() {
+    return this.exists() && lstatSync(this.path).isDirectory();
+  }
+  isFile() {
+    return this.exists() && lstatSync(this.path).isFile();
+  }
+  isPosix() {
+    return !this.isWindowsPath;
+  }
+  isRoot() {
+    return this.parse().root === this.normalize().toString();
+  }
+  isWindows() {
+    return this.isWindowsPath;
+  }
+  join(...paths) {
+    if (this.isWindowsPath) {
+      return this.build(win32.join(this.path, ...paths));
+    } else {
+      return this.build(posix.join(this.path, ...paths));
+    }
+  }
+  normalize() {
+    if (this.isWindowsPath) {
+      return this.build(win32.normalize(this.path));
+    } else {
+      return this.build(posix.normalize(this.path));
+    }
+  }
+  parent(count = 1) {
+    let path3 = this.absolute();
+    Range.new(1, count).each((i) => {
+      path3 = path3.resolve("..");
+    });
+    return path3;
+  }
+  // returns an object of the form: { root, dir, base, ext, name }
+  //
+  // Posix:
+  // >>> path.parse('/home/user/dir/file.txt')
+  // { root: '/',
+  //   dir: '/home/user/dir',
+  //   base: 'file.txt',
+  //   ext: '.txt',
+  //   name: 'file' }
+  // ┌─────────────────────┬────────────┐
+  // │          dir        │    base    │
+  // ├──────┬              ├──────┬─────┤
+  // │ root │              │ name │ ext │
+  // "  /    home/user/dir / file  .txt "
+  // └──────┴──────────────┴──────┴─────┘
+  // (All spaces in the "" line should be ignored. They are purely for formatting.)
+  //
+  // Windows:
+  // >>> path.parse('C:\\path\\dir\\file.txt');
+  // { root: 'C:\\',
+  //   dir: 'C:\\path\\dir',
+  //   base: 'file.txt',
+  //   ext: '.txt',
+  //   name: 'file' }
+  // ┌─────────────────────┬────────────┐
+  // │          dir        │    base    │
+  // ├──────┬              ├──────┬─────┤
+  // │ root │              │ name │ ext │
+  // " C:\      path\dir   \ file  .txt "
+  // └──────┴──────────────┴──────┴─────┘
+  // (All spaces in the "" line should be ignored. They are purely for formatting.)
+  parse() {
+    if (this.isWindowsPath) {
+      return win32.parse(this.path);
+    } else {
+      return posix.parse(this.path);
+    }
+  }
+  pop(count = 1) {
+    return this.parent(count);
+  }
+  relative(to) {
+    if (this.isWindowsPath) {
+      return this.build(win32.relative(this.path, to));
+    } else {
+      return this.build(posix.relative(this.path, to));
+    }
+  }
+  resolve(...paths) {
+    if (this.isWindowsPath) {
+      return this.build(win32.resolve(this.path, ...paths));
+    } else {
+      return this.build(posix.resolve(this.path, ...paths));
+    }
+  }
+  root() {
+    const { root } = this.parse();
+    return this.build(root);
+  }
+  selfAndAncestors() {
+    const ancestors = [];
+    let current = this.absolute();
+    while (true) {
+      ancestors.push(current);
+      if (current.isRoot()) {
+        break;
+      }
+      current = current.parent();
+    }
+    return ancestors;
+  }
+  // returns the parts of the path, excluding the root if applicable
+  // /home/user/dir/file.txt -> ["home", "user", "dir", "file.txt"]
+  // C:\home\user\dir\file.txt -> ["home", "user", "dir", "file.txt"]
+  // user/dir/file.txt -> ["user", "dir", "file.txt"]
+  // user\dir\file.txt -> ["user", "dir", "file.txt"]
+  split() {
+    const normalized = this.normalize();
+    if (normalized.isAbsolute()) {
+      const { root } = normalized.parse();
+      const relPath = Str(normalized.toString()).trimPrefix(root);
+      return relPath.split(_Path.sep(this.isWindowsPath));
+    } else {
+      return normalized.toString().split(_Path.sep(this.isWindowsPath));
+    }
+  }
+  toString() {
+    return this.path;
+  }
+};
+var PathEqualImpl = class extends Equal {
+  equal(val) {
+    return this.self.equals(val);
+  }
+};
+await Equal.register(Path, PathEqualImpl, true);
+
+// src/flex/range-protocols.ts
+var MappableRange = class extends Mappable {
+  map(mapFn) {
+    return this.self.map(mapFn);
+  }
+};
+await Mappable.register(Range, MappableRange, true);
+var EnumerableRange = class extends Enumerable {
+  *emit() {
+    const exclusiveEnd = this.self.inclusive ? this.self.end + 1 : this.self.end;
+    for (let i = this.self.start; i < exclusiveEnd; i++) {
+      yield i;
+    }
+  }
+};
+await Enumerable.register(Range, EnumerableRange, true);
+var EqualRange = class extends Equal {
+  equal(other) {
+    return this.self.equals(other);
+  }
+};
+await Equal.register(Range, EqualRange, true);
+var SelectableRange = class extends Selectable {
+  select(predFn) {
+    let arr = [];
+    this.self.each((num) => {
+      if (predFn(num)) {
+        arr.push(num);
+      }
+    });
+    return arr;
+  }
+};
+await Selectable.register(Range, SelectableRange, true);
+
+// src/flex/set-protocols.ts
+var MappableSet = class extends Mappable {
+  map(mapFn) {
+    const s = /* @__PURE__ */ new Set();
+    this.self.forEach((value) => {
+      const newValue = mapFn(value);
+      s.add(newValue);
+    });
+    return s;
+  }
+};
+await Mappable.register(Set, MappableSet, true);
+var EnumerableSet = class extends Enumerable {
+  // each(visitorFn: (v: T) => any): any {
+  //   return this.self.forEach((v) => visitorFn(v));
+  // }
+  *emit() {
+    for (const e of this.self) {
+      yield e;
+    }
+  }
+};
+await Enumerable.register(Set, EnumerableSet, true);
+
+// src/flex/array.ts
+function compact2(omit = [null, void 0]) {
+  return function(arr) {
+    const omitSet = toSet(omit);
+    const newArr = [];
+    for (const val of arr) {
+      if (!omitSet.has(val)) {
+        newArr.push(val);
+      }
+    }
+    return newArr;
+  };
+}
+function concat(tail) {
+  return function(arr) {
+    return arr.concat(tail);
+  };
+}
+function each4(eachFn) {
+  return function(arr) {
+    arr.forEach((value) => {
+      eachFn(value);
+    });
+  };
+}
+function find(predicateFn) {
+  return function(arr) {
+    for (const val of arr) {
+      if (predicateFn(val)) {
+        return val;
+      }
+    }
+    return void 0;
+  };
+}
+function first(n) {
+  return function(arr) {
+    return arr.slice(0, n);
+  };
+}
+function head(arr) {
+  return arr[0];
+}
+function isEmpty3(arr) {
+  return arr.length === 0;
+}
+function join(separator) {
+  return function(arr) {
+    return arr.join(separator);
+  };
+}
+function last(n) {
+  return function(arr) {
+    return arr.slice(arr.length - n, arr.length);
+  };
+}
+function map4(mapFn) {
+  return function(arr) {
+    return arr.map(mapFn);
+  };
+}
+function nth(n) {
+  return function(arr) {
+    return arr[n];
+  };
+}
+function partition(predFn) {
+  return function(arr) {
+    const trueArr = [];
+    const falseArr = [];
+    for (const val of arr) {
+      if (predFn(val)) {
+        trueArr.push(val);
+      } else {
+        falseArr.push(val);
+      }
+    }
+    return [trueArr, falseArr];
+  };
+}
+function prepend(...values3) {
+  return function(arr) {
+    arr.splice(0, 0, ...values3);
+    return arr;
+  };
+}
+function select4(predFn) {
+  return function(arr) {
+    return arr.filter(predFn);
+  };
+}
+function skipFirst(n) {
+  return function(arr) {
+    if (n > arr.length) {
+      n = arr.length;
+    }
+    return arr.slice(n, arr.length);
+  };
+}
+function skipLast(n) {
+  return function(arr) {
+    if (n > arr.length) {
+      n = arr.length;
+    }
+    return arr.slice(0, arr.length - n);
+  };
+}
+function toSet(arr) {
+  return new Set(arr);
+}
+function uniq(arr) {
+  return uniqBy(identity)(arr);
+}
+function uniqBy(comparisonValueFn) {
+  return function(arr) {
+    const map6 = /* @__PURE__ */ new Map();
+    for (const val of arr) {
+      const key = comparisonValueFn(val);
+      if (!map6.has(key)) {
+        map6.set(key, val);
+      }
+    }
+    return Array.from(map6.values());
+  };
+}
+function zip(other) {
+  return function(arr) {
+    var len = Math.min(arr.length, other.length);
+    var result = Array(len);
+    var idx = 0;
+    while (idx < len) {
+      result[idx] = [arr[idx], other[idx]];
+      idx += 1;
+    }
+    return result;
+  };
+}
+var A2 = buildWrapperProxy();
+A2.registerUncurriedFns({ head, isEmpty: isEmpty3, toSet, uniq });
+A2.registerCurriedFns({
+  compact: compact2,
+  concat,
+  each: each4,
+  filter: select4,
+  find,
+  first,
+  join,
+  last,
+  map: map4,
+  nth,
+  partition,
+  prepend,
+  select: select4,
+  skipFirst,
+  skipLast,
+  uniqBy,
+  zip
+});
+A2.registerStatic({
+  compact: compact2,
+  concat,
+  each: each4,
+  filter: select4,
+  find,
+  first,
+  head,
+  isEmpty: isEmpty3,
+  join,
+  last,
+  map: map4,
+  nth,
+  partition,
+  prepend,
+  select: select4,
+  skipFirst,
+  skipLast,
+  toSet,
+  uniq,
+  uniqBy,
+  zip
+});
+
+// src/flex/set.ts
+function addAll(enumerableVal) {
+  const enumerable = Enumerable.for(enumerableVal);
+  return function(set) {
+    enumerable.each((item) => set.add(item));
+    return set;
+  };
+}
+function each5(eachFn) {
+  return function(set) {
+    set.forEach((value) => {
+      eachFn(value);
+    });
+  };
+}
+function intersection(enumerableVal) {
+  const enumerable = Enumerable.for(enumerableVal);
+  return function(set) {
+    return set.intersection(enumerable.toSet());
+  };
+}
+function isEmpty4(set) {
+  return set.size === 0;
+}
+function isSubsetOf(enumerableSuperset) {
+  const enumerable = Enumerable.for(enumerableSuperset);
+  return function(set) {
+    return set.isSubsetOf(enumerable.toSet());
+  };
+}
+function isSupersetOf(enumerableSubset) {
+  const enumerable = Enumerable.for(enumerableSubset);
+  return function(set) {
+    return set.isSupersetOf(enumerable.toSet());
+  };
+}
+function map5(mapFn) {
+  return function(set) {
+    const s = /* @__PURE__ */ new Set();
+    set.forEach((value) => {
+      const newValue = mapFn(value);
+      s.add(newValue);
+    });
+    return s;
+  };
+}
+function toArray(set) {
+  return Array.from(set.values());
+}
+function union(enumerableVal) {
+  const enumerable = Enumerable.for(enumerableVal);
+  return function(set) {
+    return set.union(enumerable.toSet());
+  };
+}
+var S = buildWrapperProxy();
+S.registerUncurriedFns({ isEmpty: isEmpty4, toArray });
+S.registerCurriedFns({ addAll, each: each5, intersection, map: map5, union, isSubsetOf, isSupersetOf });
+S.registerStatic({
+  addAll,
+  each: each5,
+  intersection,
+  isEmpty: isEmpty4,
+  isSubsetOf,
+  isSupersetOf,
+  map: map5,
+  toArray,
+  union
+});
+
+// src/flex/pipe.ts
+var Pipe = class {
+  constructor(value) {
+    this.value = value;
+  }
+  // e.g. convertMethodsToPipeline(A([1,2,3]))
+  // returns a function that proxies method invocations through to the A([1,2,3]) object but assigns their return value
+  // to this.value in the pipeline, and then returns the pipe object, enabling stuff like this:
+  // P([1,2,3]).A.compact().A.first().value
+  _convertMethodsToPipeline(wrappedValue, nameOfMethodBag) {
+    const self = this;
+    return new Proxy(wrappedValue, {
+      get(target, property, receiver) {
+        const fn = Reflect.get(target, property, receiver);
+        if (fn === void 0) {
+          throw Error(`${nameOfMethodBag} does not have a method named ${String(property)}`);
+        }
+        return function(...args) {
+          self.value = fn.apply(receiver, args);
+          return self;
+        };
+      }
+    });
+  }
+  get A() {
+    return A2(this.value);
+  }
+  get a() {
+    return this._convertMethodsToPipeline(A2(this.value), "A");
+  }
+  compact(...args) {
+    this.value = compact(...args)(this.value);
+    return this;
+  }
+  each(visitorFn) {
+    this.value = each(visitorFn)(this.value);
+    return this;
+  }
+  get F() {
+    return F(this.value);
+  }
+  get f() {
+    return this._convertMethodsToPipeline(F(this.value), "F");
+  }
+  // enumerable() {
+  //   this.value = Enumerable.for(this.value);
+  //   return this;
+  // }
+  // enumerator() {
+  //   this.value = Enumerator.for(this.value);
+  //   return this;
+  // }
+  log() {
+    console.log(V.inspect(this.value));
+    return this;
+  }
+  get M() {
+    return M(this.value);
+  }
+  get m() {
+    return this._convertMethodsToPipeline(M(this.value), "M");
+  }
+  map(mapFn, implClass) {
+    this.value = map(mapFn)(this.value, implClass);
+    return this;
+  }
+  asyncMap(mapFn, implClass) {
+    this.value = asyncMap(mapFn)(this.value, implClass);
+    return this;
+  }
+  get O() {
+    return O(this.value);
+  }
+  get o() {
+    return this._convertMethodsToPipeline(O(this.value), "O");
+  }
+  pipe(fn) {
+    this.value = fn(this.value);
+    return this;
+  }
+  get S() {
+    return S(this.value);
+  }
+  get s() {
+    return this._convertMethodsToPipeline(S(this.value), "S");
+  }
+  get Str() {
+    return Str(this.value);
+  }
+  get str() {
+    return this._convertMethodsToPipeline(Str(this.value), "Str");
+  }
+  select(predFn, implClass) {
+    this.value = select(predFn)(this.value, implClass);
+    return this;
+  }
+  toArray() {
+    this.value = Enumerable.for(this.value).toArray();
+    return this;
+  }
+  waitAll() {
+    this.value = Promise.allSettled(this.value).then((results) => {
+      return results.map((result) => {
+        if (result.status === "fulfilled") {
+          return result.value;
+        } else {
+          return new Error(result.reason);
+        }
+      });
+    });
+    return this;
+  }
+};
+var VP = function(initial) {
+  return new Pipe(initial);
+};
+
+// src/tempfile.ts
+import "os";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import process2 from "process";
+
+// src/flex/file.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { win32 as win322, posix as posix2 } from "path";
+function exists(path3) {
+  return existsSync2(path3);
+}
+var File = class {
+  static absolutePath(...paths) {
+    if (isWindows()) {
+      return win322.resolve(...paths);
+    } else {
+      return posix2.resolve(...paths);
+    }
+  }
+  // basename("c:\\foo\\bar\\baz.txt") => "baz.txt"
+  // basename("/tmp/myfile.html") => "myfile.html"
+  static basename(path3, suffix) {
+    if (isWindows()) {
+      return win322.basename(path3, suffix);
+    } else {
+      return posix2.basename(path3, suffix);
+    }
+  }
+  static exists(path3) {
+    return exists(path3);
+  }
+  static join(...paths) {
+    if (isWindows()) {
+      return win322.join(...paths);
+    } else {
+      return posix2.join(...paths);
+    }
+  }
+  static readSync(path3) {
+    return readFileSync2(path3, {
+      encoding: "utf8"
+    });
+  }
+  static async readAsync(path3) {
+    return await readFile2(path3, {
+      encoding: "utf8"
+    });
+  }
+};
+
+// src/tempfile.ts
+var TmpFileRegistry = class _TmpFileRegistry {
+  static _instance;
+  static get instance() {
+    const path3 = File.join(osHomeDir(), ".hostctl", "tmpstatic");
+    this._instance ??= new _TmpFileRegistry(path3);
+    return this._instance;
+  }
+  rootPath;
+  tempFilePaths;
+  constructor(rootPath) {
+    this.rootPath = Path.new(rootPath);
+    this.tempFilePaths = [];
+    process2.on("exit", (code) => this.exitCallback());
+  }
+  randName() {
+    return Math.random().toString(36).slice(-5) + Math.random().toString(36).slice(-5);
+  }
+  tmpPath(tmpName) {
+    tmpName ??= this.randName();
+    return this.rootPath.join(tmpName);
+  }
+  // this directory will be automatically cleaned up at program exit
+  createNamedTmpDir(subDirName) {
+    const path3 = this.tmpPath(subDirName);
+    fs.mkdirSync(path3.toString(), { recursive: true });
+    this.registerTempFileOrDir(path3.toString());
+    return path3;
+  }
+  // this file will be automatically cleaned up at program exit
+  writeTmpFile(fileContent) {
+    const path3 = this.tmpPath();
+    fs.writeFileSync(path3.toString(), fileContent);
+    this.registerTempFileOrDir(path3.toString());
+    return path3;
+  }
+  exitCallback() {
+    this.cleanupTempFiles();
+  }
+  registerTempFileOrDir(path3) {
+    this.tempFilePaths.push(path3);
+  }
+  cleanupTempFiles() {
+    this.tempFilePaths.forEach((path3) => {
+      this.rmFile(path3);
+    });
+    this.tempFilePaths = [];
+  }
+  rmFile(path3) {
+    try {
+      fs.rmSync(path3, { force: true, recursive: true });
+    } catch (e) {
+    }
+  }
+};
+function osHomeDir() {
+  return path.resolve(os.homedir());
+}
+function writeTmpFile(fileContents) {
+  return TmpFileRegistry.instance.writeTmpFile(fileContents);
+}
+
+// src/host.ts
+var Host = class {
+  constructor(config, opts) {
+    this.config = config;
+    this.hostname = opts.hostname;
+    this.alias = opts.alias;
+    this.port = opts.port || 22;
+    this.user = opts.user;
+    this.password = opts.password;
+    this.sshKey = opts.sshKey;
+    this.tags = opts.tags ?? [];
+    this.tagSet = new Set(this.tags);
+  }
+  hostname;
+  // The network hostname or IP address, from the YAML hosts map key
+  alias;
+  port;
+  user;
+  password;
+  sshKey;
+  tags;
+  tagSet;
+  async decryptedPassword() {
+    switch (kind(this.password)) {
+      case String:
+        return this.password;
+      case SecretRef:
+        const secretRef = this.password;
+        const secret = this.config.getSecret(secretRef.name);
+        return await secret?.plaintext();
+    }
+  }
+  async decryptedSshKey() {
+    if (V(this.sshKey).isA(SecretRef)) {
+      const secretRef = this.sshKey;
+      const secret = this.config.getSecret(secretRef.name);
+      return await secret?.plaintext();
+    }
+  }
+  toYAML() {
+    let passwordForYaml = this.password;
+    if (this.password && V(this.password).isA(SecretRef)) {
+      passwordForYaml = this.password.toYAML();
+    }
+    let sshKeyForYaml = this.sshKey;
+    if (this.sshKey && V(this.sshKey).isA(SecretRef)) {
+      sshKeyForYaml = this.sshKey.toYAML();
+    }
+    return {
+      alias: this.alias,
+      user: this.user,
+      port: this.port === 22 ? void 0 : this.port,
+      // Only include port if not default
+      password: passwordForYaml,
+      "ssh-key": sshKeyForYaml,
+      tags: this.tags
+    };
+  }
+  // domain logic
+  get shortName() {
+    return this.alias || this.hostname;
+  }
+  isLocal() {
+    return this.hostname === "localhost" || this.hostname === "127.0.0.1";
+  }
+  get uri() {
+    return this.hostname;
+  }
+  // returns the temporary path to the decrypted ssh key
+  async writeTmpDecryptedSshKey() {
+    const content = await this.decryptedSshKey();
+    if (content) {
+      return writeTmpFile(content).toString();
+    }
+  }
+  _plaintextSshKeyPath = void 0;
+  async plaintextSshKeyPath() {
+    if (this._plaintextSshKeyPath) {
+      return this._plaintextSshKeyPath;
+    }
+    switch (kind(this.sshKey)) {
+      case String:
+        this._plaintextSshKeyPath = this.sshKey;
+        break;
+      case SecretRef:
+        this._plaintextSshKeyPath = await this.writeTmpDecryptedSshKey();
+        break;
+    }
+    return this._plaintextSshKeyPath;
+  }
+  toObject() {
+    return {
+      hostname: this.hostname,
+      port: this.port,
+      alias: this.alias,
+      user: this.user,
+      tags: this.tags
+    };
+  }
+  hasTag(tag) {
+    return this.tagSet.has(tag);
+  }
+  // each tag is a string of the form:
+  // - foo
+  // - bar,baz
+  // the interpretation of a 'bar,baz' tag is that the host must have either the 'bar' tag or the 'baz' tag in order to consider the 'bar,baz' tag present
+  hasAllTags(tags) {
+    for (const tag of tags) {
+      const tagParts = tag.split(",");
+      const anyTagPartPresent = S(this.tagSet).intersection(tagParts).size > 0;
+      if (!anyTagPartPresent) return false;
+    }
+    return true;
+  }
+  // each tag is a string of the form:
+  // - foo
+  // - bar+baz
+  // the interpretation of a 'bar+baz' tag is that the host must have both the 'bar' tag and the 'baz' tag in order to consider the 'bar+baz' tag present
+  hasAnyTag(tags) {
+    const effectiveTagsForMatching = S(new Set(this.tagSet)).addAll(A2([this.hostname, this.alias]).compact());
+    for (const tag of tags) {
+      const tagParts = tag.split("+");
+      const allTagPartsPresent = S(effectiveTagsForMatching).isSupersetOf(tagParts);
+      if (allTagPartsPresent) return true;
+    }
+    return false;
+  }
+};
+
+// src/age-encryption.ts
+import fs2 from "fs";
+import * as age from "age-encryption";
+
+// src/process.ts
+import spawnAsync from "@expo/spawn-async";
+
+// src/age-encryption.ts
+function readIdentityStringFromFile(path3) {
+  const contents = fs2.readFileSync(path3, {
+    encoding: "utf8"
+  });
+  const identityString = contents.split(/\r?\n|\r|\n/g).map((line) => line.trim()).find((line) => line.startsWith("AGE-SECRET-KEY-1"));
+  if (!identityString) throw new Error(`Unable to read identity from file: ${path3}`);
+  return identityString;
+}
+var LibraryDriver = class {
+  async encrypt(valueToEncrypt, publicKeys) {
+    const e = new age.Encrypter();
+    publicKeys.forEach((key) => e.addRecipient(key));
+    const ciphertextBytes = await e.encrypt(valueToEncrypt);
+    return age.armor.encode(ciphertextBytes);
+  }
+  async decrypt(valueToDecryptArmored, privateKeyFilePaths) {
+    if (privateKeyFilePaths.length === 0) {
+      throw new Error("Unable to decrypt: No age encryption identity (private key) specified.");
+    }
+    const d = new age.Decrypter();
+    let identitiesAdded = 0;
+    for (const path3 of privateKeyFilePaths) {
+      try {
+        const identityString = readIdentityStringFromFile(path3);
+        d.addIdentity(identityString);
+        identitiesAdded++;
+      } catch (err) {
+        console.warn(`Failed to read or parse identity file ${path3}, skipping: ${err.message}`);
+      }
+    }
+    if (identitiesAdded === 0) {
+      return null;
+    }
+    try {
+      const ciphertextBytes = age.armor.decode(valueToDecryptArmored);
+      const decryptedText = await d.decrypt(ciphertextBytes, "text");
+      return decryptedText;
+    } catch (error) {
+      return null;
+    }
+  }
+};
+var Identity = class {
+  identityFilePath;
+  identity;
+  // either the path to an identity file or an identity string must be supplied
+  constructor({ path: path3, identity: identity2 }) {
+    if (identity2) {
+      this.identity = identity2;
+      this.identityFilePath = this.writeTmpIdentityFile(identity2);
+    } else if (path3) {
+      this.identity = this.readIdentityFromFile(path3);
+      this.identityFilePath = path3;
+    } else {
+      throw "Either an identity string or an identity file path must be supplied to create an Age Encryption identity";
+    }
+  }
+  get recipient() {
+    return age.identityToRecipient(this.identity);
+  }
+  // returns the path to the temp file
+  writeTmpIdentityFile(identity2) {
+    return writeTmpFile(identity2).toString();
+  }
+  readIdentityFromFile(path3) {
+    const contents = fs2.readFileSync(path3, {
+      encoding: "utf8"
+    });
+    const identityString = contents.split(/\r?\n|\r|\n/g).map((line) => line.trim()).find((line) => line.startsWith("AGE-SECRET-KEY-1"));
+    if (!identityString) throw new Error(`Unable to read identity file: ${path3}`);
+    return identityString;
+  }
+  get privateKey() {
+    return this.identity;
+  }
+  get publicKey() {
+    return this.recipient;
+  }
+  decrypt(encryptedString) {
+    return AgeEncryption.decrypt(encryptedString, [this.identityFilePath]);
+  }
+  async encrypt(plaintext) {
+    return AgeEncryption.encrypt(plaintext, [await this.recipient]);
+  }
+};
+var AgeEncryption = class {
+  static instance = new LibraryDriver();
+  // Use LibraryDriver by default
+  static async encrypt(valueToEncrypt, publicKeys) {
+    const encrypted = await this.instance.encrypt(valueToEncrypt, publicKeys);
+    return encrypted;
+  }
+  static async decrypt(valueToDecrypt, privateKeyFilePaths) {
+    return await this.instance.decrypt(valueToDecrypt, privateKeyFilePaths);
+  }
+};
+
+// src/config-file.ts
+var SecretRef = class {
+  constructor(name) {
+    this.name = name;
+  }
+  toYAML() {
+    return this;
+  }
+};
+var SecretValue2 = class {
+  constructor(value) {
+    this.value = value;
+  }
+  async encrypt(recipients) {
+    if (!this.isEncrypted()) {
+      this.value = await AgeEncryption.encrypt(this.value, recipients);
+    }
+    return this.value;
+  }
+  async decrypt(identities) {
+    if (this.isEncrypted()) {
+      const decryptedValue = await AgeEncryption.decrypt(
+        this.value,
+        identities.map((i) => i.identityFilePath)
+      );
+      if (!decryptedValue) {
+        return void 0;
+      }
+      this.value = decryptedValue;
+    }
+    return this.value;
+  }
+  isEncrypted() {
+    return this.value.includes("AGE ENCRYPTED FILE");
+  }
+  toYAML() {
+    return this.value;
+  }
+};
+var Secret2 = class {
+  constructor(config, name, ids, value) {
+    this.config = config;
+    this.name = name;
+    this.ids = ids;
+    this.value = value;
+  }
+  recipients() {
+    return this.ids.recipients();
+  }
+  async ciphertext() {
+    return await this.value.encrypt(this.recipients());
+  }
+  async plaintext() {
+    const identities = this.config.loadPrivateKeys();
+    return await this.value.decrypt(identities);
+  }
+  async encrypt() {
+    return await this.ciphertext();
+  }
+  async decrypt() {
+    return await this.plaintext();
+  }
+  toYAML() {
+    return {
+      ids: this.ids.toYAML(),
+      value: this.value.toYAML()
+    };
+  }
+};
+var RecipientGroup = class {
+  constructor(config, publicKeys, idRefs) {
+    this.config = config;
+    this.publicKeys = publicKeys;
+    this.idRefs = idRefs;
+  }
+  // returns an array of public keys associated with all immediate and transitive recipients
+  recipients() {
+    const accumulatedPublicKeys = A2(this.publicKeys).toSet();
+    this.walkRecipientGroups((rg) => {
+      S(accumulatedPublicKeys).addAll(rg.publicKeys);
+    });
+    return S(accumulatedPublicKeys).toArray();
+  }
+  walkRecipientGroups(visitFn, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(this)) return;
+    visited.add(this);
+    visitFn(this);
+    this.config.getRecipientGroups(this.idRefs).forEach((rg) => rg.walkRecipientGroups(visitFn, visited));
+  }
+  toYAML() {
+    return this.publicKeys.concat(this.idRefs);
+  }
+};
+var NamedRecipientGroup = class extends RecipientGroup {
+  constructor(config, name, publicKeys, idRefs) {
+    super(config, publicKeys, idRefs);
+    this.config = config;
+    this.name = name;
+    this.publicKeys = publicKeys;
+    this.idRefs = idRefs;
+  }
+};
+var SecretRefYamlType = new yaml.Type("!secret", {
+  kind: "scalar",
+  // 'scalar' means string
+  // Loader must check if the input object is suitable for this type.
+  resolve(data) {
+    return !!data && typeof data === "string" && data.trim().length > 0;
+  },
+  // If a node is resolved, use it to create a SecretRef instance.
+  construct(yamlObj) {
+    return new SecretRef(yamlObj);
+  },
+  // Dumper must process instances of Point by rules of this YAML type.
+  instanceOf: SecretRef,
+  // Dumper must represent SecretRef objects as string in YAML.
+  represent(secretRef) {
+    return secretRef.name;
+  }
+});
+var HOSTCTL_CONFIG_SCHEMA = yaml.DEFAULT_SCHEMA.extend([SecretRefYamlType]);
+var ConfigFile2 = class {
+  constructor(path3) {
+    this.path = path3;
+    this._hosts = /* @__PURE__ */ new Map();
+    this._ids = /* @__PURE__ */ new Map();
+    this._secrets = /* @__PURE__ */ new Map();
+  }
+  _hosts;
+  _ids;
+  _secrets;
+  // serialization and deserialization
+  async load() {
+    if (!File.exists(this.path)) {
+      throw new Error(`Config file ${this.path} doesn't exist. Unable to load.`);
+    }
+    const yamlFileContents = await fsa.readFile(this.path, {
+      encoding: "utf8"
+    });
+    const yamlDocument = yaml.load(yamlFileContents, {
+      schema: HOSTCTL_CONFIG_SCHEMA
+    });
+    this.parse(yamlDocument);
+  }
+  parse(yamlDocument) {
+    this._hosts = this.parseHosts(yamlDocument.hosts || {});
+    this._ids = this.parseIdsMap(yamlDocument.ids || {});
+    this._secrets = this.parseSecrets(yamlDocument.secrets || {});
+  }
+  parseSecretValue(yamlSecretValue) {
+    switch (V(yamlSecretValue).kind()) {
+      case Undefined:
+        return yamlSecretValue;
+      case SecretRef:
+        return yamlSecretValue;
+      case String:
+        return yamlSecretValue;
+      // return new SecretValue(yamlSecretValue as string);
+      default:
+        throw new Error(`unknown secret type: ${V.inspect(yamlSecretValue)}`);
+    }
+  }
+  // yamlHosts is an object
+  parseHosts(yamlHosts) {
+    const hosts = Object.entries(yamlHosts).reduce((hostMap, [hostUri, hostObj]) => {
+      hostObj ||= {};
+      const password = this.parseSecretValue(hostObj.password);
+      const sshKey = this.parseSecretValue(hostObj["ssh-key"]);
+      hostMap.set(
+        hostUri,
+        new Host(this, {
+          ...hostObj,
+          // Use 'as any' to allow spread of hostObj properties
+          hostname: hostUri,
+          // The YAML map key is always the hostname
+          password,
+          sshKey
+        })
+      );
+      return hostMap;
+    }, /* @__PURE__ */ new Map());
+    return hosts;
+  }
+  parseIdsMap(yamlIds) {
+    const ids = Object.entries(yamlIds).reduce((secretsMap, [name, value]) => {
+      value ||= [];
+      const rg = this.parseRecipients(value);
+      secretsMap.set(name, new NamedRecipientGroup(this, name, rg.publicKeys, rg.idRefs));
+      return secretsMap;
+    }, /* @__PURE__ */ new Map());
+    return ids;
+  }
+  parseRecipients(ids) {
+    let idStrings;
+    if (V(ids).isA(String)) {
+      idStrings = [ids];
+    } else if (Array.isArray(ids) && ids.every((item) => V(item).isA(String))) {
+      idStrings = ids;
+    } else if (Array.isArray(ids)) {
+      idStrings = ids.flat(1);
+    } else {
+      idStrings = [];
+    }
+    const publicKeysAndIdRefs = idStrings.flatMap((str) => str.split(",")).map((str) => str.trim());
+    const [publicKeys, idRefs] = A2(publicKeysAndIdRefs).partition(this.isValidPublicKey);
+    return new RecipientGroup(this, publicKeys, idRefs);
+  }
+  // returns true if the key is an Age encryption public key (i.e. a bech32 key with a prefix of 'age')
+  isValidPublicKey(str) {
+    try {
+      const { prefix, words } = bech32.decode(str);
+      return prefix === "age";
+    } catch (e) {
+      return false;
+    }
+  }
+  // yamlSecrets is an object
+  parseSecrets(yamlSecrets) {
+    const secrets = Object.entries(yamlSecrets).reduce((secretsMap, [name, yamlSecret]) => {
+      const recipients = this.parseRecipients(yamlSecret.ids);
+      secretsMap.set(name, new Secret2(this, name, recipients, new SecretValue2(yamlSecret.value)));
+      return secretsMap;
+    }, /* @__PURE__ */ new Map());
+    return secrets;
+  }
+  async save(destinationPath = this.path) {
+    const hosts = this.serializeHosts();
+    const secrets = this.serializeSecrets();
+    const ids = this.serializeIds();
+    const yamlFileObj = {
+      hosts,
+      secrets,
+      ids
+    };
+    const yamlFileContents = yaml.dump(yamlFileObj, {
+      schema: HOSTCTL_CONFIG_SCHEMA,
+      noRefs: true
+    });
+    await fsa.writeFile(destinationPath, yamlFileContents);
+  }
+  serializeHosts() {
+    return VP(this._hosts).map(([name, host]) => [name, host.toYAML()]).m.toObject().value;
+  }
+  serializeSecrets() {
+    return VP(this._secrets).map(([name, secret]) => [name, secret.toYAML()]).m.toObject().value;
+  }
+  serializeIds() {
+    return VP(this._ids).map(([name, id]) => [name, id.toYAML()]).m.toObject().value;
+  }
+  // domain logic
+  // loads private keys from the AGE_IDS environment variable
+  loadPrivateKeys() {
+    const ageIds = process.env.AGE_IDS;
+    if (ageIds) {
+      const paths = globSync2(ageIds);
+      const ids = paths.map((path3) => new Identity({ path: path3 }));
+      return ids;
+    }
+    return [];
+  }
+  getSecret(name) {
+    return this._secrets.get(name);
+  }
+  getRecipientGroups(idRefs) {
+    return VP(idRefs).map((idRef) => this._ids.get(idRef)).compact().value;
+  }
+  async decryptAllIfPossible() {
+    await VP(this._secrets).m.values().map((secret) => secret.decrypt()).waitAll().value;
+  }
+  async encryptAll() {
+    await VP(this._secrets).m.values().map((secret) => secret.encrypt()).waitAll().value;
+  }
+  // Config interface
+  hosts() {
+    return M(this._hosts).values();
+  }
+  secrets() {
+    return this._secrets;
+  }
+  ids() {
+    return this._ids;
+  }
+};
+
+// src/config-url.ts
+var ConfigUrl = class {
+  constructor(url) {
+    this.url = url;
+    this._hosts = /* @__PURE__ */ new Map();
+    this._secrets = /* @__PURE__ */ new Map();
+    this._ids = /* @__PURE__ */ new Map();
+  }
+  _hosts;
+  _secrets;
+  _ids;
+  // Config interface
+  hosts() {
+    return [];
+  }
+  getSecret(name) {
+    return void 0;
+  }
+  getRecipientGroups(idRefs) {
+    return [];
+  }
+  secrets() {
+    return this._secrets;
+  }
+  ids() {
+    return this._ids;
+  }
+};
+
+// src/config.ts
+async function load(configRef) {
+  if (configRef && fs4.existsSync(configRef)) {
+    const configFile = new ConfigFile2(configRef);
+    await configFile.load();
+    return configFile;
+  } else if (configRef) {
+    return new ConfigUrl(configRef);
+  } else {
+    throw new Error("No config specified.");
+  }
+}
+
+// src/interaction-handler.ts
+import { Readable } from "stream";
+import { StreamRegex } from "stream-regex";
+var InteractionHandler = class _InteractionHandler {
+  static with(inputs) {
+    return new _InteractionHandler(new Map(Object.entries(inputs)));
+  }
+  patternInputMappings;
+  // pairs of pattern -> response
+  inputStreamForRegexMatcher;
+  // private streamRegex: StreamRegex;
+  // private matches: Readable;
+  writeFn;
+  constructor(patternInputMappings = /* @__PURE__ */ new Map()) {
+    this.patternInputMappings = M(patternInputMappings).map(([pattern, v]) => [
+      pattern instanceof RegExp ? pattern.source : pattern,
+      v
+    ]);
+  }
+  clone() {
+    return new _InteractionHandler(this.patternInputMappings);
+  }
+  with(inputs) {
+    const clone = this.clone();
+    clone.mapInput(inputs);
+    return clone;
+  }
+  mapInput(inputMap) {
+    Object.entries(inputMap).forEach(([pattern, response]) => {
+      this.map(pattern, response);
+    });
+    return this;
+  }
+  map(pattern, response) {
+    if (pattern instanceof RegExp) {
+      this.patternInputMappings.set(pattern.source, response);
+    } else {
+      this.patternInputMappings.set(pattern, response);
+    }
+    return this;
+  }
+  // builds a regex of the form /(alternative 1)|(alternative 2)|...|(alternative N)/
+  compositeRegex() {
+    if (M(this.patternInputMappings).isEmpty()) return void 0;
+    const compositePattern = VP(this.patternInputMappings).m.keys().map((pattern) => `(${pattern})`).a.join("|").value;
+    return new RegExp(compositePattern, "g");
+  }
+  // returns the first pattern that matches
+  // the matching pattern will be a key in ioMappings
+  firstMatchingPattern(matchStr) {
+    return Array.from(this.patternInputMappings.keys()).find((pattern) => matchStr.match(pattern));
+  }
+  findReplacementForMatch(matchStr) {
+    const matchingPattern = this.firstMatchingPattern(matchStr);
+    if (!matchingPattern) return void 0;
+    const replacementValue = this.patternInputMappings.get(matchingPattern);
+    return replacementValue;
+  }
+  begin() {
+    this.inputStreamForRegexMatcher = new Readable();
+    this.inputStreamForRegexMatcher._read = () => {
+    };
+    const compositeRegex = this.compositeRegex();
+    if (compositeRegex) {
+      const streamRegex = new StreamRegex(compositeRegex);
+      const matches2 = streamRegex.match(this.inputStreamForRegexMatcher);
+      matches2.on("data", (matchStr) => {
+        const inputToWrite = this.findReplacementForMatch(matchStr);
+        if (inputToWrite !== void 0) {
+          this.emitInput(inputToWrite);
+        }
+      });
+    }
+  }
+  handleInput(inputChunk) {
+    if (this.inputStreamForRegexMatcher) {
+      this.inputStreamForRegexMatcher.push(inputChunk);
+    }
+  }
+  // either use setOutputToNewReadable XOR setOutputWriter; not both
+  setOutputToNewReadable() {
+    const stdinReadable = new Readable();
+    this.setOutputWriter((str) => stdinReadable.push(str));
+    stdinReadable._read = () => {
+    };
+    return stdinReadable;
+  }
+  // either use setOutputToNewReadable XOR setOutputWriter; not both
+  setOutputWriter(writeFn) {
+    this.writeFn = writeFn;
+  }
+  emitInput(input) {
+    if (this.writeFn) {
+      this.writeFn(input);
+    }
+  }
+  end() {
+    if (this.inputStreamForRegexMatcher) {
+      this.inputStreamForRegexMatcher.push(null);
+    }
+  }
+};
+
+// src/app.ts
+import * as util2 from "util";
+import chalk4 from "chalk";
+import { password as promptPassword } from "@inquirer/prompts";
+import { Listr } from "listr2";
+
+// src/task.model.ts
+var Task = class {
+  constructor(runFn, taskModuleAbsolutePath, description, name) {
+    this.runFn = runFn;
+    this.taskModuleAbsolutePath = taskModuleAbsolutePath;
+    this.description = description;
+    this.name = name;
+  }
+};
+
+// src/stacktrace.ts
+import StackTracey from "stacktracey";
+function callstack() {
+  return new StackTracey();
+}
+
+// src/runtime-base.ts
+import { Mutex as Mutex2 } from "async-mutex";
+
+// src/command.ts
+import "shell-quote";
+import Shellwords from "shellwords-ts";
+var CommandResult = class {
+  constructor(stdout, stderr, exitCode, signal) {
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+    this.signal = signal;
+  }
+  toJSON() {
+    return {
+      stdout: this.stdout,
+      stderr: this.stderr,
+      exitCode: this.exitCode,
+      signal: this.signal,
+      success: this.success,
+      failure: this.failure
+    };
+  }
+  get out() {
+    return this.stdout;
+  }
+  get err() {
+    return this.stderr;
+  }
+  get exit() {
+    return this.exitCode;
+  }
+  get sig() {
+    return this.signal;
+  }
+  get success() {
+    return this.exitCode === 0;
+  }
+  get failure() {
+    return !this.success;
+  }
+};
+var Command = class {
+  static parse(commandString, env) {
+    if (!commandString || commandString.trim() === "") {
+      throw new Error("Command string cannot be empty.");
+    }
+    const parts = Shellwords.split(commandString);
+    const cmd_unsafe = A2.head(parts);
+    if (cmd_unsafe === void 0) {
+      throw new Error(`Failed to parse command from string: "${commandString}". Resulted in no command part.`);
+    }
+    const cmd = cmd_unsafe;
+    const parsedArgs = A2(parts).skipFirst(1);
+    const args = A2(parsedArgs).compact();
+    return {
+      cmd,
+      args,
+      env
+    };
+  }
+  cmd;
+  args;
+  cwd;
+  env;
+  result;
+  constructor(opts) {
+    const { cmd, args, cwd, env, result } = opts;
+    this.cmd = cmd;
+    this.args = args;
+    this.cwd = cwd;
+    this.env = env;
+    this.result = result;
+  }
+  isRunning() {
+    return !!this.result;
+  }
+  toJSON() {
+    return {
+      cmd: this.cmd,
+      args: this.args,
+      cwd: this.cwd,
+      env: this.env,
+      result: this.result?.toJSON()
+    };
+  }
+};
+
+// src/runtime-base.ts
+import { StringBuilder } from "typescript-string-operations";
+import chalk from "chalk";
+function task(runFn, options) {
+  const moduleThatTaskIsDefinedIn = Path.new(callstack().items[2].file).absolute().toString();
+  const taskName = options?.name || "anonymous_task";
+  const taskInstance = new Task(runFn, moduleThatTaskIsDefinedIn, options?.description, taskName);
+  const taskFnObject = function(params) {
+    return function(parentInvocation) {
+      return parentInvocation.invokeChildTask(taskFnObject, params ?? {});
+    };
+  };
+  Object.assign(taskFnObject, { task: taskInstance });
+  return taskFnObject;
+}
+var Invocation = class {
+  constructor(runtime, taskFnDefinition, parent) {
+    this.runtime = runtime;
+    this.taskFnDefinition = taskFnDefinition;
+    this.parent = parent;
+    this.id = crypto.randomUUID();
+    this.children = [];
+    this.childrenMutex = new Mutex2();
+    const { promise, resolve, reject } = Promise.withResolvers();
+    this.result = promise;
+    this.resolveResult = resolve;
+    this.rejectResult = reject;
+    this.stdoutSB = new StringBuilder();
+    this.stderrSB = new StringBuilder();
+  }
+  id;
+  children;
+  // Children can have any params
+  childrenMutex;
+  description;
+  stderrSB;
+  stdoutSB;
+  host;
+  result;
+  resolveResult;
+  rejectResult;
+  // Constructor and fields are above
+  // Concrete method implementations
+  getPassword() {
+    return this.runtime.getPassword();
+  }
+  async getSecret(name) {
+    const secret = this.runtime.app.config.getSecret(name);
+    if (!secret) {
+      return void 0;
+    }
+    return secret.plaintext();
+  }
+  get stderr() {
+    return this.stderrSB.toString();
+  }
+  get stdout() {
+    return this.stdoutSB.toString();
+  }
+  info(...message) {
+    this.log(Verbosity.INFO, ...message);
+  }
+  debug(...message) {
+    this.log(Verbosity.DEBUG, ...message);
+  }
+  warn(...message) {
+    this.log(Verbosity.WARN, ...message);
+  }
+  error(...message) {
+    this.log(Verbosity.ERROR, ...message);
+  }
+  async resultError() {
+    try {
+      await this.result;
+      return void 0;
+    } catch (e) {
+      return e;
+    }
+  }
+  setDescription(description) {
+    this.description = description;
+  }
+  setFutureResult(resultPromise) {
+    resultPromise.then(this.resolveResult, this.rejectResult);
+  }
+  getDescription() {
+    return this.description;
+  }
+  getChildren() {
+    return this.children;
+  }
+  getResultPromise() {
+    return this.result;
+  }
+  exit(exitCode, message) {
+    if (message) {
+      this.runtime.app.warn(
+        chalk.yellow(`Task ${this.description || this.id} requested exit with code ${exitCode}: ${message}`)
+      );
+    }
+    process.exit(exitCode);
+  }
+  inventory(tags) {
+    return this.runtime.inventory(tags);
+  }
+  async appendChildInvocation(childInvocation) {
+    await this.childrenMutex.runExclusive(async () => {
+      this.children.push(childInvocation);
+    });
+  }
+  // Note: 'exit' has a concrete implementation above, so it's not abstract here.
+  // Note: 'inventory' has a concrete implementation above, so it's not abstract here.
+};
+
+// src/local-runtime.ts
+import Handlebars2 from "handlebars";
+import * as fs5 from "fs";
+
+// src/ruspty-command.ts
+import { Pty } from "@replit/ruspty";
+import { StringBuilder as StringBuilder2 } from "typescript-string-operations";
+import "human-signals";
+var RusPtyCommand = class _RusPtyCommand extends Command {
+  static fromArray(commandWithArgs, env, cwd) {
+    const envObj = O(env || {}).map(([key, value]) => [key, String(value)]);
+    const cmd = commandWithArgs[0] || "";
+    const parsedArgs = commandWithArgs.slice(1);
+    const args = parsedArgs.filter((arg) => arg !== null && arg !== void 0 && arg !== "");
+    return new _RusPtyCommand({ cmd, args, cwd, env: envObj });
+  }
+  static fromString(command, env, cwd) {
+    const envObj = O(env || {}).map(([key, value]) => [key, String(value)]);
+    const { cmd, args } = this.parse(command, envObj);
+    return new _RusPtyCommand({ cmd, args, cwd, env: envObj });
+  }
+  process;
+  // Definite assignment assertion
+  async run(interactionHandler = new InteractionHandler(), stdin) {
+    const self = this;
+    return new Promise(function(resolve, reject) {
+      const stdout = new StringBuilder2();
+      self.process = new Pty({
+        command: self.cmd,
+        args: self.args,
+        dir: self.cwd,
+        envs: self.env,
+        interactive: true,
+        size: { rows: 30, cols: 80 },
+        onExit: (err, exitCode) => {
+          interactionHandler.end();
+          const signalObj = void 0;
+          const commandResult = new CommandResult(stdout.toString(), "", exitCode, signalObj);
+          self.result = commandResult;
+          resolve(commandResult);
+        }
+      });
+      const read = self.process.read;
+      const write = self.process.write;
+      if (stdin) {
+        write.write(stdin);
+      }
+      interactionHandler.begin();
+      interactionHandler.setOutputWriter((str) => write.write(str));
+      read.on("data", (chunk) => {
+        stdout.append(chunk);
+        interactionHandler.handleInput(chunk);
+      });
+    });
+  }
+};
+
+// src/local-runtime.ts
+import chalk2 from "chalk";
+
+// src/util/input-helpers.ts
+var CHECKMARK = "\u2713";
+var XMARK = "\u2717";
+var SUDO_PROMPT_REGEX = {
+  /**
+   * Matches the default sudo prompt on most Linux distributions.
+   * Example: `[sudo] password for <username>:`
+   */
+  LINUX: "\\[sudo\\] password",
+  /**
+   * Matches the default sudo prompt on macOS and some BSD systems.
+   * Example: `Password:`
+   */
+  MAC_BSD: "^Password:",
+  /**
+   * Matches the default prompt for `doas` on OpenBSD.
+   * Example: `doas (username@hostname) password:`
+   */
+  DOAS: "doas \\(.*\\) password:"
+};
+function withSudo(password, existingInputMap = {}) {
+  if (!password) {
+    return existingInputMap;
+  }
+  const passwordResponse = `${password}
+`;
+  return {
+    ...existingInputMap,
+    [SUDO_PROMPT_REGEX.LINUX]: passwordResponse,
+    [SUDO_PROMPT_REGEX.MAC_BSD]: passwordResponse,
+    [SUDO_PROMPT_REGEX.DOAS]: passwordResponse
+  };
+}
+
+// src/local-runtime.ts
+var LocalInvocation = class _LocalInvocation extends Invocation {
+  constructor(runtime, taskFnDefinition, params, parent) {
+    super(runtime, taskFnDefinition, parent);
+    this.runtime = runtime;
+    this.taskFnDefinition = taskFnDefinition;
+    this.description = Handlebars2.compile(
+      taskFnDefinition.task.description || taskFnDefinition.task.name || "anonymous_local_task"
+    )(params);
+    this.config = this.runtime.app.config;
+    this.file = {
+      read: async (path3) => fs5.promises.readFile(path3, "utf-8"),
+      write: async (path3, content, options) => fs5.promises.writeFile(path3, content, { mode: options?.mode }),
+      exists: async (path3) => {
+        try {
+          await fs5.promises.access(path3);
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      mkdir: async (path3, options) => {
+        await fs5.promises.mkdir(path3, options);
+      },
+      rm: async (path3, options) => fs5.promises.rm(path3, options)
+    };
+  }
+  config;
+  file;
+  log(level, ...message) {
+    this.runtime.app.log(level, ...message);
+  }
+  async exec(command, options = {}) {
+    options = options || {};
+    const interactionHandler = this.runtime.interactionHandler.clone();
+    const stdinForCommand = options.stdin;
+    if (options.input && typeof options.input === "object") {
+      O(options.input).each(([pattern, value]) => {
+        interactionHandler.map(pattern, value);
+      });
+    }
+    if (options.sudo) {
+      const hostPassword = await this.runtime.getPassword();
+      interactionHandler.mapInput(withSudo(hostPassword));
+    }
+    const cwd = options.cwd ?? process.cwd();
+    let finalEnv = {};
+    if (options.env) {
+      finalEnv = options.env;
+    } else {
+      Object.keys(process.env).forEach((key) => {
+        const value = process.env[key];
+        if (value !== void 0) {
+          finalEnv[key] = value;
+        }
+      });
+    }
+    let commandInstance;
+    if (command instanceof Array) {
+      commandInstance = RusPtyCommand.fromArray(command, finalEnv, cwd);
+    } else {
+      commandInstance = RusPtyCommand.fromString(command, finalEnv, cwd);
+    }
+    this.log(
+      Verbosity.DEBUG,
+      `Executing command: ${Array.isArray(command) ? command.join(" ") : command}${options.stdin ? " with stdin" : ""}${options.input ? " with interaction patterns" : ""}`
+    );
+    await commandInstance.run(interactionHandler, stdinForCommand);
+    const cmdResult = commandInstance.result;
+    if (!cmdResult) {
+      this.log(Verbosity.ERROR, "Command execution resulted in undefined result.");
+      return new CommandResult("", "Command execution resulted in undefined result.", -1, void 0);
+    }
+    return cmdResult;
+  }
+  async ssh(tags, remoteTaskFn) {
+    const targetHosts = this.runtime.app.querySelectedInventory(tags);
+    if (targetHosts.length === 0) {
+      this.runtime.app.warn(`No hosts found for tags: ${tags.join(", ")} in ssh call from ${this.id}`);
+      return {};
+    }
+    const entryPromises = VP(targetHosts).map(async (host) => {
+      const result = await this.runRemoteTaskOnHost(host, remoteTaskFn);
+      return [host.hostname, result];
+    }).value;
+    const entries = await Promise.all(entryPromises);
+    const record = Object.fromEntries(entries);
+    return record;
+  }
+  async runRemoteTaskOnHost(host, remoteTaskFn) {
+    this.debug(`Run function on: ${chalk2.yellow(V.inspect(host.toObject()))}`);
+    const interactionHandler = new InteractionHandler(this.runtime.app.getSecretsForHost(host.hostname));
+    const remoteRuntime = new RemoteRuntime(
+      this.runtime.app,
+      host,
+      this.runtime,
+      // The LocalRuntime instance of this LocalInvocation
+      interactionHandler
+    );
+    try {
+      const connected = await remoteRuntime.connect();
+      if (!connected) {
+        throw new Error(`Unable to connect to ${host.uri}`);
+      }
+      const adHocRemoteInvocationTaskFn = task(
+        async function(context) {
+          return remoteTaskFn(context);
+        },
+        { description: `Ad-hoc task on ${host.uri} via ssh from ${this.taskFnDefinition.task.name} (${this.id})` }
+      );
+      const rootRemoteInvocation = new RemoteInvocation(
+        remoteRuntime,
+        adHocRemoteInvocationTaskFn,
+        // This TaskFn is for the container of the ad-hoc operation on this host
+        {},
+        this,
+        // Parent is the current LocalInvocation
+        host
+      );
+      await this.appendChildInvocation(rootRemoteInvocation);
+      const rootRemoteContext = this.runtime.app.taskContextForRunFn(
+        rootRemoteInvocation,
+        {},
+        host
+      );
+      const resultPromise = remoteTaskFn(rootRemoteContext);
+      rootRemoteInvocation.setFutureResult(resultPromise);
+      rootRemoteInvocation.setDescription(`SSH to ${host.uri}`);
+      return await resultPromise;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.runtime.app.error(
+        `Error during SSH operation to ${host.uri}: ${errorMessage}`,
+        error instanceof Error ? error.stack : void 0
+      );
+      return error instanceof Error ? error : new Error(errorMessage);
+    } finally {
+      await remoteRuntime.disconnect();
+    }
+  }
+  exit(exitCode, message) {
+    if (message) {
+      this.log(exitCode === 0 ? Verbosity.INFO : Verbosity.ERROR, message);
+    }
+    this.runtime.app.warn(`Task ${this.id} requested exit with code ${exitCode}. Forcing process exit.`);
+    process.exit(exitCode);
+  }
+  inventory(tags) {
+    return this.runtime.app.queryInventory(new Set(tags));
+  }
+  async run(taskPartialFn) {
+    return taskPartialFn(this);
+  }
+  async invokeChildTask(childTaskFnDefinition, params) {
+    const childInvocation = new _LocalInvocation(this.runtime, childTaskFnDefinition, params, this);
+    await this.appendChildInvocation(childInvocation);
+    const loggedChildResultPromise = childInvocation.result.then((value) => {
+      if (value instanceof Error) return value;
+      if (value === void 0 || value === null) return void 0;
+      return String(value);
+    }).catch((error) => error);
+    this.runtime.app.taskTree.add(
+      childInvocation.id,
+      this.id,
+      childTaskFnDefinition.task.name || "anonymous_child_task",
+      loggedChildResultPromise
+    );
+    const taskContext = this.runtime.app.taskContextForRunFn(
+      childInvocation,
+      params,
+      void 0
+    );
+    try {
+      const result = await childTaskFnDefinition.task.runFn.call(childInvocation, taskContext);
+      childInvocation.resolveResult(result);
+      return result;
+    } catch (error) {
+      childInvocation.rejectResult(error);
+      throw error;
+    }
+  }
+};
+var LocalRuntime = class {
+  constructor(app, localBundlePath, interactionHandler = new InteractionHandler()) {
+    this.app = app;
+    this.localBundlePath = localBundlePath;
+    this.interactionHandler = interactionHandler;
+    const appConfigInstance = this.app.config;
+    if (appConfigInstance instanceof ConfigFile2) {
+      this.host = new Host(appConfigInstance, { hostname: "localhost" });
+    } else {
+      const configType = appConfigInstance?.constructor?.name || typeof appConfigInstance;
+      this.app.error(
+        `CRITICAL ERROR: LocalRuntime could not initialize its 'localhost' Host object. The application's configuration (type: ${configType}) is not a file-based configuration (expected ConfigFile).`
+      );
+      throw new Error(
+        `LocalRuntime init failed: Expected app.config to be an instance of ConfigFile for 'localhost' Host, but got ${configType}.`
+      );
+    }
+    this.config = {
+      cwd: process.cwd(),
+      configFile: appConfigInstance instanceof ConfigFile2 ? appConfigInstance : void 0
+    };
+  }
+  config;
+  host;
+  // Represents the local machine
+  memoizedPassword;
+  get tmpDirRootPath() {
+    return this.app.hostctlTmpDir();
+  }
+  async getPassword() {
+    if (this.memoizedPassword) {
+      return this.memoizedPassword;
+    }
+    this.memoizedPassword = await this.app.promptPassword("Enter local sudo password:");
+    return this.memoizedPassword;
+  }
+  async getSecret(name) {
+    const secret = this.app.config.getSecret(name);
+    if (!secret) {
+      this.app.warn(`Secret ${name} not found in config.`);
+      return void 0;
+    }
+    return secret.plaintext();
+  }
+  getTmpDir() {
+    return this.app.createNamedTmpDir();
+  }
+  getTmpFile(prefix, postfix, dir) {
+    const tmpDir = dir || this.getTmpDir();
+    const randomName = prefix ? `${prefix}-${crypto.randomUUID()}` : crypto.randomUUID();
+    const finalName = postfix ? `${randomName}-${postfix}` : randomName;
+    return tmpDir.join(finalName);
+  }
+  inventory(tags) {
+    return this.app.queryInventory(new Set(tags));
+  }
+  async invokeRootTask(taskFnDefinition, params, description) {
+    const rootInvocation = new LocalInvocation(
+      this,
+      taskFnDefinition,
+      params,
+      void 0
+    );
+    if (description) {
+      rootInvocation.description = description;
+    }
+    const loggedRootResultPromise = rootInvocation.result.then((value) => {
+      if (value instanceof Error) return value;
+      if (value === void 0 || value === null) return void 0;
+      return String(value);
+    }).catch((error) => error);
+    this.app.taskTree.add(
+      rootInvocation.id,
+      null,
+      taskFnDefinition.task.name || "anonymous_root_task",
+      loggedRootResultPromise
+    );
+    const taskContext = this.app.taskContextForRunFn(
+      rootInvocation,
+      params,
+      void 0
+    );
+    taskFnDefinition.task.runFn.call(rootInvocation, taskContext).then(rootInvocation.resolveResult).catch(rootInvocation.rejectResult);
+    return rootInvocation;
+  }
+};
+
+// src/remote-runtime.ts
+import Handlebars3 from "handlebars";
+import "path";
+
+// src/ssh-session.ts
+import { signalsByName } from "human-signals";
+import { NodeSSH } from "node-ssh";
+import { PassThrough } from "stream";
+var SSHSession = class {
+  ssh;
+  constructor() {
+    this.ssh = new NodeSSH();
+  }
+  connect(sshConnectOpts) {
+    return this.ssh.connect(sshConnectOpts);
+  }
+  async deleteFile(remotePath) {
+    const self = this;
+    return new Promise(function(resolve, reject) {
+      self.ssh.withSFTP(async (sftp) => {
+        sftp.unlink(remotePath, (err) => {
+          if (err) {
+            const errnoError = err;
+            if (errnoError.errno === 2 || errnoError.code === "ENOENT") {
+              resolve(true);
+            } else {
+              const errnoError2 = err;
+              const errorCodeDisplay = errnoError2.code !== void 0 ? errnoError2.code : errnoError2.errno !== void 0 ? errnoError2.errno : "N/A";
+              reject(`${errnoError2.message} (code ${errorCodeDisplay}) ${remotePath}`);
+            }
+          } else {
+            resolve(true);
+          }
+        });
+      });
+    });
+  }
+  async sftp() {
+    return this.ssh.requestSFTP();
+  }
+  async execCommand(command, options) {
+    const nodeSshCmdOptions = {
+      // Using 'any' temporarily to build up, then will cast or ensure type compatibility
+      cwd: options?.cwd,
+      stdin: typeof options?.stdin === "string" ? options.stdin : Buffer.isBuffer(options?.stdin) ? options.stdin.toString() : void 0
+    };
+    if (options?.pty !== void 0) {
+      nodeSshCmdOptions.options = {
+        ...nodeSshCmdOptions.options || {},
+        // Preserve other potential ssh2 options if they were there
+        pty: options.pty
+      };
+    }
+    const result = await this.ssh.execCommand(command, nodeSshCmdOptions);
+    const exitCode = result.code === null ? -1 : result.code;
+    const signalString = result.signal;
+    const signalObject = signalString ? signalsByName[signalString] : void 0;
+    const commandResult = new CommandResult(result.stdout, result.stderr, exitCode, signalObject);
+    return new Command({ cmd: command, args: [], cwd: options?.cwd, env: options?.env, result: commandResult });
+  }
+  async getFile(remotePath, localPath) {
+    await this.ssh.getFile(localPath, remotePath);
+  }
+  /**
+   * Executes a command on the remote host.
+   * @param command The command to execute. Can be a string or an array of strings. If an array, the first element is
+   *                the command and the rest are arguments. Otherwise, the string is parsed as a command.
+   * @param interactionHandler The interaction handler to use.
+   * @param execOptions The options for the execution.
+   * @returns A promise that resolves to the result of the command.
+   */
+  async run(command, interactionHandler = new InteractionHandler(), execOptions = {}) {
+    const self = this;
+    const combinedStdin = new PassThrough();
+    if (execOptions.stdin) {
+      combinedStdin.write(execOptions.stdin);
+    }
+    interactionHandler.setOutputToNewReadable().pipe(combinedStdin);
+    interactionHandler.begin();
+    let cmd, args;
+    if (command instanceof Array) {
+      cmd = command[0] || "";
+      args = command.slice(1).filter((arg) => !!arg);
+    } else {
+      const parsedCommand = Command.parse(command);
+      cmd = parsedCommand.cmd;
+      args = parsedCommand.args;
+    }
+    const ptyOption = execOptions.pty ?? true;
+    const { stdout, stderr, code, signal } = await self.ssh.exec(cmd, args, {
+      cwd: execOptions.cwd,
+      execOptions: { pty: ptyOption, env: execOptions.env },
+      stream: "both",
+      stdin: combinedStdin,
+      onStdout: (chunk) => {
+        const output = chunk.toString("utf8");
+        interactionHandler.handleInput(output);
+      },
+      onStderr: (chunk) => {
+        const errorOutput = chunk.toString("utf8");
+        interactionHandler.handleInput(errorOutput);
+      }
+    });
+    interactionHandler.end();
+    const signalName = signal;
+    const signalObj = signalName ? signalsByName[signalName] : void 0;
+    const result = new CommandResult(stdout, stderr, code || 0, signalObj);
+    return new Command({ cmd, args, cwd: execOptions.cwd, env: execOptions.env, result });
+  }
+  async sendFile(localPath, remotePath) {
+    try {
+      await this.ssh.putFile(localPath, remotePath);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  async disconnect() {
+    this.ssh.dispose();
+  }
+  isConnected() {
+    return this.ssh.isConnected();
+  }
+};
+
+// src/remote-runtime.ts
+import "chalk";
+import "util";
+import "typescript-string-operations";
+import { match, P } from "ts-pattern";
+var RemoteInvocation = class _RemoteInvocation extends Invocation {
+  // sshSession is removed from RemoteInvocation, it will be managed by RemoteRuntime
+  constructor(runtime, taskFnDefinition, params, parent, hostInstance) {
+    super(runtime, taskFnDefinition, parent);
+    this.taskFnDefinition = taskFnDefinition;
+    this.parent = parent;
+    this.hostInstance = hostInstance;
+    this.description = Handlebars3.compile(
+      taskFnDefinition.task.description || taskFnDefinition.task.name || "anonymous_remote_task"
+    )(params);
+    this.host = hostInstance || parent.host;
+    if (!this.host) {
+      throw new Error("RemoteInvocation must have a host.");
+    }
+    this.config = this.runtime.app.config;
+    this.file = {
+      read: async (filePath) => {
+        const sftp = await this.ensureSftp();
+        const remotePath = this.resolveRemotePath(filePath);
+        return new Promise((resolve, reject) => {
+          sftp.readFile(remotePath, (err, data) => {
+            if (err) {
+              return reject(err);
+            }
+            if (!data) {
+              return reject(new Error(`SFTP readFile returned no data for ${remotePath}`));
+            }
+            resolve(data.toString("utf-8"));
+          });
+        });
+      },
+      write: async (filePath, content, options) => {
+        const sftp = await this.ensureSftp();
+        const remotePath = this.resolveRemotePath(filePath);
+        await sftp.writeFile(remotePath, content, { mode: options?.mode });
+      },
+      exists: async (filePath) => {
+        const sftp = await this.ensureSftp();
+        const remotePath = this.resolveRemotePath(filePath);
+        return new Promise((resolve, reject) => {
+          sftp.stat(remotePath, (err, stats) => {
+            if (err) {
+              const sftpError = err;
+              if (sftpError.code === 2 || sftpError.code === "ENOENT" || typeof err.message === "string" && (err.message.includes("No such file") || err.message.includes("No such entity"))) {
+                resolve(false);
+              } else {
+                reject(err);
+              }
+            } else {
+              resolve(true);
+            }
+          });
+        });
+      },
+      mkdir: async (dirPath, options) => {
+        const remoteDir = this.resolveRemotePath(dirPath);
+        let command = `mkdir ${options?.recursive ? "-p " : ""}${this.quoteRemoteArg(remoteDir)}`;
+        await this.exec(command);
+        if (options?.mode) {
+          await this.exec(`chmod ${this.quoteRemoteArg(String(options.mode))} ${this.quoteRemoteArg(remoteDir)}`);
+        }
+      },
+      rm: async (itemPath, options) => {
+        const remoteItem = this.resolveRemotePath(itemPath);
+        const command = `rm ${options?.recursive ? "-r " : ""}${options?.force ? "-f " : ""}${this.quoteRemoteArg(remoteItem)}`;
+        await this.exec(command);
+      }
+    };
+  }
+  config;
+  file;
+  async ensureSftp() {
+    if (!(this.runtime instanceof RemoteRuntime)) {
+      throw new Error("Runtime is not a RemoteRuntime instance, cannot ensure SFTP.");
+    }
+    return this.runtime.getSftpClient();
+  }
+  resolveRemotePath(p) {
+    return p;
+  }
+  quoteRemoteArg(arg) {
+    return "'" + arg.replace(/'/g, "'\\''") + "'";
+  }
+  log(level, ...message) {
+    const hostUri = this.host ? `${this.host.user || ""}@${this.host.hostname}` : "unknown-host";
+    this.runtime.app.log(level, `[${hostUri}|${this.id}|${this.description || "task"}]`, ...message);
+  }
+  uri() {
+    if (!this.host) throw new Error("Host is not defined for this remote invocation.");
+    return `${this.host.user || this.runtime.app.defaultSshUser()}@${this.host.hostname}`;
+  }
+  async exec(command, options) {
+    if (!this.host) throw new Error("Host is not defined for exec command in RemoteInvocation.");
+    if (!(this.runtime instanceof RemoteRuntime)) {
+      throw new Error("Runtime is not a RemoteRuntime instance, cannot execute remote command.");
+    }
+    const stdinForRemoteCommand = options?.stdin;
+    const execSpecificInteractionHandler = this.runtime.interactionHandler.clone();
+    if (options?.input) {
+      execSpecificInteractionHandler.mapInput(options.input);
+    }
+    if (options?.sudo) {
+      const hostPassword = await this.runtime.getPassword();
+      execSpecificInteractionHandler.mapInput(withSudo(hostPassword));
+    }
+    this.debug(`Executing remote command on ${this.host.hostname}: ${command}`);
+    const cmdOrErr = await this.runtime.executeCommand(command, {
+      cwd: options?.cwd,
+      stdin: stdinForRemoteCommand,
+      pty: options?.pty,
+      env: options?.env,
+      interactionHandler: execSpecificInteractionHandler
+      // Pass the potentially augmented handler
+    });
+    return match(cmdOrErr).with(P.instanceOf(Error), (err) => {
+      throw err;
+    }).with(P.instanceOf(Command), (command2) => {
+      return command2.result;
+    }).exhaustive();
+  }
+  exit(exitCode, message) {
+    const hostUri = this.host ? `${this.host.user || ""}@${this.host.hostname}` : "unknown-host";
+    const msg = `Remote task ${this.id} on ${hostUri} requested exit with code ${exitCode}${message ? ": " + message : ""}`;
+    this.log(Verbosity.WARN, msg);
+    throw new Error(msg);
+  }
+  inventory(tags) {
+    return this.runtime.app.queryInventory(new Set(tags));
+  }
+  async run(taskPartialFn) {
+    return taskPartialFn(this);
+  }
+  async invokeChildTask(childTaskFnDefinition, params) {
+    if (!this.host) throw new Error("Host is not defined for invokeChildTask in RemoteInvocation.");
+    const childInvocation = new _RemoteInvocation(this.runtime, childTaskFnDefinition, params, this, this.host);
+    await this.appendChildInvocation(childInvocation);
+    this.runtime.app.taskTree.add(
+      childInvocation.id,
+      this.id,
+      childTaskFnDefinition.task.name || "anonymous_remote_child_task",
+      childInvocation.result.then((r) => r === null ? void 0 : r)
+    );
+    const taskContext = this.runtime.app.taskContextForRunFn(
+      childInvocation,
+      params,
+      this.host
+    );
+    try {
+      const result = await childTaskFnDefinition.task.runFn.call(childInvocation, taskContext);
+      childInvocation.resolveResult(result);
+      return result;
+    } catch (error) {
+      childInvocation.rejectResult(error);
+      throw error;
+    }
+  }
+  // End of invokeChildTask method
+  ssh(tags, remoteTaskFn) {
+    throw new Error("ssh from a remote host is not currently supported.");
+  }
+};
+var RemoteRuntime = class {
+  sftpClientInstance;
+  // Type should be SFTPWrapper from 'node-ssh'
+  app;
+  host;
+  interactionHandler;
+  sshSession;
+  constructor(app, host, _localRuntime, interactionHandler = new InteractionHandler()) {
+    this.app = app;
+    this.host = host;
+    this.interactionHandler = interactionHandler;
+    this.sshSession = new SSHSession();
+  }
+  get tmpDirRootPath() {
+    return new Path("/tmp");
+  }
+  async getPassword() {
+    return await this.host.decryptedPassword();
+  }
+  async getSecret(name) {
+    const secret = this.app.config.getSecret(name);
+    if (!secret) {
+      this.app.warn(`Secret ${name} not found in config.`);
+      return void 0;
+    }
+    return secret.plaintext();
+  }
+  getTmpDir() {
+    return this.tmpDirRootPath.join(this.app.randName());
+  }
+  getTmpFile(prefix, postfix, dir) {
+    const tmpDir = dir || this.getTmpDir();
+    return tmpDir.join(this.app.randName());
+  }
+  inventory(tags) {
+    return this.app.queryInventory(new Set(tags));
+  }
+  async connect() {
+    if (this.sshSession.isConnected() && this.sftpClientInstance) {
+      this.app.debug(`RemoteRuntime: SSH session and SFTP already connected to ${this.host.uri}`);
+      return true;
+    }
+    this.app.debug(`RemoteRuntime: Connecting SSH to ${this.host.uri}...`);
+    const sshConnectOpts = {
+      host: this.host.hostname,
+      // Changed from this.host.host
+      username: this.host.user || this.app.defaultSshUser(),
+      // Assuming defaultSshUser on App
+      port: this.host.port,
+      // node-ssh parses port from host string if present
+      privateKey: await this.host.plaintextSshKeyPath(),
+      password: await this.host.decryptedPassword()
+    };
+    try {
+      if (!this.sshSession.isConnected()) {
+        await this.sshSession.connect(sshConnectOpts);
+        this.app.debug(`RemoteRuntime: SSH connected to ${this.host.uri}`);
+      }
+      this.app.debug(`RemoteRuntime: Requesting SFTP client for ${this.host.uri}`);
+      this.sftpClientInstance = await this.sshSession.sftp();
+      this.app.debug(`RemoteRuntime: SFTP client ready for ${this.host.uri}`);
+    } catch (e) {
+      this.app.error(`RemoteRuntime: SSH connection or SFTP setup to ${this.host.uri} failed: ${e.message}`);
+      if (this.sshSession.isConnected()) {
+        await this.sshSession.disconnect().catch((err) => {
+          this.app.error(`RemoteRuntime: Error during disconnect after failed connect/sftp: ${err.message}`);
+        });
+      }
+      this.sftpClientInstance = void 0;
+      throw e;
+    }
+    return this.sshSession.isConnected();
+  }
+  async getSftpClient() {
+    await this.connect();
+    if (!this.sftpClientInstance) {
+      throw new Error(`SFTP client not available on SSHSession for ${this.host.uri} after connect call.`);
+    }
+    return this.sftpClientInstance;
+  }
+  async executeCommand(command, options) {
+    this.app.debug(`RemoteRuntime: Executing on ${this.host.uri}: ${command}`);
+    const handlerToUse = options?.interactionHandler || this.interactionHandler;
+    let cmdOrErr;
+    try {
+      if (options?.pty || handlerToUse !== this.interactionHandler) {
+        this.app.debug(`RemoteRuntime: Executing command on ${this.host.uri} via sshSession.run (PTY/custom handler)`);
+        const commandObj = await this.sshSession.run(command, handlerToUse, {
+          cwd: options?.cwd,
+          stdin: options?.stdin,
+          pty: options?.pty,
+          env: options?.env
+        });
+        cmdOrErr = commandObj;
+      } else {
+        this.app.debug(
+          `RemoteRuntime: Executing command on ${this.host.uri} via sshSession.execCommand (no PTY/default handler)`
+        );
+        const actualCommand = Array.isArray(command) ? command.join(" ") : command;
+        const commandObj = await this.sshSession.execCommand(actualCommand, {
+          cwd: options?.cwd,
+          stdin: options?.stdin,
+          env: options?.env
+        });
+        cmdOrErr = commandObj;
+      }
+      this.app.logHostCommandResult(this.host, command, cmdOrErr);
+    } catch (e) {
+      this.app.error(`RemoteRuntime: executeCommand failed for '${command}': ${e.message}`);
+      this.app.error(e.stack);
+      cmdOrErr = e;
+      this.app.logHostCommandResult(this.host, command, cmdOrErr);
+    }
+    return cmdOrErr;
+  }
+  async disconnect() {
+    if (this.sshSession.isConnected()) {
+      this.app.debug(`RemoteRuntime: Disconnecting SSH from ${this.host.uri}`);
+      this.sftpClientInstance = void 0;
+      await this.sshSession.disconnect();
+    }
+  }
+  async invokeRootTask(taskFnDefinition, params) {
+    await this.connect();
+    if (!this.sshSession) throw new Error("SSH session not established for invokeRootTask.");
+    const rootInvocation = new RemoteInvocation(
+      this,
+      taskFnDefinition,
+      params,
+      { runtime: this, host: this.host },
+      this.host
+    );
+    this.app.taskTree.add(
+      rootInvocation.id,
+      null,
+      taskFnDefinition.task.name || `remote_root_task_on_${this.host.hostname}`,
+      // Changed host to hostname
+      rootInvocation.result.then((r) => r === null ? void 0 : r)
+    );
+    const taskContext = this.app.taskContextForRunFn(rootInvocation, params, this.host);
+    taskFnDefinition.task.runFn.call(rootInvocation, taskContext).then(rootInvocation.resolveResult).catch(rootInvocation.rejectResult);
+    return rootInvocation;
+  }
+};
+
+// src/node-runtime.ts
+import os2 from "os";
+import axios from "axios";
+import * as cheerio from "cheerio";
+import { match as match3 } from "ts-pattern";
+import which from "which";
+
+// src/http.ts
+import { createWriteStream, unlink } from "fs";
+import { get } from "https";
+async function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(dest, { flags: "wx" });
+    const request = get(url, (response) => {
+      if (response.statusCode === 200) {
+        response.pipe(file);
+      } else {
+        file.close();
+        unlink(dest, () => {
+        });
+        reject(`Server responded with ${response.statusCode}: ${response.statusMessage}`);
+      }
+    });
+    request.on("error", (err) => {
+      file.close();
+      unlink(dest, () => {
+      });
+      reject(err.message);
+    });
+    file.on("finish", () => {
+      resolve(dest.toString());
+    });
+    file.on("error", (err) => {
+      file.close();
+      if (err.code === "EEXIST") {
+        reject(new Error("File already exists"));
+      } else {
+        unlink(dest, () => {
+        });
+        reject(err.message);
+      }
+    });
+  });
+}
+
+// src/shell-command.ts
+import spawnAsync2 from "@expo/spawn-async";
+import { signalsByName as signalsByName2 } from "human-signals";
+var ShellCommand = class _ShellCommand extends Command {
+  static fromString(command, env, cwd) {
+    const { cmd, args } = this.parse(command, env);
+    return new _ShellCommand({ cmd, args, cwd, env });
+  }
+  async run() {
+    try {
+      const resultPromise = spawnAsync2(this.cmd, this.args, {
+        cwd: this.cwd,
+        env: this.env
+        // shell: true
+      });
+      let { pid, stdout, stderr, status, signal } = await resultPromise;
+      const signalObj = signal && signalsByName2[signal] || void 0;
+      const commandResult = new CommandResult(stdout || "", stderr || "", status || 0, signalObj);
+      this.result = commandResult;
+    } catch (e) {
+      const error = e;
+      if (error.message) console.error(error.message);
+      if (error.stack) console.error(error.stack);
+      let { pid, stdout, stderr, status, signal } = error;
+      const signalObj = signal && signalsByName2[signal] || void 0;
+      const commandResult = new CommandResult(stdout || "", stderr || "", status || 1, signalObj);
+      this.result = commandResult;
+    }
+    return this.result;
+  }
+};
+
+// src/unarchive.ts
+import decompress from "decompress";
+import decompressTarGzPlugin from "decompress-targz";
+import decompressZipPlugin from "decompress-unzip";
+import { match as match2, P as P2 } from "ts-pattern";
+import decompressTarPlugin from "decompress-tar";
+import { fileTypeFromBuffer } from "file-type";
+import { getStreamAsBuffer } from "get-stream";
+import xzdecompress from "xz-decompress";
+async function unarchive(inputPath, outputPath) {
+  const filename = File.basename(inputPath);
+  return await match2(filename).with(P2.string.regex(/.tar.xz$/), () => decompressTarXz(inputPath, outputPath)).with(P2.string.regex(/.tar.gz$/), () => decompressTarGz(inputPath, outputPath)).with(P2.string.regex(/.zip$/), () => decompressZip(inputPath, outputPath)).otherwise(() => {
+    throw new Error(`unable to decompress unknown file type: ${inputPath}`);
+  });
+}
+async function decompressTarGz(inputPath, outputPath, dropRootDir = 1) {
+  await decompress(inputPath, outputPath, {
+    plugins: [decompressTarGzPlugin()],
+    strip: dropRootDir
+  });
+}
+async function decompressTarXzPlugin(input) {
+  const type = await fileTypeFromBuffer(input);
+  if (!type || type.ext !== "xz") {
+    return [];
+  }
+  const blob = new Blob([input]);
+  const webReadableStream = blob.stream();
+  const xzStream = new xzdecompress.XzReadableStream(webReadableStream);
+  const decompressedBuffer = await getStreamAsBuffer(xzStream);
+  return decompressTarPlugin()(decompressedBuffer);
+}
+async function decompressTarXz(inputPath, outputPath, dropRootDir = 1) {
+  await decompress(inputPath, outputPath, {
+    plugins: [decompressTarXzPlugin],
+    strip: dropRootDir
+  });
+}
+async function decompressZip(inputPath, outputPath, dropRootDir = 1) {
+  await decompress(inputPath, outputPath, {
+    plugins: [decompressZipPlugin()],
+    strip: dropRootDir
+  });
+}
+
+// src/node-runtime.ts
+var NodeRuntime = class _NodeRuntime {
+  constructor(tmpDir) {
+    this.tmpDir = tmpDir;
+    this.client = axios.create({
+      baseURL: "https://nodejs.org/"
+    });
+    this.alreadyInstalled = false;
+    this.localNode = this.tmpDir.join(_NodeRuntime.Name, "bin", "node");
+    this.localNpm = this.tmpDir.join(_NodeRuntime.Name, "bin", "npm");
+  }
+  static Name = "nodejs";
+  client;
+  alreadyInstalled;
+  localNode;
+  localNpm;
+  async isNodeInstalledGlobally() {
+    const result = await ShellCommand.fromString(`node --version`).run();
+    return result.success;
+  }
+  async isNodeInstalledLocally() {
+    const result = await ShellCommand.fromString(`${this.localNode} --version`).run();
+    return result.success;
+  }
+  async isNpmInstalledGlobally() {
+    const result = await ShellCommand.fromString(`npm --version`).run();
+    return result.success;
+  }
+  async isNpmInstalledLocally() {
+    const result = await ShellCommand.fromString(`${this.localNpm} --version`).run();
+    return result.success;
+  }
+  async nodeCmd() {
+    if (await this.isNodeInstalledGlobally()) return "node";
+    if (await this.isNodeInstalledLocally()) return this.localNode.toString();
+    throw new Error("node not installed");
+  }
+  async nodePath() {
+    if (await this.isNodeInstalledGlobally()) {
+      return await which("node", { nothrow: true });
+    }
+    if (await this.isNodeInstalledLocally()) return this.localNode.toString();
+    return null;
+  }
+  async npmCmd() {
+    if (await this.isNpmInstalledGlobally()) return "npm";
+    if (await this.isNpmInstalledLocally()) return this.localNpm.toString();
+    throw new Error("npm not installed");
+  }
+  async npmPath() {
+    if (await this.isNpmInstalledGlobally()) {
+      return await which("npm", { nothrow: true });
+    }
+    if (await this.isNpmInstalledLocally()) return this.localNpm.toString();
+    return null;
+  }
+  async installIfNeeded() {
+    if (this.alreadyInstalled || await this.isNodeInstalledGlobally() || await this.isNodeInstalledLocally()) {
+      this.alreadyInstalled = true;
+      return;
+    }
+    return this.install();
+  }
+  async install() {
+    const platform2 = os2.platform();
+    const arch = os2.arch();
+    const packagePath = await this.downloadNodePackage(platform2, arch);
+    const unzipDir = await this.unzipPackage(packagePath);
+    this.alreadyInstalled = true;
+    return unzipDir;
+  }
+  async listPackages() {
+    const response = await this.client.get(`/dist/latest/`);
+    const doc = await cheerio.load(response.data);
+    const allFileLinks = doc("a").map((i, el) => doc(el).attr("href")).toArray();
+    const archiveFiles = A2(allFileLinks).select((filename) => filename.match(/.*\.(gz|zip|xz)/));
+    const urls = A2(archiveFiles).map((filename) => `https://nodejs.org/dist/latest/${filename}`);
+    return urls;
+  }
+  // returns the path to the downloaded zip file
+  async downloadNodePackage(platform2, arch) {
+    const platformInFilename = match3(platform2).with("linux", () => "linux").with("win32", () => "win").with("darwin", () => "darwin").otherwise(() => "unknown-platform");
+    const archInFilename = match3(arch).with("x64", () => "x64").with("x86", () => "x86").with("arm", () => "armv7l").with("arm64", () => "arm64").otherwise(() => "unknown-arch");
+    const packages = await this.listPackages();
+    const url = A2(packages).find((url2) => url2.match(`node-v.*-${platformInFilename}-${archInFilename}`));
+    if (V.isAbsent(url)) {
+      throw new Error(`Unable to download node for ${os2}/${arch} OS/architecture`);
+    }
+    const filename = File.basename(url);
+    const path3 = this.tmpDir.join(filename);
+    if (path3.exists()) return path3.toString();
+    return await downloadFile(url, path3.toString());
+  }
+  // returns the path to the unzipped package directory
+  async unzipPackage(packagePath) {
+    const dir = this.tmpDir.join(_NodeRuntime.Name);
+    if (dir.exists()) return dir.toString();
+    await unarchive(packagePath, dir.toString());
+    return dir.toString();
+  }
+  async npmInstall(omitDev = true, cwd) {
+    if (omitDev) {
+      return this.npm("install --omit=dev", cwd);
+    } else {
+      return this.npm("install", cwd);
+    }
+  }
+  async npm(npmArgs, cwd) {
+    const npmCmd = await this.npmCmd();
+    const env = O(process.env).select(([_, v]) => !!v);
+    return ShellCommand.fromString(`${npmCmd} ${npmArgs}`.trim(), env, cwd).run();
+  }
+  async node(nodeArgs, cwd) {
+    const nodeCmd = await this.nodeCmd();
+    const env = O(process.env).select(([_, v]) => !!v);
+    return ShellCommand.fromString(`${nodeCmd} ${nodeArgs}`.trim(), env, cwd).run();
+  }
+};
+
+// src/zip.ts
+import AdmZip from "adm-zip";
+async function zipDirectory(sourceDir, outputFilePath) {
+  const zip2 = new AdmZip();
+  zip2.addLocalFolder(sourceDir);
+  await zip2.writeZipPromise(outputFilePath);
+  return outputFilePath;
+}
+async function unzipDirectory(inputFilePath, outputDirectory) {
+  const zip2 = new AdmZip(inputFilePath);
+  return new Promise((resolve, reject) => {
+    zip2.extractAllToAsync(outputDirectory, true, false, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(outputDirectory);
+      }
+    });
+  });
+}
+
+// src/hash.ts
+import { createHash } from "crypto";
+function sha256(str) {
+  return createHash("sha256").update(str).digest("hex");
+}
+
+// src/param-map.ts
+import { match as match4 } from "ts-pattern";
+var ParamMap = class _ParamMap {
+  static parse(cliArguments) {
+    const root = new _ParamMap();
+    A2(cliArguments).each((arg) => {
+      const idx = arg.indexOf(":");
+      if (idx === -1) {
+        root.set(arg, "true");
+        return;
+      }
+      const key = arg.slice(0, idx);
+      const value = arg.slice(idx + 1);
+      root.set(key, value);
+    });
+    return root;
+  }
+  map;
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  get(keyPath) {
+    try {
+      return A2(keyPath.split(":")).reduce(
+        (node, key) => node.get(key),
+        this.map
+      );
+    } catch (e) {
+      return void 0;
+    }
+  }
+  set(keyPath, value) {
+    const keyParts = keyPath.split(":");
+    const paramMap = A2(keyParts).skipLast(1).reduce((node, key2) => {
+      let nextNode = node.get(key2);
+      if (nextNode) return nextNode;
+      const newParamMap = new _ParamMap();
+      node.set(key2, newParamMap);
+      return newParamMap;
+    }, this.map);
+    const key = A2(keyParts).last(1)[0];
+    paramMap.set(key, value);
+  }
+  toObject() {
+    let obj = {};
+    M(this.map).each(([k, v]) => {
+      obj[k] = match4(v).when(V.isA(String), (str) => this.stringToJsonObj(str)).otherwise(() => {
+        return v.toObject();
+      });
+    });
+    return obj;
+  }
+  stringToJsonObj(str) {
+    return match4(str).when(matches(/(.*,)+/g), (str2) => {
+      return VP(str2.split(",")).map((s) => s.trim()).compact([""]).map((s) => this.stringToJsonObj(s)).value;
+    }).when(isNumeric, (str2) => parseFloat(str2)).otherwise(() => str);
+  }
+};
+
+// src/version.ts
+var version = "0.1.32";
+
+// src/app.ts
+import { retryUntilDefined } from "ts-retry";
+import { Mutex as Mutex3 } from "async-mutex";
+import { match as match5 } from "ts-pattern";
+
+// src/core/remote/runAllRemote.ts
+async function run(context) {
+  const { params, ssh } = context;
+  const { taskFn, params: taskParams } = params;
+  return await ssh([], async (remoteContext) => {
+    const hostIdentifier = remoteContext.host?.alias || remoteContext.host?.shortName || "unknown_remote_host";
+    remoteContext.debug(`[${hostIdentifier}] Connected via SSH.`);
+    try {
+      const result = await remoteContext.run(taskFn(taskParams));
+      remoteContext.debug(`[${hostIdentifier}] Remote task result:`, JSON.stringify(result));
+      return result;
+    } catch (e) {
+      remoteContext.debug(`[${hostIdentifier}] Failed to run remote task:`, e.message);
+      return e;
+    }
+  });
+}
+var runAllRemote_default = task(run, {
+  description: "run a task on all selected hosts"
+});
+
+// src/app.ts
+var TaskTree = class {
+  // private taskEventBus: Emittery<{ newTask: NewTaskEvent; taskComplete: TaskCompleteEvent }>;
+  listr;
+  subLists;
+  nodes;
+  mutex;
+  constructor() {
+    this.mutex = new Mutex3();
+    this.nodes = /* @__PURE__ */ new Map();
+    this.subLists = /* @__PURE__ */ new Map();
+    this.listr = new Listr([], {
+      // exitOnError: false,
+      concurrent: true,
+      rendererOptions: { collapseSubtasks: false }
+    });
+  }
+  clear() {
+    this.nodes.clear();
+    this.subLists.clear();
+    this.listr = new Listr([], {
+      // exitOnError: false,
+      concurrent: true,
+      rendererOptions: { collapseSubtasks: false }
+    });
+  }
+  async add(id, parentId, name, result) {
+    return await this.mutex.runExclusive(async () => {
+      const parent = this.get(parentId);
+      const newNode = { id, parentId, parent, children: /* @__PURE__ */ new Set(), name, result };
+      this.nodes.set(id, newNode);
+      this.listr.add({
+        title: newNode.name,
+        task: async (ctx, task3) => {
+          await result;
+        }
+      });
+      return newNode;
+    });
+  }
+  get(id) {
+    return this.nodes.get(id);
+  }
+  async getWithTimeout(id) {
+    try {
+      return await retryUntilDefined(
+        () => {
+          return this.get(id);
+        },
+        { delay: 50, maxTry: 5 }
+      );
+    } catch (err) {
+      return void 0;
+    }
+  }
+  // setResult(id: string, result: Promise<string | Error | undefined>): TaskTreeNode | undefined {
+  //   const node = this.get(id);
+  //   if (node) {
+  //     node.result = result;
+  //   }
+  //   return node;
+  // }
+  run(ctx) {
+    return this.listr.run(ctx);
+  }
+  // emit(name: any, event: any) {
+  //   this.taskEventBus.emit(name, event);
+  // }
+};
+var Verbosity = {
+  ERROR: 0,
+  WARN: 1,
+  INFO: 2,
+  DEBUG: 3,
+  TRACE: 4
+};
+var App = class {
+  configRef;
+  _config;
+  selectedTags;
+  outputStyle;
+  _tmpDir;
+  tmpFileRegistry;
+  taskTree;
+  verbosity = Verbosity.ERROR;
+  constructor() {
+    this.taskTree = new TaskTree();
+    this.selectedTags = /* @__PURE__ */ new Set([]);
+    this.outputStyle = "plain";
+    this.tmpFileRegistry = new TmpFileRegistry(this.hostctlTmpDir());
+    this.configRef = void 0;
+    process3.on("exit", (code) => this.appExitCallback());
+  }
+  appExitCallback() {
+  }
+  get config() {
+    if (!this._config) {
+      throw new Error("Configuration has not been loaded. Call loadConfig() first.");
+    }
+    return this._config;
+  }
+  get tmpDir() {
+    if (!this._tmpDir) {
+      if (!fs6.existsSync(this.hostctlDir().toString())) {
+        fs6.mkdirSync(this.hostctlDir().toString(), { recursive: true });
+      }
+      this._tmpDir = this.createNamedTmpDir(version);
+    }
+    return this._tmpDir;
+  }
+  async loadConfig(configString) {
+    this.configRef = configString;
+    this._config = await load(configString);
+  }
+  log(level, ...args) {
+    if (this.outputStyle === "plain" && this.verbosity >= level) {
+      console.log(...args);
+    }
+  }
+  debug(...args) {
+    this.log(Verbosity.DEBUG, ...args);
+  }
+  info(...args) {
+    this.log(Verbosity.INFO, ...args);
+  }
+  warn(...args) {
+    this.log(Verbosity.WARN, ...args);
+  }
+  error(...args) {
+    this.log(Verbosity.ERROR, ...args);
+  }
+  osHomeDir() {
+    return Path.new(homedir3()).absolute();
+  }
+  hostctlDir() {
+    return this.osHomeDir().join(".hostctl");
+  }
+  hostctlTmpDir() {
+    return this.hostctlDir().join("tmp");
+  }
+  randName() {
+    return Math.random().toString(36).slice(-5) + Math.random().toString(36).slice(-5);
+  }
+  hostctlTmpPath(tmpName) {
+    tmpName ??= this.randName();
+    return this.hostctlTmpDir().join(tmpName);
+  }
+  // this directory will be automatically cleaned up at program exit
+  createNamedTmpDir(subDirName) {
+    return this.tmpFileRegistry.createNamedTmpDir(subDirName);
+  }
+  // this file will be automatically cleaned up at program exit
+  writeTmpFile(fileContent) {
+    return this.tmpFileRegistry.writeTmpFile(fileContent);
+  }
+  shouldRunRemote() {
+    const selectedHosts = this.selectedInventory();
+    if (selectedHosts.length === 0 && this.selectedTags.size === 0) return false;
+    return selectedHosts.some((h) => !h.isLocal());
+  }
+  logHostCommandResult(host, command, cmdOrErr, isErrorResult = false) {
+    const hostName = host.uri || (host.isLocal() ? "localhost" : "unknown-host");
+    if (cmdOrErr instanceof Error || isErrorResult) {
+      const error = cmdOrErr;
+      this.debug(chalk4.red(`[${hostName}] Error executing command "${command}": ${error.message}`));
+      if (error.stack && this.verbosity >= Verbosity.DEBUG) {
+        this.debug(chalk4.red(error.stack));
+      }
+    } else {
+      const cmdRes = cmdOrErr.result;
+      this.debug(chalk4.green(`[${hostName}] Success executing "${command}" (exit code: ${cmdRes.exitCode})`));
+      if (cmdRes.stdout) {
+        this.debug(chalk4.cyan(`[${hostName}] STDOUT:
+${cmdRes.stdout.trim()}`));
+      }
+      if (cmdRes.stderr) {
+        this.debug(chalk4.yellow(`[${hostName}] STDERR:
+${cmdRes.stderr.trim()}`));
+      }
+    }
+  }
+  defaultSshUser() {
+    return void 0;
+  }
+  // entrypoint for the cli: AGE_IDS=~/.secrets/age/test-jill.priv tsx bin/ops.ts e whoami -t ubuntu
+  // e.g. AGE_IDS=~/.secrets/age/david.priv tsx bin/ops.ts -c david.yaml exec "whoami" -t synology blog 4gb web1
+  async execute(cmd) {
+    const selectedHosts = this.selectedInventory();
+    const cmdResults = A2(selectedHosts).map((host) => this.runRemote(host, cmd));
+    const hostResultQuads = await VP(selectedHosts).a.zip(cmdResults).a.map(([host, cmdPromise]) => {
+      return cmdPromise.then(
+        (cmd2) => match5(cmd2).when(isError2, (err) => [host, false, "", chalk4.red(err.message)]).otherwise((cmd3) => [host, cmd3.result?.success ?? false, cmd3.result?.stdout, cmd3.result?.stderr])
+      );
+    }).waitAll().value;
+    if (this.outputStyle === "plain") {
+      this.warn(chalk4.yellow("=== Result ==="));
+      A2(hostResultQuads).each(([host, success, stdout, stderr]) => {
+        this.warn(
+          `${success ? chalk4.green(CHECKMARK) : chalk4.red(XMARK)} ${chalk4.cyan(host.hostname)}${host.alias ? ` (${host.alias})` : ""}`
+        );
+        if (stdout) {
+          this.warn(stdout);
+        }
+        if (stderr) {
+          this.warn(chalk4.red(stderr));
+        }
+        this.warn(chalk4.yellow("--------------"));
+      });
+    } else if (this.outputStyle === "json") {
+      const result = A2(hostResultQuads).reduce(
+        (acc, [host, success, stdout, stderr]) => {
+          acc[host.hostname] = {
+            alias: host.alias || "",
+            success,
+            stdout,
+            stderr
+          };
+          return acc;
+        },
+        {}
+      );
+      console.log(JSON.stringify(result, null, 2));
+    }
+    return hostResultQuads.every(([_, success]) => success);
+  }
+  // used by execute to run a command on the remote host
+  async runRemote(host, cmd) {
+    try {
+      const hostPassword = await host.decryptedPassword();
+      const sshConnection = {
+        host: host.uri,
+        username: host.user,
+        password: hostPassword,
+        privateKeyPath: await host.plaintextSshKeyPath()
+      };
+      const interactionHandler = InteractionHandler.with(withSudo(hostPassword));
+      const session = new SSHSession();
+      await session.connect(sshConnection);
+      const commandObj = await session.run(cmd, interactionHandler);
+      session.disconnect();
+      return commandObj;
+    } catch (e) {
+      return e;
+    }
+  }
+  getSecretsForHost(hostId) {
+    const secretsMap = /* @__PURE__ */ new Map();
+    if (!this._config) {
+      return secretsMap;
+    }
+    return secretsMap;
+  }
+  taskContextForRunFn(invocation, params, hostForContext) {
+    const effectiveHost = hostForContext || invocation.host;
+    return {
+      // Properties from TaskContext
+      params,
+      id: invocation.id,
+      host: effectiveHost,
+      config: invocation.config,
+      // Delegated from invocation
+      // Methods from TaskContext, delegating to invocation
+      log: (level, ...message) => {
+        invocation.log(level, ...message);
+      },
+      info: (...message) => {
+        invocation.info(...message);
+      },
+      debug: (...message) => {
+        invocation.debug(...message);
+      },
+      warn: (...message) => {
+        invocation.warn(...message);
+      },
+      error: (...message) => {
+        invocation.error(...message);
+      },
+      exec: async (command, options) => {
+        return await invocation.exec(command, options);
+      },
+      ssh: async (tags, remoteTaskFn) => {
+        return await invocation.ssh(tags, remoteTaskFn);
+      },
+      run: async (taskPartialFn) => {
+        return await invocation.run(taskPartialFn);
+      },
+      getPassword: async () => {
+        return await invocation.getPassword();
+      },
+      getSecret: async (name) => {
+        return await invocation.getSecret(name);
+      },
+      exit: (exitCode, message) => {
+        invocation.exit(exitCode, message);
+      },
+      inventory: (tags) => {
+        return invocation.inventory(tags);
+      },
+      file: invocation.file
+    };
+  }
+  setSelectedTags(selectedTags) {
+    this.selectedTags = new Set(selectedTags);
+  }
+  setOutputStyle(outputStyle) {
+    this.outputStyle = outputStyle;
+  }
+  setVerbosity(level) {
+    this.verbosity = level;
+  }
+  outputJson() {
+    return this.outputStyle == "json";
+  }
+  outputPlain() {
+    return this.outputStyle == "plain";
+  }
+  querySelectedInventory(tags = []) {
+    return this.selectInventory(this.selectedInventory(), new Set(tags));
+  }
+  selectedInventory() {
+    return this.queryInventory(this.selectedTags);
+  }
+  // returns hosts that have *all* of the given tags
+  // each tag is a string of the form:
+  // - foo
+  // - bar+baz
+  // the tags are interpreted to be in disjunctive-normal-form: a disjunction of conjunctions
+  queryInventory(tags = /* @__PURE__ */ new Set()) {
+    if (!this._config) {
+      this.warn("Warning: Configuration not loaded, cannot query inventory.");
+      return [];
+    }
+    const allHosts = this._config.hosts();
+    if (tags.size === 0) {
+      return allHosts;
+    }
+    return this.selectInventory(allHosts, new Set(tags));
+  }
+  selectInventory(hosts, tags = /* @__PURE__ */ new Set()) {
+    if (S(tags).isEmpty()) {
+      return hosts;
+    }
+    return A2(hosts).select((host) => host.hasAnyTag(tags));
+  }
+  // entrypoint for the cli: AGE_IDS=~/.secrets/age/test-jill.priv tsx bin/hostctl.ts inventory -t ubuntu
+  printInventoryReport() {
+    const configFromGetter = this.config;
+    const config = configFromGetter;
+    const allHosts = config.hosts();
+    const allSecrets = config.secrets();
+    const allIds = config.ids();
+    if (this.outputPlain()) {
+      let output = "Config file: " + this.configRef + "\n\nHosts:\n";
+      if (allHosts.length > 0) {
+        allHosts.forEach((host) => {
+          output += `  - ${host.uri}:
+`;
+          output += `    alias: ${host.alias || ""}
+`;
+          output += `    user: ${host.user || ""}
+`;
+          output += `    port: ${host.port || ""}
+`;
+          output += `    tags: ${host.tags.join(", ")}
+`;
+        });
+      } else {
+        output += "  {}\n";
+      }
+      output += "\nSecrets:\n";
+      if (allSecrets.size > 0) {
+        allSecrets.forEach((secret, name) => {
+          output += `  - ${name}:
+`;
+          output += `    encrypted: ${secret.value.isEncrypted()}
+`;
+        });
+      } else {
+        output += "  {}\n";
+      }
+      output += "\nIdentities (Public Keys):\n";
+      if (allIds.size > 0) {
+        allIds.forEach((idGroup, name) => {
+          output += `  - ${name}:
+`;
+          output += `    publicKeys: ${idGroup.publicKeys.join(", ")}
+`;
+        });
+      } else {
+        output += "  {}\n";
+      }
+      console.log(output.trim());
+    } else if (this.outputJson()) {
+      const jsonData = {
+        hosts: allHosts.map((h) => h.toObject()),
+        secrets: {},
+        identities: {}
+      };
+      allSecrets.forEach((secret, name) => {
+        jsonData.secrets[name] = {
+          name: secret.name,
+          encrypted: secret.value.isEncrypted()
+          // Consider if ids/recipients should be exposed here
+        };
+      });
+      allIds.forEach((idGroup, name) => {
+        jsonData.identities[name] = {
+          name: idGroup.name || name,
+          // Assuming NamedRecipientGroup has a name property
+          publicKeys: idGroup.publicKeys,
+          idRefs: idGroup.idRefs
+        };
+      });
+      console.log(JSON.stringify(jsonData, null, 2));
+    }
+  }
+  // entrypoint for the cli: AGE_IDS=~/.secrets/age/test-david.priv tsx bin/hostctl.ts inventory encrypt
+  async encryptInventoryFile() {
+    if (!this.configRef) {
+      throw new Error("Cannot encrypt inventory: Configuration file reference is not set.");
+    }
+    const currentConfigRef = this.configRef;
+    this.warn(`Encrypting inventory file: ${currentConfigRef}`);
+    const configFile = new ConfigFile2(currentConfigRef);
+    await configFile.load();
+    await configFile.encryptAll();
+    await configFile.save(currentConfigRef);
+  }
+  // entrypoint for the cli: AGE_IDS=~/.secrets/age/david.priv tsx bin/hostctl.ts inventory decrypt
+  async decryptInventoryFile() {
+    if (!this.configRef) {
+      throw new Error("Cannot decrypt inventory: Configuration file reference is not set.");
+    }
+    const currentConfigRef = this.configRef;
+    const configFile = new ConfigFile2(currentConfigRef);
+    await configFile.load();
+    let hasEncryptedSecrets = false;
+    for (const secret of configFile._secrets.values()) {
+      if (secret.value.isEncrypted()) {
+        hasEncryptedSecrets = true;
+        break;
+      }
+    }
+    if (!hasEncryptedSecrets) {
+      this.info("No encrypted secrets found to decrypt. Inventory is already decrypted.");
+      return;
+    }
+    this.warn(`Decrypting inventory file: ${currentConfigRef}`);
+    try {
+      await configFile.decryptAllIfPossible();
+      const successfullyUsedIdentityPaths = configFile.loadPrivateKeys().filter((identity2) => {
+        try {
+          return fs6.existsSync(identity2.identityFilePath);
+        } catch (e) {
+          return false;
+        }
+      }).map((i) => i.identityFilePath).join("\n");
+      if (this.verbosity >= Verbosity.INFO && successfullyUsedIdentityPaths.length > 0) {
+        this.info(`Decrypted with one or more of the following private keys:
+${successfullyUsedIdentityPaths}`);
+      } else if (this.verbosity >= Verbosity.INFO && hasEncryptedSecrets && successfullyUsedIdentityPaths.length === 0) {
+        this.warn("Encrypted secrets found, but no specified AGE identities were successfully used or found.");
+      }
+      await configFile.save(currentConfigRef);
+    } catch (error) {
+      if (error.message?.includes("Unable to read identity file")) {
+        throw new Error("Decryption failed: no identity matched or failed to decrypt due to key issue.");
+      }
+      if (error.message?.includes("No identity matched secret")) {
+        throw new Error("Decryption failed: no identity matched the encrypted secrets.");
+      }
+      throw error;
+    }
+  }
+  // entrypoint for the cli: AGE_IDS=~/.secrets/age/david.priv tsx bin/hostctl.ts -t ubuntu -- script.ts
+  // e.g. AGE_IDS=~/.secrets/age/david.priv tsx bin/hostctl.ts -c david.yaml -t synology blog 4gb web1 -- script.ts
+  async runScript(scriptRef, params) {
+    const selectedHosts = this.selectedInventory();
+    this.info(`Selected hosts: ${selectedHosts.length}`);
+    const absoluteScriptRef = Path.new(scriptRef).absolute();
+    this.debug(`absoluteScriptRef=${absoluteScriptRef}`);
+    this.debug(`params=${util2.inspect(params)}`);
+    const mod = await this.loadScriptAsModule(absoluteScriptRef.toString());
+    this.debug(`mod=${util2.inspect(mod)}`);
+    const packageFileDir = this.pathOfPackageJsonFile(absoluteScriptRef.toString());
+    if (!packageFileDir) {
+      console.error(
+        chalk4.red(`Bundle failure. "${absoluteScriptRef}" nor any ancestor directory contains a package.json file.`)
+      );
+      return;
+    }
+    const taskFn = mod.default;
+    const interactionHandler = new InteractionHandler();
+    const localRuntime = new LocalRuntime(this, absoluteScriptRef, interactionHandler);
+    if (this.outputPlain()) {
+      this.info(`run: ${chalk4.yellow(absoluteScriptRef.toString())} ${chalk4.cyan(util2.inspect(params))}`);
+    }
+    let invocation;
+    let scriptResult;
+    try {
+      invocation = await localRuntime.invokeRootTask(taskFn, params, `Running ${scriptRef}`);
+      if (!invocation) {
+        this.error(`Failed to invoke task for script: ${scriptRef}`);
+        scriptResult = new Error(`Failed to invoke task for script: ${scriptRef}`);
+      } else {
+        scriptResult = await invocation.result;
+        this.reportScriptResult(invocation, scriptResult);
+      }
+    } catch (e) {
+      scriptResult = e;
+      if (this.outputPlain()) {
+        this.error(`Error running script ${scriptRef}: ${scriptResult.message}`);
+        if (this.verbosity >= Verbosity.DEBUG && scriptResult.stack) {
+          this.error(scriptResult.stack);
+        }
+      }
+      if (invocation) {
+        this.reportScriptResult(invocation, scriptResult);
+      }
+    }
+    if (scriptResult instanceof Error) {
+      process3.exit(1);
+    }
+  }
+  // entrypoint for the cli: AGE_IDS=~/.secrets/age/david.priv tsx bin/hostctl.ts -t ubuntu -- script.ts
+  // e.g. AGE_IDS=~/.secrets/age/david.priv tsx bin/hostctl.ts -c david.yaml -t synology blog 4gb web1 -- script.ts
+  async runScriptRemote(scriptRef, params) {
+    const selectedHosts = this.selectedInventory();
+    this.info(`Selected hosts: ${selectedHosts.length}`);
+    const absoluteScriptRef = Path.new(scriptRef).absolute();
+    this.debug(`absoluteScriptRef=${absoluteScriptRef}`);
+    this.debug(`params=${util2.inspect(params)}`);
+    const mod = await this.loadScriptAsModule(absoluteScriptRef.toString());
+    this.debug(`mod=${util2.inspect(mod)}`);
+    const packageFileDir = this.pathOfPackageJsonFile(absoluteScriptRef.toString());
+    if (!packageFileDir) {
+      console.error(
+        chalk4.red(`Bundle failure. "${absoluteScriptRef}" nor any ancestor directory contains a package.json file.`)
+      );
+      return;
+    }
+    const taskFn = mod.default;
+    const interactionHandler = new InteractionHandler();
+    const localRuntime = new LocalRuntime(this, absoluteScriptRef, interactionHandler);
+    this.info(`run: ${chalk4.yellow(absoluteScriptRef.toString())} ${chalk4.cyan(util2.inspect(params))}`);
+    let invocation;
+    let scriptResult;
+    try {
+      const runAllRemoteParams = { taskFn, params };
+      invocation = await localRuntime.invokeRootTask(
+        runAllRemote_default,
+        runAllRemoteParams,
+        `Running ${scriptRef} on selected hosts`
+      );
+      if (!invocation) {
+        this.error(`Failed to invoke task for script: ${scriptRef}`);
+        scriptResult = new Error(`Failed to invoke task for script: ${scriptRef}`);
+      } else {
+        scriptResult = await invocation.result;
+        this.reportScriptResult(invocation, scriptResult);
+      }
+    } catch (e) {
+      scriptResult = e;
+      if (this.outputPlain()) {
+        this.error(`Error running script ${scriptRef}: ${scriptResult.message}`);
+        if (this.verbosity >= Verbosity.DEBUG && scriptResult.stack) {
+          this.error(scriptResult.stack);
+        }
+      }
+      if (invocation) {
+        this.reportScriptResult(invocation, scriptResult);
+      }
+    }
+    if (scriptResult instanceof Error) {
+      process3.exit(1);
+    }
+  }
+  async walkInvocationTreePreorder(invocation, visitFn, visited = /* @__PURE__ */ new Set(), depth = 0) {
+    if (visited.has(invocation)) return;
+    visited.add(invocation);
+    await visitFn(invocation, depth);
+    for (const childInvocation of invocation.getChildren()) {
+      await this.walkInvocationTreePreorder(childInvocation, visitFn, visited, depth + 1);
+    }
+  }
+  async reportScriptResult(invocation, scriptResult) {
+    if (this.outputPlain()) {
+      this.warn("=== Evaluation ===");
+      await this.walkInvocationTreePreorder(invocation, async (invocation2, depth) => {
+        const indent = "  ".repeat(depth);
+        if (invocation2.getDescription() || invocation2.id) {
+          const err = await invocation2.resultError();
+          if (err) {
+            if (this.verbosity >= Verbosity.WARN) {
+              this.warn(
+                `${indent}${chalk4.red(XMARK)} ${invocation2.getDescription() || invocation2.id} ${chalk4.red(util2.inspect(err))}`
+              );
+              if (this.verbosity >= Verbosity.INFO) {
+                this.info(`${indent}  ${chalk4.red(err.message)}`);
+                if (this.verbosity >= Verbosity.DEBUG) {
+                  invocation2.stdout && this.debug(`${indent}  ${chalk4.bgGreen(invocation2.stdout.trimEnd())}`);
+                  invocation2.stderr && this.debug(`${indent}  ${chalk4.bgRed(invocation2.stderr.trimEnd())}`);
+                }
+              }
+            }
+          } else {
+            if (this.verbosity >= Verbosity.WARN) {
+              this.warn(`${indent}${chalk4.green(CHECKMARK)} ${invocation2.getDescription() || invocation2.id}`);
+              if (this.verbosity >= Verbosity.INFO) {
+                this.info(`${indent}  ${chalk4.green(util2.inspect(await invocation2.getResultPromise()))}`);
+                if (this.verbosity >= Verbosity.DEBUG) {
+                  invocation2.stdout && this.debug(`${indent}  ${chalk4.bgGreen(invocation2.stdout.trimEnd())}`);
+                  invocation2.stderr && this.debug(`${indent}  ${chalk4.bgRed(invocation2.stderr.trimEnd())}`);
+                }
+              }
+            }
+          }
+        }
+      });
+      this.warn("=== Result ===");
+      if (isError2(scriptResult)) {
+        this.warn(chalk4.red(`${invocation.getDescription() || invocation.id} failed:`));
+        this.warn(chalk4.red(scriptResult.message));
+        if (scriptResult.stack) {
+          this.warn(chalk4.red(scriptResult.stack));
+        }
+      } else if (scriptResult && typeof scriptResult === "object" && "exitCode" in scriptResult && typeof scriptResult.exitCode === "number") {
+        const exitCode = scriptResult.exitCode;
+        const message = scriptResult.message || "";
+        this.warn(
+          chalk4.yellow(
+            `${invocation.getDescription() || invocation.id} requested exit with code ${exitCode}: ${message}`
+          )
+        );
+      } else if (scriptResult === void 0) {
+        this.warn(chalk4.green(`${invocation.getDescription() || invocation.id} completed successfully.`));
+      } else {
+        this.warn(
+          chalk4.green(
+            `${invocation.getDescription() || invocation.id} completed with result: ${util2.inspect(scriptResult, { depth: 3 })}`
+          )
+        );
+      }
+    } else if (this.outputJson()) {
+      if (!(scriptResult instanceof Error)) {
+        console.log(JSON.stringify(scriptResult, null, 2));
+      } else {
+        const errorJson = {
+          error: scriptResult.message,
+          stack: scriptResult.stack
+        };
+        console.log(JSON.stringify(errorJson, null, 2));
+      }
+    }
+  }
+  async loadScriptAsModule(scriptRef) {
+    const mod = await import(scriptRef);
+    return mod;
+  }
+  parseParams(scriptArgs) {
+    return ParamMap.parse(scriptArgs).toObject();
+  }
+  // this function creates a bundle of a given directory
+  async bundleProject(entrypointPath) {
+    const nodeRuntime = new NodeRuntime(this.tmpDir);
+    const entrypointDir = this.pathOfPackageJsonFile(entrypointPath);
+    if (!entrypointDir) {
+      console.error(
+        chalk4.red(`Bundle failure. "${entrypointPath}" nor any ancestor directory contains a package.json file.`)
+      );
+      return;
+    }
+    const tasks = new Listr([], {
+      exitOnError: false,
+      concurrent: true
+    });
+    tasks.add([
+      {
+        title: `Bundling ${entrypointDir.toString()}`,
+        task: async (ctx) => {
+          await this.generateBundle(nodeRuntime, entrypointDir);
+        }
+      }
+    ]);
+    try {
+      await tasks.run();
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  async generateBundle(nodeRuntime, packageFileDir) {
+    await nodeRuntime.installIfNeeded();
+    const result = await nodeRuntime.npmInstall(true, packageFileDir.toString());
+    if (result.failure) throw new Error(result.err);
+    const absoluteDirPath = packageFileDir.toString();
+    const dirNameHash = sha256(absoluteDirPath).slice(0, 10);
+    const bundleZipFile = this.tmpDir.join(`bundle${dirNameHash}.zip`);
+    const zipPath = await zipDirectory(packageFileDir.toString(), bundleZipFile.toString());
+    return Path.new(zipPath);
+  }
+  // walks the directory tree that contains the given path from leaf to root searching for the deepest directory
+  // containing a package.json file and returns the absolute path of that directory
+  pathOfPackageJsonFile(path3) {
+    let p = Path.new(path3);
+    while (true) {
+      if (p.dirContains("package.json")) {
+        return p.absolute();
+      }
+      if (p.isRoot()) {
+        return null;
+      }
+      p = p.parent();
+    }
+  }
+  async printRuntimeReport() {
+    const nodeRuntime = new NodeRuntime(this.tmpDir);
+    const reportObj = {
+      nodePath: await nodeRuntime.nodePath(),
+      npmPath: await nodeRuntime.npmPath()
+      // summary: report?.getReport(),
+    };
+    this.info(reportObj);
+  }
+  async promptPassword(message = "Enter your password") {
+    return await promptPassword({ message });
+  }
+  async installRuntime() {
+    this.info(`creating node runtime with ${this.tmpDir.toString()}`);
+    const nodeRuntime = new NodeRuntime(this.tmpDir);
+    await nodeRuntime.installIfNeeded();
+  }
+  async bootstrap() {
+  }
+};
+
+// src/cli.ts
+import JSON5 from "json5";
+
+// src/cli/run-resolver.ts
+import { simpleGit } from "simple-git";
+import filenamify from "filenamify";
+import { match as match6 } from "ts-pattern";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+async function resolveScriptPath(app, packageOrBundle, scriptRef, scriptArgs) {
+  if (packageOrBundle && packageOrBundle.startsWith("core.") || !packageOrBundle && scriptRef && scriptRef.startsWith("core.")) {
+    const name = packageOrBundle?.startsWith("core.") ? packageOrBundle : scriptRef;
+    const relPath = name.replace(/^core\./, "").split(".").join(Path.sep());
+    const moduleDir = Path.new(dirname(fileURLToPath(import.meta.url)));
+    const coreRoot = moduleDir.parent().join("core");
+    const candidate = coreRoot.join(`${relPath}.ts`);
+    if (!candidate.isFile()) {
+      throw new Error(`Core task script not found: ${candidate}`);
+    }
+    if (packageOrBundle?.startsWith("core.") && scriptRef) {
+      scriptArgs = [scriptRef, ...scriptArgs];
+    }
+    return { scriptRef: candidate.toString(), scriptArgs };
+  }
+  if (!packageOrBundle) {
+    throw new Error("No bundle or package specified.");
+  }
+  const currentPackageOrBundle = packageOrBundle;
+  let resolvedScriptRef = scriptRef ?? "";
+  await match6(currentPackageOrBundle).when(
+    (path3) => Path.new(path3).isFile() && Path.new(path3).ext() === ".zip",
+    async () => {
+      const tmpName = filenamify(currentPackageOrBundle);
+      const destPath = app.tmpDir.join(tmpName);
+      await unzipDirectory(currentPackageOrBundle, destPath.toString());
+      resolvedScriptRef = destPath.resolve(resolvedScriptRef).toString();
+    }
+  ).when(
+    (path3) => Path.new(path3).isDirectory(),
+    async () => {
+      const tmpName = filenamify(currentPackageOrBundle);
+      const destPath = app.tmpDir.join(tmpName);
+      const pkgPath = Path.new(currentPackageOrBundle);
+      await pkgPath.copy(destPath.toString());
+      resolvedScriptRef = destPath.resolve(resolvedScriptRef).toString();
+    }
+  ).when(isValidUrl, async () => {
+    const tmpName = filenamify(currentPackageOrBundle);
+    const destPath = app.tmpDir.join(tmpName);
+    const git = simpleGit();
+    await git.clone(currentPackageOrBundle, destPath.toString());
+    resolvedScriptRef = destPath.resolve(resolvedScriptRef).toString();
+  }).otherwise(async () => {
+    if (resolvedScriptRef) {
+      A2(scriptArgs).prepend(resolvedScriptRef);
+    }
+    resolvedScriptRef = currentPackageOrBundle;
+  });
+  return { scriptRef: resolvedScriptRef, scriptArgs };
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/cli.ts
+var isError2 = (value) => !!value && typeof value === "object" && "message" in value && typeof value.message === "string" && "stack" in value && typeof value.stack === "string";
+var logError = (message, error) => {
+  console.error(`Error: ${message}`);
+  if (isError2(error)) {
+    console.error(error.stack);
+  } else {
+    try {
+      const unknownError = new Error(
+        `Unexpected value thrown: ${typeof error === "object" ? JSON.stringify(error) : String(error)}`
+      );
+      console.error(unknownError.stack);
+    } catch {
+      console.error(new Error(`Unexpected value thrown: non-stringifiable object`).stack);
+    }
+  }
+};
+function isValidUrl2(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+function increaseVerbosity(dummyValue, previous) {
+  return previous + 1;
+}
+function decreaseVerbosity(dummyValue, previous) {
+  return previous - 1;
+}
+var Cli = class {
+  app;
+  program;
+  constructor() {
+    this.app = new App();
+    this.program = new cmdr.Command();
+    this.program.configureHelp({ showGlobalOptions: true }).name("hostctl").version(version).option("-q, --quiet", "quiet; be less verbose; may be specified multiple times", decreaseVerbosity, 0).option(
+      "-v, --verbose",
+      "verbose; may be specified multiple times for increased verbosity",
+      increaseVerbosity,
+      Verbosity.WARN
+    ).option("-c, --config <file path>", "config file path or http endpoint").option("--json", "output should be json formatted").option("-p, --password", "should prompt for sudo password?", false).option("-t, --tag <tags...>", "specify a tag (repeat for multiple tags)");
+    this.program.command("bundle").alias("b").argument("[path]", `the path to bundle (e.g. hostctl bundle .)`, ".").description("bundle the given path as an npm project").action(this.handleBundle.bind(this));
+    this.program.command("exec").alias("e").argument(
+      "<command...>",
+      `the command string to run, with optional arguments (e.g. hostctl exec sudo sh -c 'echo "$(whoami)"')`
+    ).description("execute a command on the selected hosts (default)").action(this.handleExec.bind(this));
+    const inventoryCmd = this.program.command("inventory").alias("i").description("manage inventory and view reports");
+    inventoryCmd.command("report", { isDefault: true }).description("print out an inventory report (default)").action(this.handleInventory.bind(this));
+    inventoryCmd.command("encrypt").alias("e").description("encrypt the inventory file").action(this.handleInventoryEncrypt.bind(this));
+    inventoryCmd.command("decrypt").alias("d").description("decrypt the inventory file").action(this.handleInventoryDecrypt.bind(this));
+    inventoryCmd.command("list").alias("ls").description("list the hosts in the inventory file").action(this.handleInventoryList.bind(this));
+    this.program.command("run").alias("r").argument(
+      "[package_or_bundle]",
+      `the package or bundle to run the specified <script> from.
+          The package or bundle may be either:
+          - a directory in the local filesystem, e.g. /my/package/foo
+          - a git repository, e.g. https://github.com/hostctl/core
+          - a zipped package (a bundle), e.g. packagebundle123.zip
+        `
+    ).argument(
+      "[script]",
+      `the hostctl script to run (e.g. hostctl run myscript OR hostctl run mypackage myscript).
+          The script may be specified as either:
+          - a package followed by the script, e.g. hostctl run github.com/hostctl/core echo args:hello,world
+          - a script, e.g. hostctl run main.ts
+          - a zipped package (a bundle), e.g. hostctl run packagebundle.zip echo args:hello,world`
+    ).argument("[script arguments...]", "the runtime arguments to the script.").description("run a hostctl script (default)").option(
+      "-f, --file <path>",
+      "runtime parameters should be read from file at <path> containing json object representing params to supply to the script"
+    ).option(
+      '-p, --params "<json object>"',
+      "runtime parameters supplied as a string to be parsed as a json object representing params to supply to the script"
+    ).option("-r, --remote", "run the script on remote hosts specified by tags via SSH orchestration").action(this.handleRun.bind(this));
+    const runtimeCmd = this.program.command("runtime").alias("rt").description("print out a report of the runtime environment").action(this.handleRuntime.bind(this));
+    runtimeCmd.command("install").alias("i").description("install a temporary runtime environment on the local host if needed").action(this.handleRuntimeInstall.bind(this));
+  }
+  async handleBundle(path3, options, cmd) {
+    const opts = cmd.optsWithGlobals();
+    await this.loadApp(opts);
+    this.app.bundleProject(path3);
+  }
+  async handleInventory(options, cmd) {
+    const opts = cmd.optsWithGlobals();
+    await this.loadApp(opts);
+    this.app.printInventoryReport();
+  }
+  async handleInventoryEncrypt(options, cmd) {
+    const opts = cmd.optsWithGlobals();
+    await this.loadApp(opts);
+    await this.app.encryptInventoryFile();
+  }
+  async handleInventoryDecrypt(options, cmd) {
+    const opts = cmd.optsWithGlobals();
+    await this.loadApp(opts);
+    await this.app.decryptInventoryFile();
+  }
+  async handleInventoryList(options, cmd) {
+    const opts = cmd.optsWithGlobals();
+    await this.loadApp(opts);
+    if (!this.app.config) {
+      console.log("Configuration could not be loaded. Cannot list hosts.");
+      if (!this.app.configRef) {
+        console.log("(Also, no configuration file path was found by the app instance)");
+      }
+      return;
+    }
+    console.log("Config file: " + this.app.configRef);
+    const hosts = this.app.selectedInventory();
+    if (hosts.length > 0) {
+      console.log("\nHosts in inventory:");
+      hosts.forEach((host) => {
+        let hostIdentifier = host.shortName || "(Unnamed host)";
+        console.log(`  - ${hostIdentifier}`);
+        if (host.tags && host.tags.length > 0) {
+          console.log(`    Tags: ${host.tags.join(", ")}`);
+        }
+      });
+    } else {
+      const selectedTagsSet = this.app.selectedTags;
+      const selectedTagsArray = Array.from(selectedTagsSet);
+      if (selectedTagsArray.length > 0) {
+        console.log(`No hosts found matching tags: ${selectedTagsArray.join(", ")}`);
+      } else {
+        console.log("No hosts found in the inventory.");
+      }
+    }
+  }
+  async handleExec(commandParts, options, cmd) {
+    const opts = cmd.optsWithGlobals();
+    await this.loadApp(opts);
+    this.app.warn(`Executing command: ${commandParts}`);
+    const success = await this.app.execute(commandParts);
+    if (!success) {
+      process4.exitCode = 1;
+    }
+  }
+  async handleRun(packageOrBundle, scriptRef, scriptArgs, options, cmd) {
+    const opts = cmd.optsWithGlobals();
+    await this.loadApp(opts);
+    this.app.debug(`tags: ${opts.tag}, remote: ${opts.remote}`);
+    const resolved = await resolveScriptPath(this.app, packageOrBundle, scriptRef, scriptArgs);
+    scriptRef = resolved.scriptRef;
+    scriptArgs = resolved.scriptArgs;
+    let params = {};
+    try {
+      if (options.params) {
+        params = JSON5.parse(options.params);
+      } else if (options.file) {
+        const contents = File.readSync(options.file);
+        params = JSON5.parse(contents);
+      } else {
+        params = this.app.parseParams(scriptArgs);
+      }
+    } catch (err) {
+      this.app.error(
+        `Failed to parse params as JSON5: ${err.message}`,
+        `params: ${JSON5.stringify(options.params)}`
+      );
+      throw new Error(`Failed to parse params as JSON5: ${err.message}`);
+    }
+    if (!scriptRef) {
+      this.program.help();
+    }
+    this.app.debug(`Resolved script: ${scriptRef}`);
+    this.app.debug(`Script params: ${JSON.stringify(params)}`);
+    if (opts.remote) {
+      await this.app.runScriptRemote(scriptRef, params);
+    } else {
+      await this.app.runScript(scriptRef, params);
+    }
+  }
+  deriveConfigRef(suppliedConfigRef) {
+    if (suppliedConfigRef && Path.new(suppliedConfigRef).isFile()) {
+      return Path.new(suppliedConfigRef).toString();
+    }
+    const foundPath = Path.cwd().selfAndAncestors().find((p) => p.join("hostctl.yaml").isFile());
+    if (foundPath) {
+      return foundPath.join("hostctl.yaml").toString();
+    }
+    const homeConfigPath = Path.homeDir().join(".hostctl", "hostctl.yaml");
+    if (homeConfigPath.isFile()) {
+      return homeConfigPath.toString();
+    }
+    if (suppliedConfigRef && isValidUrl2(suppliedConfigRef)) {
+      return suppliedConfigRef;
+    }
+    throw new Error(
+      "Could not find a hostctl configuration file. Searched for 'hostctl.yaml' in the current directory, ancestor directories, and '~/.hostctl/hostctl.yaml'. If you intended to use a URL or a specific file path, please ensure it's correct and accessible via the -c option."
+    );
+  }
+  async loadApp(opts) {
+    const derivedConfigRef = this.deriveConfigRef(opts.config);
+    await this.app.loadConfig(derivedConfigRef);
+    const verbosity = opts.quiet + opts.verbose;
+    this.app.setVerbosity(verbosity);
+    if (opts.json) {
+      this.app.setOutputStyle("json");
+    } else {
+      this.app.setOutputStyle("plain");
+    }
+    let tagsToSet = [];
+    if (typeof opts.tag === "string") {
+      tagsToSet = [opts.tag];
+    } else if (Array.isArray(opts.tag)) {
+      tagsToSet = opts.tag;
+    }
+    this.app.setSelectedTags(tagsToSet);
+  }
+  async run() {
+    try {
+      await this.program.parseAsync(process4.argv);
+    } catch (e) {
+      logError("hostctl error:", e);
+    }
+  }
+  async handleRuntime(options, cmd) {
+    const opts = cmd.optsWithGlobals();
+    await this.loadApp(opts);
+    await this.app.printRuntimeReport();
+  }
+  async handleRuntimeInstall(options, cmd) {
+    const opts = cmd.optsWithGlobals();
+    await this.loadApp(opts);
+    await this.app.installRuntime();
+  }
+};
+
+// src/bin/hostctl.ts
+var cli = new Cli();
+cli.program.parseAsync(process.argv).catch((error) => {
+  console.error("Unhandled error in hostctl binary:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=hostctl.js.map