hunter-harness 0.2.3 → 0.2.5

package/dist/bin.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // src/bin.ts
+import { realpathSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { Command, CommanderError } from "commander";
@@ -3008,7 +3009,7 @@ function isBenignHighEntropyLookalike(value) {
   return false;
 }
 function highEntropyCandidates(content) {
-  const matches = content.matchAll(/\b[A-Za-z0-9_+.=\-]{24,}\b/g);
+  const matches = content.matchAll(/\b[A-Za-z0-9_+.=-]{24,}\b/g);
   return [...matches].map((match) => ({
     value: match[0],
     offset: match.index,
@@ -5006,7 +5007,7 @@ async function runRecoveryMenuIfApplicable(options, dependencies) {
 }
 
 // src/workflow-data/resolve.ts
-import { cp, mkdir as mkdir4, readdir as readdir7, readFile as readFile14, stat as stat5 } from "node:fs/promises";
+import { cp, mkdir as mkdir4, readdir as readdir7, readFile as readFile14, rm as rm8, stat as stat5 } from "node:fs/promises";
 import { dirname as dirname4, join as join16, relative as relative2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var WorkflowDataResolutionError = class extends Error {
@@ -5103,6 +5104,48 @@ async function siblingWorkflowPackage(cwd) {
   }
   return null;
 }
+async function readCachedNpmPackageVersion(cacheRoot) {
+  const manifestPath = join16(cacheRoot, "package.json");
+  if (!await pathExists3(manifestPath)) return null;
+  try {
+    const pkg = JSON.parse(await readFile14(manifestPath, "utf8"));
+    return typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+async function latestWorkflowCacheIsStale(cacheRoot, packageName, resolveManifest) {
+  const cachedVersion = await readCachedNpmPackageVersion(cacheRoot);
+  if (cachedVersion === null) return true;
+  try {
+    const manifest = resolveManifest ?? (async (spec) => {
+      const pacote = await import("pacote");
+      const result = await pacote.default.manifest(spec);
+      return { version: String(result.version) };
+    });
+    const remote = await manifest(packageName);
+    return remote.version !== cachedVersion;
+  } catch {
+    return false;
+  }
+}
+async function materializeWorkflowPackageCache(cacheRoot, packageSpec, extract) {
+  await mkdir4(cacheRoot, { recursive: true });
+  const staging = join16(cacheRoot, ".extract");
+  await rm8(staging, { recursive: true, force: true });
+  await mkdir4(staging, { recursive: true });
+  await extract(packageSpec, staging);
+  const packageDir = await pathExists3(join16(staging, "harness", "manifests")) ? staging : join16(staging, "package");
+  if (!await pathExists3(join16(packageDir, "harness", "manifests"))) {
+    throw new WorkflowDataResolutionError(
+      "\u5DE5\u4F5C\u6D41\u6570\u636E\u5305\u5185\u5BB9\u65E0\u6548\uFF1A\u7F3A\u5C11 harness/manifests",
+      "WORKFLOW_DATA_INVALID",
+      7
+    );
+  }
+  await cp(packageDir, cacheRoot, { recursive: true });
+  await verifyWorkflowPackageIntegrity(cacheRoot);
+}
 async function resolveWorkflowResourcesRoot(options, argv = []) {
   if (options.override !== void 0) return options.override;
   const envRoot = options.env.HUNTER_HARNESS_RESOURCES_ROOT?.trim();
@@ -5124,28 +5167,25 @@ async function resolveWorkflowResourcesRoot(options, argv = []) {
   const cacheKey = packageSpec.replace("/", "+");
   const cacheRoot = join16(options.cwd, ".harness", "cache", "workflow-packages", cacheKey);
   if (await pathExists3(join16(cacheRoot, "harness", "manifests"))) {
-    await verifyWorkflowPackageIntegrity(cacheRoot);
-    return cacheRoot;
+    if (version === "latest") {
+      const stale = await latestWorkflowCacheIsStale(cacheRoot, packageName, options.pacoteManifest);
+      if (stale) {
+        await rm8(cacheRoot, { recursive: true, force: true });
+      } else {
+        await verifyWorkflowPackageIntegrity(cacheRoot);
+        return cacheRoot;
+      }
+    } else {
+      await verifyWorkflowPackageIntegrity(cacheRoot);
+      return cacheRoot;
+    }
   }
   try {
-    await mkdir4(cacheRoot, { recursive: true });
     const extract = options.pacoteExtract ?? (async (spec, destination) => {
       const pacote = await import("pacote");
       await pacote.default.extract(spec, destination);
     });
-    const staging = join16(cacheRoot, ".extract");
-    await mkdir4(staging, { recursive: true });
-    await extract(packageSpec, staging);
-    const packageDir = await pathExists3(join16(staging, "harness", "manifests")) ? staging : join16(staging, "package");
-    if (!await pathExists3(join16(packageDir, "harness", "manifests"))) {
-      throw new WorkflowDataResolutionError(
-        "\u5DE5\u4F5C\u6D41\u6570\u636E\u5305\u5185\u5BB9\u65E0\u6548\uFF1A\u7F3A\u5C11 harness/manifests",
-        "WORKFLOW_DATA_INVALID",
-        7
-      );
-    }
-    await cp(packageDir, cacheRoot, { recursive: true });
-    await verifyWorkflowPackageIntegrity(cacheRoot);
+    await materializeWorkflowPackageCache(cacheRoot, packageSpec, extract);
     return cacheRoot;
   } catch (error) {
     if (error instanceof WorkflowDataResolutionError) throw error;
@@ -5262,9 +5302,18 @@ async function runCli(argv, overrides = {}) {
     throw error;
   }
 }
-if (process.argv[1] !== void 0 && import.meta.url === pathToFileURL(process.argv[1]).href) {
+function isDirectCliEntrypoint(entry = process.argv[1], metaUrl = import.meta.url) {
+  if (entry === void 0) return false;
+  try {
+    return metaUrl === pathToFileURL(realpathSync(entry)).href;
+  } catch {
+    return metaUrl === pathToFileURL(entry).href;
+  }
+}
+if (isDirectCliEntrypoint()) {
   process.exitCode = await runCli(process.argv.slice(2));
 }
 export {
+  isDirectCliEntrypoint,
   runCli
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hunter-harness",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Local-first, server-governed agent harness",
   "license": "MIT",
   "type": "module",