hostctl 0.1.55 → 0.1.58

package/dist/index.d.ts

@@ -397,6 +397,24 @@ declare class InteractionHandler {
     end(): void;
 }
 
+type CacheScope = 'global' | 'host' | 'invocation';
+type CacheMode = 'use' | 'refresh' | 'bypass';
+interface CacheOptions {
+    scope?: CacheScope;
+    key?: string;
+    ttlMs?: number;
+    mode?: CacheMode;
+}
+type CacheConfig = boolean | CacheScope | CacheOptions;
+interface TaskRunOptions {
+    cache?: CacheConfig;
+}
+interface MemoizeOptions {
+    scope?: CacheScope;
+    ttlMs?: number;
+    mode?: CacheMode;
+}
+
 /**
  * Generic object type for parameters and return values.
  */
@@ -471,7 +489,11 @@ interface TaskContext<TParams extends TaskParams = TaskParams> {
         pty?: boolean;
     }) => Promise<CommandResult>;
     ssh: <TRemoteParams extends TaskParams = {}, TRemoteReturn extends RunFnReturnValue = RunFnReturnValue>(tags: string[], remoteTaskFn: (remoteContext: TaskContext<TRemoteParams>) => Promise<TRemoteReturn>) => Promise<Record<string, TRemoteReturn | Error>>;
-    run: <TRunReturn extends RunFnReturnValue>(taskPartialFn: TaskPartialFn<TRunReturn>) => Promise<TRunReturn>;
+    run: {
+        <TRunReturn extends RunFnReturnValue>(taskPartialFn: TaskPartialFn<TRunReturn>, options?: TaskRunOptions): Promise<TRunReturn>;
+        <TParams extends TaskParams, TRunReturn extends RunFnReturnValue>(taskFn: TaskFn<TParams, TRunReturn>, params?: TParams, options?: TaskRunOptions): Promise<TRunReturn>;
+    };
+    memoize: <TReturn>(key: string, valueOrFactory: TReturn | Promise<TReturn> | (() => TReturn | Promise<TReturn>), options?: MemoizeOptions) => Promise<TReturn>;
     getPassword: () => Promise<string | undefined>;
     getSecret: (name: string) => Promise<string | undefined>;
     exit: (exitCode: number, message?: string) => void;
@@ -479,7 +501,10 @@ interface TaskContext<TParams extends TaskParams = TaskParams> {
     selectedInventory: (tags?: string[]) => Host[];
     file: FileSystemOperations$1;
 }
