hostctl 0.1.57 → 0.1.58

package/dist/bin/hostctl.js

@@ -2929,9 +2929,13 @@ function task(runFn4, options) {
     options?.outputSchema
   );
   const taskFnObject = function(params) {
-    return function(parentInvocation) {
-      return parentInvocation.invokeChildTask(taskFnObject, params ?? {});
+    const normalizedParams = params ?? {};
+    const taskPartialFn = function(parentInvocation) {
+      return parentInvocation.invokeChildTask(taskFnObject, normalizedParams);
     };
+    taskPartialFn.taskFn = taskFnObject;
+    taskPartialFn.params = normalizedParams;
+    return taskPartialFn;
   };
   Object.assign(taskFnObject, { task: taskInstance });
   return taskFnObject;
@@ -3897,6 +3901,9 @@ import AdmZip from "adm-zip";
 
 // src/hash.ts
 import { createHash } from "crypto";
+function sha256(str) {
+  return createHash("sha256").update(str).digest("hex");
+}
 
 // src/param-map.ts
 import { match as match2 } from "ts-pattern";
@@ -3981,7 +3988,7 @@ var ParamMap = class _ParamMap {
 import * as z from "zod";
 
 // src/version.ts
-var version = "0.1.57";
+var version = "0.1.58";
 
 // src/app.ts
 import { retryUntilDefined } from "ts-retry";
@@ -6731,58 +6738,64 @@ async function detectRockyLinux(exec) {
 }
 var os_default = task(
   async function run27(context) {
-    try {
-      const { exec } = context;
-      const {
-        success: ostypeSuccess,
-        stdout: ostypeOutput,
-        stderr: ostypeStderr
-      } = await exec(["bash", "-c", "echo $OSTYPE"]);
-      if (!ostypeSuccess) {
-        throw new Error(`Failed to get OSTYPE: ${ostypeStderr}`);
-      }
-      const family = await match5(ostypeOutput.trim().toLowerCase()).with(P3.string.startsWith("solaris"), () => "solaris").with(P3.string.startsWith("darwin"), () => "darwin").with(P3.string.startsWith("linux"), () => "linux").with(P3.string.startsWith("bsd"), () => "bsd").with(P3.string.startsWith("freebsd"), () => "bsd").with(P3.string.startsWith("msys"), () => "windows").with(P3.string.startsWith("cygwin"), () => "windows").with(P3.string.startsWith("mingw"), () => "windows").otherwise(async () => {
-        const { stdout: unameOutput } = await exec(["uname"]);
-        const unameFamily = match5(unameOutput.trim().toLowerCase()).with(P3.string.startsWith("sunos"), () => "solaris").with(P3.string.startsWith("darwin"), () => "darwin").with(P3.string.startsWith("linux"), () => "linux").with(P3.string.startsWith("freebsd"), () => "bsd").with(P3.string.startsWith("openbsd"), () => "bsd").with(P3.string.startsWith("netbsd"), () => "bsd").otherwise(() => "unknown");
-        return unameFamily;
-      });
-      const [osIdLike, osId, osVersion] = await match5(family).with("bsd", async () => {
-        const { stdout: unameROutput } = await exec(["uname", "-r"]);
-        return [family, family, unameROutput.trim()];
-      }).with("darwin", async () => {
-        const { stdout: swVersOutput } = await exec(["sw_vers", "-productVersion"]);
-        return [family, family, swVersOutput.trim()];
-      }).with("linux", async () => {
-        const { idLike, id, version: version2 } = await getOsReleaseInfo(exec);
-        return [idLike, id, version2];
-      }).with("solaris", async () => {
-        const { stdout: unameROutput } = await exec(["uname", "-r"]);
-        return ["solaris", "solaris", unameROutput.trim()];
-      }).with("windows", () => ["windows", "windows", "unknown"]).otherwise(() => ["unknown", "unknown", "unknown"]);
-      let variant = osId.toLowerCase();
-      if (family === "linux" && !variant.includes("rocky") && (osIdLike.toLowerCase().includes("rocky") || osId.toLowerCase().includes("rhel"))) {
-        const isRocky = await detectRockyLinux(exec);
-        if (isRocky) {
-          variant = "rocky";
+    return await context.memoize(
+      "core.host.os:v1",
+      async () => {
+        try {
+          const { exec } = context;
+          const {
+            success: ostypeSuccess,
+            stdout: ostypeOutput,
+            stderr: ostypeStderr
+          } = await exec(["bash", "-c", "echo $OSTYPE"]);
+          if (!ostypeSuccess) {
+            throw new Error(`Failed to get OSTYPE: ${ostypeStderr}`);
+          }
+          const family = await match5(ostypeOutput.trim().toLowerCase()).with(P3.string.startsWith("solaris"), () => "solaris").with(P3.string.startsWith("darwin"), () => "darwin").with(P3.string.startsWith("linux"), () => "linux").with(P3.string.startsWith("bsd"), () => "bsd").with(P3.string.startsWith("freebsd"), () => "bsd").with(P3.string.startsWith("msys"), () => "windows").with(P3.string.startsWith("cygwin"), () => "windows").with(P3.string.startsWith("mingw"), () => "windows").otherwise(async () => {
+            const { stdout: unameOutput } = await exec(["uname"]);
+            const unameFamily = match5(unameOutput.trim().toLowerCase()).with(P3.string.startsWith("sunos"), () => "solaris").with(P3.string.startsWith("darwin"), () => "darwin").with(P3.string.startsWith("linux"), () => "linux").with(P3.string.startsWith("freebsd"), () => "bsd").with(P3.string.startsWith("openbsd"), () => "bsd").with(P3.string.startsWith("netbsd"), () => "bsd").otherwise(() => "unknown");
+            return unameFamily;
+          });
+          const [osIdLike, osId, osVersion] = await match5(family).with("bsd", async () => {
+            const { stdout: unameROutput } = await exec(["uname", "-r"]);
+            return [family, family, unameROutput.trim()];
+          }).with("darwin", async () => {
+            const { stdout: swVersOutput } = await exec(["sw_vers", "-productVersion"]);
+            return [family, family, swVersOutput.trim()];
+          }).with("linux", async () => {
+            const { idLike, id, version: version2 } = await getOsReleaseInfo(exec);
+            return [idLike, id, version2];
+          }).with("solaris", async () => {
+            const { stdout: unameROutput } = await exec(["uname", "-r"]);
+            return ["solaris", "solaris", unameROutput.trim()];
+          }).with("windows", () => ["windows", "windows", "unknown"]).otherwise(() => ["unknown", "unknown", "unknown"]);
+          let variant = osId.toLowerCase();
+          if (family === "linux" && !variant.includes("rocky") && (osIdLike.toLowerCase().includes("rocky") || osId.toLowerCase().includes("rhel"))) {
+            const isRocky = await detectRockyLinux(exec);
+            if (isRocky) {
+              variant = "rocky";
+            }
+          }
+          return {
+            success: true,
+            family,
+            os: osIdLike.toLowerCase(),
+            variant,
+            version: osVersion
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message,
+            family: "unknown",
+            os: "unknown",
+            variant: "unknown",
+            version: "unknown"
+          };
         }
-      }
-      return {
-        success: true,
-        family,
-        os: osIdLike.toLowerCase(),
-        variant,
-        version: osVersion
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message,
-        family: "unknown",
-        os: "unknown",
-        variant: "unknown",
-        version: "unknown"
-      };
-    }
+      },
+      { scope: "host" }
+    );
   },
   {
     name: "os",
@@ -31791,6 +31804,154 @@ function registrySize(registry2) {
   return registry2.tasks().length;
 }
 
+// src/task-cache.ts
+var DEFAULT_CACHE_MODE = "use";
+var LOCAL_HOST_SCOPE_KEY = "host:local";
+function normalizeValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      const normalized = normalizeValue(item);
+      return normalized === void 0 ? null : normalized;
+    });
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const sortedKeys = Object.keys(obj).sort();
+    const result = {};
+    for (const key of sortedKeys) {
+      const normalized = normalizeValue(obj[key]);
+      if (normalized !== void 0) {
+        result[key] = normalized;
+      }
+    }
+    return result;
+  }
+  return value;
+}
+function stableJson(value) {
+  const normalized = normalizeValue(value);
+  return JSON.stringify(normalized ?? null);
+}
+function normalizeCacheConfig(cache) {
+  if (!cache) {
+    return { enabled: false, mode: DEFAULT_CACHE_MODE };
+  }
+  if (cache === true) {
+    return { enabled: true, mode: DEFAULT_CACHE_MODE };
+  }
+  if (typeof cache === "string") {
+    return { enabled: true, scope: cache, mode: DEFAULT_CACHE_MODE };
+  }
+  return {
+    enabled: true,
+    scope: cache.scope,
+    key: cache.key,
+    ttlMs: cache.ttlMs,
+    mode: cache.mode ?? DEFAULT_CACHE_MODE
+  };
+}
+function buildTaskCacheKey(taskIdentity, params) {
+  const taskName = taskIdentity?.task?.name;
+  const modulePath = taskIdentity?.task?.taskModuleAbsolutePath;
+  const identity2 = taskName ?? (modulePath ? Path.new(modulePath).absolute().toString() : "unknown-task");
+  const paramsHash = sha256(stableJson(params ?? {}));
+  return `${identity2}:${paramsHash}`;
+}
+function buildHostScopeKey(host, configRef) {
+  if (!host) {
+    return LOCAL_HOST_SCOPE_KEY;
+  }
+  const identity2 = {
+    alias: host.alias ?? "",
+    hostname: host.hostname ?? "",
+    user: host.user ?? "",
+    port: host.port ?? 22,
+    config: configRef ?? ""
+  };
+  return `host:${sha256(stableJson(identity2))}`;
+}
+function buildInvocationScopeKey(rootInvocationId) {
+  return `invocation:${rootInvocationId}`;
+}
+var TaskCacheStore = class {
+  entries = /* @__PURE__ */ new Map();
+  runId;
+  constructor(runId) {
+    this.runId = runId ?? crypto.randomUUID();
+  }
+  globalScopeKey() {
+    return `global:${this.runId}`;
+  }
+  get(scopeKey, cacheKey2) {
+    const scope = this.entries.get(scopeKey);
+    if (!scope) {
+      return void 0;
+    }
+    const entry = scope.get(cacheKey2);
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.expiresAt > 0 && Date.now() > entry.expiresAt) {
+      scope.delete(cacheKey2);
+      if (scope.size === 0) {
+        this.entries.delete(scopeKey);
+      }
+      return void 0;
+    }
+    return entry;
+  }
+  set(scopeKey, cacheKey2, value, ttlMs) {
+    const scope = this.entries.get(scopeKey) ?? /* @__PURE__ */ new Map();
+    const expiresAt = ttlMs && ttlMs > 0 ? Date.now() + ttlMs : 0;
+    const entry = { value, expiresAt };
+    scope.set(cacheKey2, entry);
+    this.entries.set(scopeKey, scope);
+    return entry;
+  }
+  delete(scopeKey, cacheKey2) {
+    const scope = this.entries.get(scopeKey);
+    if (!scope) {
+      return;
+    }
+    scope.delete(cacheKey2);
+    if (scope.size === 0) {
+      this.entries.delete(scopeKey);
+    }
+  }
+  async resolve(scopeKey, cacheKey2, compute, options = {}) {
+    const mode = options.mode ?? DEFAULT_CACHE_MODE;
+    if (mode === "bypass") {
+      return await compute();
+    }
+    if (mode === "use") {
+      const cached = this.get(scopeKey, cacheKey2);
+      if (cached) {
+        return await cached.value;
+      }
+    }
+    const promise = Promise.resolve().then(compute);
+    this.set(scopeKey, cacheKey2, promise, options.ttlMs);
+    try {
+      return await promise;
+    } catch (error) {
+      this.delete(scopeKey, cacheKey2);
+      throw error;
+    }
+  }
+};
+
 // src/app.ts
 var TaskTree = class {
   // private taskEventBus: Emittery<{ newTask: NewTaskEvent; taskComplete: TaskCompleteEvent }>;
@@ -31887,6 +32048,7 @@ var App3 = class _App {
   outputStyle;
   _tmpDir;
   tmpFileRegistry;
+  taskCache;
   taskTree;
   verbosity = Verbosity.ERROR;
   passwordProvider;
@@ -31896,6 +32058,7 @@ var App3 = class _App {
     this.taskTree = new TaskTree();
     this.outputStyle = "plain";
     this.tmpFileRegistry = new TmpFileRegistry(this.hostctlTmpDir());
+    this.taskCache = new TaskCacheStore();
     this.configRef = void 0;
     this.hostSelector = void 0;
     process3.on("exit", (code) => this.appExitCallback());
@@ -32211,6 +32374,27 @@ ${cmdRes.stderr.trim()}`));
   }
   taskContextForRunFn(invocation, params, hostForContext) {
     const effectiveHost = hostForContext || invocation.host;
+    const rootInvocationId = (() => {
+      let current = invocation;
+      while (current.parent) {
+        current = current.parent;
+      }
+      return current.id;
+    })();
+    const defaultScope = () => effectiveHost ? "host" : "global";
+    const scopeKeyFor = (scope) => {
+      switch (scope) {
+        case "global":
+          return this.taskCache.globalScopeKey();
+        case "host":
+          return buildHostScopeKey(effectiveHost, this.configRef);
+        case "invocation":
+          return buildInvocationScopeKey(rootInvocationId);
+      }
+    };
+    const isTaskFn = (candidate) => {
+      return typeof candidate === "function" && !!candidate.task;
+    };
     return {
       // Properties from TaskContext
       params,
@@ -32240,8 +32424,58 @@ ${cmdRes.stderr.trim()}`));
       ssh: async (tags, remoteTaskFn) => {
         return await invocation.ssh(tags, remoteTaskFn);
       },
-      run: async (taskPartialFn) => {
-        return await invocation.run(taskPartialFn);
+      run: async (...args) => {
+        const [firstArg, secondArg, thirdArg] = args;
+        let taskPartialFn;
+        let taskIdentity;
+        let paramsForKey;
+        let options;
+        if (isTaskFn(firstArg)) {
+          taskIdentity = firstArg;
+          paramsForKey = secondArg ?? {};
+          options = thirdArg;
+          taskPartialFn = taskIdentity(paramsForKey);
+        } else {
+          taskPartialFn = firstArg;
+          options = secondArg;
+          const meta = taskPartialFn;
+          taskIdentity = meta.taskFn;
+          paramsForKey = meta.params;
+        }
+        const cacheDecision = normalizeCacheConfig(options?.cache);
+        if (!cacheDecision.enabled || cacheDecision.mode === "bypass") {
+          return await invocation.run(taskPartialFn);
+        }
+        const scope = cacheDecision.scope ?? defaultScope();
+        const cacheKey2 = cacheDecision.key ?? buildTaskCacheKey(taskIdentity, paramsForKey ?? {});
+        const scopeKey = scopeKeyFor(scope);
+        return await this.taskCache.resolve(scopeKey, cacheKey2, () => invocation.run(taskPartialFn), {
+          ttlMs: cacheDecision.ttlMs,
+          mode: cacheDecision.mode
+        });
+      },
+      memoize: async (key, valueOrFactory, options) => {
+        const cacheDecision = normalizeCacheConfig({
+          scope: options?.scope,
+          ttlMs: options?.ttlMs,
+          mode: options?.mode,
+          key
+        });
+        const scope = cacheDecision.scope ?? defaultScope();
+        const scopeKey = scopeKeyFor(scope);
+        const compute = async () => {
+          if (typeof valueOrFactory === "function") {
+            return await valueOrFactory();
+          }
+          return await valueOrFactory;
+        };
+        if (cacheDecision.mode === "bypass") {
+          return await compute();
+        }
+        return await this.taskCache.resolve(scopeKey, key, compute, {
+          ttlMs: cacheDecision.ttlMs,
+          mode: cacheDecision.mode
+        });
       },
       getPassword: async () => {
         return await invocation.getPassword();