@glrs-dev/cli 0.0.1 → 0.1.1

package/dist/vendor/harness-opencode/dist/chunk-VJUETC6A.js

@@ -0,0 +1,205 @@
+// src/auto-update.ts
+import * as fs from "fs/promises";
+import * as fsSync from "fs";
+import * as path from "path";
+import * as os from "os";
+import { fileURLToPath } from "url";
+import { execFile } from "child_process";
+var PACKAGE_NAME = "@glrs-dev/harness-plugin-opencode";
+function getOpenCodeCachePackageDir() {
+  const cacheHome = process.env["XDG_CACHE_HOME"] ?? path.join(os.homedir(), ".cache");
+  return path.join(
+    cacheHome,
+    "opencode",
+    "packages",
+    "@glrs-dev",
+    "harness-opencode@latest"
+  );
+}
+async function inspectCachePin(cacheDir) {
+  const pkgPath = path.join(cacheDir, "package.json");
+  let raw;
+  try {
+    raw = await fs.readFile(pkgPath, "utf8");
+  } catch {
+    return { kind: "missing" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { kind: "missing" };
+  }
+  const deps = parsed.dependencies ?? {};
+  const spec = deps[PACKAGE_NAME];
+  if (typeof spec !== "string") {
+    return { kind: "not-our-package", name: parsed.name ?? "(unknown)" };
+  }
+  if (/^\d+\.\d+\.\d+(-[0-9a-zA-Z.-]+)?(\+[0-9a-zA-Z.-]+)?$/.test(spec)) {
+    return { kind: "exact", version: spec };
+  }
+  return { kind: "non-exact", spec };
+}
+async function atomicWriteJson(targetPath, value) {
+  const serialized = JSON.stringify(value, null, 2) + "\n";
+  const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+  await fs.writeFile(tmpPath, serialized, "utf8");
+  await fs.rename(tmpPath, targetPath);
+}
+async function refreshPluginCache(currentVersion, latestVersion, ctx = {}) {
+  if (process.env["HARNESS_OPENCODE_AUTO_UPDATE"] === "0") {
+    return {
+      outcome: "disabled",
+      message: "HARNESS_OPENCODE_AUTO_UPDATE=0 \u2014 cache rewrite skipped"
+    };
+  }
+  const cacheDir = ctx.cacheDir ?? getOpenCodeCachePackageDir();
+  if (currentVersion === latestVersion) {
+    return {
+      outcome: "already-current",
+      message: `running ${currentVersion}, latest is ${latestVersion}`,
+      fromVersion: currentVersion,
+      toVersion: latestVersion
+    };
+  }
+  const pin = await inspectCachePin(cacheDir);
+  switch (pin.kind) {
+    case "missing":
+      return {
+        outcome: "cache-missing",
+        message: `no cache pin at ${cacheDir} \u2014 nothing to rewrite`
+      };
+    case "not-our-package":
+      return {
+        outcome: "not-our-package",
+        message: `cache dir exists but doesn't pin ${PACKAGE_NAME} (name=${pin.name})`
+      };
+    case "non-exact":
+      return {
+        outcome: "non-exact-pin",
+        message: `cache pin is "${pin.spec}" (not exact) \u2014 user-managed, leaving alone`
+      };
+    case "exact": {
+      if (pin.version === latestVersion) {
+        return {
+          outcome: "already-current",
+          message: `cache already pinned to ${latestVersion}`,
+          fromVersion: pin.version,
+          toVersion: latestVersion
+        };
+      }
+      break;
+    }
+  }
+  const fromVersion = pin.version;
+  if (ctx.dryRun) {
+    return {
+      outcome: "refreshed",
+      message: `[dry-run] would rewrite ${cacheDir} from ${fromVersion} to ${latestVersion}`,
+      fromVersion,
+      toVersion: latestVersion
+    };
+  }
+  try {
+    const pkgPath = path.join(cacheDir, "package.json");
+    const pkgRaw = await fs.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(pkgRaw);
+    const deps = { ...pkg.dependencies ?? {} };
+    deps[PACKAGE_NAME] = latestVersion;
+    const newPkg = { ...pkg, dependencies: deps };
+    await atomicWriteJson(pkgPath, newPkg);
+    const lockPath = path.join(cacheDir, "package-lock.json");
+    try {
+      const lockRaw = await fs.readFile(lockPath, "utf8");
+      const lock = JSON.parse(lockRaw);
+      const packages = { ...lock.packages ?? {} };
+      if (packages[""] && packages[""].dependencies) {
+        packages[""] = {
+          ...packages[""],
+          dependencies: {
+            ...packages[""].dependencies,
+            [PACKAGE_NAME]: latestVersion
+          }
+        };
+      }
+      const nmKey = `node_modules/${PACKAGE_NAME}`;
+      if (packages[nmKey]) {
+        packages[nmKey] = {
+          ...packages[nmKey],
+          version: latestVersion
+        };
+        delete packages[nmKey]["resolved"];
+        delete packages[nmKey]["integrity"];
+      }
+      const newLock = { ...lock, packages };
+      await atomicWriteJson(lockPath, newLock);
+    } catch {
+      try {
+        await fs.rm(lockPath, { force: true });
+      } catch {
+      }
+    }
+    const nmPath = path.join(cacheDir, "node_modules");
+    try {
+      await fs.rm(nmPath, { recursive: true, force: true });
+    } catch {
+    }
+    if (!ctx.skipInstall) {
+      try {
+        await new Promise((resolve, reject) => {
+          const child = execFile(
+            "npm",
+            ["install", "--no-audit", "--no-fund"],
+            { cwd: cacheDir, timeout: 3e4 },
+            (err) => err ? reject(err) : resolve()
+          );
+          child.unref?.();
+        });
+      } catch {
+      }
+    }
+    return {
+      outcome: "refreshed",
+      message: `rewrote cache pin ${fromVersion} \u2192 ${latestVersion}; next OpenCode restart will reinstall`,
+      fromVersion,
+      toVersion: latestVersion
+    };
+  } catch (err) {
+    return {
+      outcome: "error",
+      message: `cache rewrite failed: ${err.message}`,
+      fromVersion,
+      toVersion: latestVersion
+    };
+  }
+}
+function readOurPackageVersion(fromFileUrl) {
+  const here = path.dirname(fileURLToPath(fromFileUrl));
+  const candidates = [
+    path.join(here, "..", "package.json"),
+    // dist/index.js → dist/../package.json
+    path.join(here, "..", "..", "package.json"),
+    // src/index.ts → src/../../package.json
+    path.join(here, "package.json")
+    // safety net
+  ];
+  for (const candidate of candidates) {
+    try {
+      const raw = fsSync.readFileSync(candidate, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.name === PACKAGE_NAME && typeof parsed.version === "string") {
+        return parsed.version;
+      }
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+
+export {
+  PACKAGE_NAME,
+  getOpenCodeCachePackageDir,
+  inspectCachePin,
+  refreshPluginCache,
+  readOurPackageVersion
+};