-type TaskPartialFn<TReturn extends RunFnReturnValue = RunFnReturnValue> = (parentInvocation: IInvocation) => Promise<TReturn>;
+type TaskPartialFn<TReturn extends RunFnReturnValue = RunFnReturnValue> = ((parentInvocation: IInvocation) => Promise<TReturn>) & {
+    taskFn?: TaskFn<any, RunFnReturnValue>;
+    params?: TaskParams;
+};
 interface TaskFn<TParams extends TaskParams = TaskParams, TReturn extends RunFnReturnValue = RunFnReturnValue> {
     (params?: TParams): TaskPartialFn<TReturn>;
     task: Task<TParams, TReturn>;
@@ -748,6 +773,7 @@ declare class App {
     private outputStyle;
     private _tmpDir?;
     private tmpFileRegistry;
+    private taskCache;
     taskTree: TaskTree;
     verbosity: VerbosityLevel;
     private passwordProvider?;

package/dist/index.js

@@ -2719,7 +2719,7 @@ var Verbosity = {
 };
 
 // src/version.ts
-var version = "0.1.55";
+var version = "0.1.58";
 
 // src/commands/pkg/create.ts
 import { promises as fs5 } from "fs";
@@ -4150,9 +4150,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;
@@ -6154,58 +6158,64 @@ async function detectRockyLinux(exec) {
 }
 var os_default = task(
   async function run26(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 match3(ostypeOutput.trim().toLowerCase()).with(P2.string.startsWith("solaris"), () => "solaris").with(P2.string.startsWith("darwin"), () => "darwin").with(P2.string.startsWith("linux"), () => "linux").with(P2.string.startsWith("bsd"), () => "bsd").with(P2.string.startsWith("freebsd"), () => "bsd").with(P2.string.startsWith("msys"), () => "windows").with(P2.string.startsWith("cygwin"), () => "windows").with(P2.string.startsWith("mingw"), () => "windows").otherwise(async () => {
-        const { stdout: unameOutput } = await exec(["uname"]);
-        const unameFamily = match3(unameOutput.trim().toLowerCase()).with(P2.string.startsWith("sunos"), () => "solaris").with(P2.string.startsWith("darwin"), () => "darwin").with(P2.string.startsWith("linux"), () => "linux").with(P2.string.startsWith("freebsd"), () => "bsd").with(P2.string.startsWith("openbsd"), () => "bsd").with(P2.string.startsWith("netbsd"), () => "bsd").otherwise(() => "unknown");
-        return unameFamily;
-      });
-      const [osIdLike, osId, osVersion] = await match3(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 match3(ostypeOutput.trim().toLowerCase()).with(P2.string.startsWith("solaris"), () => "solaris").with(P2.string.startsWith("darwin"), () => "darwin").with(P2.string.startsWith("linux"), () => "linux").with(P2.string.startsWith("bsd"), () => "bsd").with(P2.string.startsWith("freebsd"), () => "bsd").with(P2.string.startsWith("msys"), () => "windows").with(P2.string.startsWith("cygwin"), () => "windows").with(P2.string.startsWith("mingw"), () => "windows").otherwise(async () => {
+            const { stdout: unameOutput } = await exec(["uname"]);
+            const unameFamily = match3(unameOutput.trim().toLowerCase()).with(P2.string.startsWith("sunos"), () => "solaris").with(P2.string.startsWith("darwin"), () => "darwin").with(P2.string.startsWith("linux"), () => "linux").with(P2.string.startsWith("freebsd"), () => "bsd").with(P2.string.startsWith("openbsd"), () => "bsd").with(P2.string.startsWith("netbsd"), () => "bsd").otherwise(() => "unknown");
+            return unameFamily;
+          });
+          const [osIdLike, osId, osVersion] = await match3(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",
@@ -31924,8 +31934,8 @@ function renderTaskRows(rows, {
       name: r.name,
       description: r.description,
       module: r.module,
-      inputSchema: Boolean(r.inputSchema),
-      outputSchema: Boolean(r.outputSchema),
+      inputSchema: schemaToDescriptor(r.inputSchema),
+      outputSchema: schemaToDescriptor(r.outputSchema),
       schemaSource: r.schemaSource
     }));
     console.log(JSON.stringify(sanitized, null, 2));
@@ -31966,9 +31976,12 @@ function summarizeType(val) {
     case "optional":
     case "ZodNullable":
     case "nullable":
+    case "ZodDefault":
+    case "default":
       return summarizeType(def.innerType || def.type);
     case "ZodEffects":
-      return summarizeType(def.schema);
+    case "pipe":
+      return summarizeType(def.schema || def.in);
     case "ZodString":
     case "string":
       return { type: "string", desc };
@@ -31991,8 +32004,11 @@ function summarizeType(val) {
       return types.length ? { type: types.join(" | "), desc } : {};
     }
     case "ZodLiteral":
-    case "literal":
-      return { type: JSON.stringify(def.value), desc };
+    case "literal": {
+      const values3 = Array.isArray(def?.values) ? def.values : def?.value !== void 0 ? [def.value] : [];
+      const value = values3.length ? values3[0] : void 0;
+      return { type: value !== void 0 ? JSON.stringify(value) : void 0, desc };
+    }
     case "ZodObject":
     case "object":
       return { type: "object", desc };
@@ -32000,6 +32016,140 @@ function summarizeType(val) {
       return { type: String(tn).replace(/^Zod/, "").toLowerCase(), desc };
   }
 }
+function schemaToDescriptor(schema) {
+  if (!schema) return null;
+  const { schema: base, nullable } = unwrapSchema(schema);
+  const def = base?._def ?? base?.def;
+  const typeName = def?.typeName || def?.type;
+  const description = def?.description || base?.description;
+  let descriptor = {};
+  switch (typeName) {
+    case "ZodString":
+    case "string":
+      descriptor.type = "string";
+      break;
+    case "ZodNumber":
+    case "number":
+      descriptor.type = "number";
+      break;
+    case "ZodBoolean":
+    case "boolean":
+      descriptor.type = "boolean";
+      break;
+    case "ZodArray":
+    case "array": {
+      const inner = def?.element ?? def?.type;
+      descriptor.type = "array";
+      descriptor.items = schemaToDescriptor(inner);
+      break;
+    }
+    case "ZodObject":
+    case "object": {
+      const shapeSource = def?.shape || def?.shape_;
+      const shape = shapeSource && typeof shapeSource === "function" ? shapeSource.call(def) : shapeSource;
+      const properties = {};
+      const required = [];
+      if (shape && typeof shape === "object") {
+        for (const [key, value] of Object.entries(shape)) {
+          const { schema: fieldSchema, optional, nullable: fieldNullable } = unwrapSchema(value);
+          const fieldDescriptor = schemaToDescriptor(fieldSchema) ?? {};
+          if (fieldNullable) {
+            fieldDescriptor.nullable = true;
+          }
+          properties[key] = fieldDescriptor;
+          if (!optional) {
+            required.push(key);
+          }
+        }
+      }
+      descriptor.type = "object";
+      descriptor.properties = properties;
+      descriptor.required = required.length ? required : void 0;
+      break;
+    }
+    case "ZodUnion":
+    case "union": {
+      const options = def?.options ?? [];
+      descriptor.anyOf = options.map((option) => schemaToDescriptor(option)).filter(Boolean);
+      break;
+    }
+    case "ZodLiteral":
+    case "literal": {
+      const values3 = Array.isArray(def?.values) ? def.values : def?.value !== void 0 ? [def.value] : [];
+      const sample = values3.length ? values3[0] : void 0;
+      descriptor.type = sample === null ? "null" : typeof sample;
+      descriptor.enum = values3;
+      break;
+    }
+    case "ZodEnum":
+    case "enum":
+      const enumValues = Array.isArray(def?.values) ? def.values : Object.values(def?.entries ?? {});
+      descriptor.enum = enumValues;
+      if (enumValues.length) {
+        const hasNumber = enumValues.some((value) => typeof value === "number");
+        const hasString = enumValues.some((value) => typeof value === "string");
+        descriptor.type = hasNumber && !hasString ? "number" : "string";
+      } else {
+        descriptor.type = "string";
+      }
+      break;
+    case "ZodNativeEnum":
+    case "nativeenum": {
+      const values3 = Array.isArray(def?.values) ? def.values : Object.values(def?.entries ?? def?.values ?? {});
+      descriptor.type = values3.every((value) => typeof value === "number") ? "number" : "string";
+      descriptor.enum = values3;
+      break;
+    }
+    default:
+      descriptor.type = typeName ? String(typeName).replace(/^Zod/, "").toLowerCase() : "unknown";
+      break;
+  }
+  if (description) {
+    descriptor.description = description;
+  }
+  if (nullable) {
+    descriptor.nullable = true;
+  }
+  return descriptor;
+}
+function unwrapSchema(schema) {
+  let current = schema;
+  let optional = false;
+  let nullable = false;
+  while (current) {
+    const def = current?._def ?? current?.def;
+    const typeName = def?.typeName || def?.type;
+    if (typeName === "ZodOptional" || typeName === "optional") {
+      optional = true;
+      current = def?.innerType ?? def?.type;
+      continue;
+    }
+    if (typeName === "ZodNullable" || typeName === "nullable") {
+      nullable = true;
+      current = def?.innerType ?? def?.type;
+      continue;
+    }
+    if (typeName === "ZodDefault" || typeName === "default") {
+      optional = true;
+      current = def?.innerType ?? def?.type;
+      continue;
+    }
+    if (typeName === "ZodEffects" || typeName === "effects") {
+      current = def?.schema;
+      continue;
+    }
+    if (typeName === "pipe") {
+      current = def?.in ?? def?.schema;
+      continue;
+    }
+    if (typeName === "transform") {
+      current = def?.schema ?? def?.in;
+      continue;
+    }
+    break;
+  }
+  return { schema: current, optional, nullable };
+}
 function formatSchemaLines(schema) {
   if (!schema) return ["none"];
   const def = schema._def ?? schema.def;
@@ -32012,7 +32162,7 @@ function formatSchemaLines(schema) {
       const tn = anyVal?._def?.typeName || anyVal?.def?.type;
       const typeString = summary2.type || (tn ? String(tn).replace(/^Zod/, "").toLowerCase() : void 0);
       const desc = summary2.desc;
-      const optional = tn === "ZodOptional" || tn === "ZodNullable";
+      const optional = ["ZodOptional", "optional", "ZodNullable", "nullable", "ZodDefault", "default"].includes(tn);
       const typePart = typeString ? `: ${typeString}` : "";
       const descPart = desc ? ` - ${desc}` : "";
       return `- ${key}${optional ? "?" : ""}${typePart}${descPart}`;
@@ -32792,6 +32942,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 match5 } from "ts-pattern";
@@ -32935,6 +33088,154 @@ var runAllRemote_default = task(run252, {
   outputSchema: RunResultSchema
 });
 
+// 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 }>;
@@ -33031,6 +33332,7 @@ var App6 = class _App {
   outputStyle;
   _tmpDir;
   tmpFileRegistry;
+  taskCache;
   taskTree;
   verbosity = Verbosity.ERROR;
   passwordProvider;
@@ -33040,6 +33342,7 @@ var App6 = 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;
     process4.on("exit", (code) => this.appExitCallback());
@@ -33355,6 +33658,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,
@@ -33384,8 +33708,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();