skillwiki 0.9.63 → 0.10.1

package/dist/chunk-SCGC7YNM.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+import {
+  findReviewRequiredOp,
+  git,
+  hasActiveGitSequencer,
+  hasUnmergedPaths,
+  loadFleetManifestAndHost,
+  runVaultSyncPullHelper,
+  supersedeStaleReviewRequiredJournals
+} from "./chunk-R6BKJWVC.js";
+import {
+  ExitCode,
+  err,
+  ok
+} from "./chunk-C5OLZRRM.js";
+
+// src/utils/managed-write-lock.ts
+import { randomBytes } from "crypto";
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function managedWriteLockPath(vault) {
+  const gitPath = git(vault, ["rev-parse", "--git-path", "vault-sync/managed-write.lock"]);
+  if (gitPath) return gitPath.startsWith("/") ? gitPath : join(vault, gitPath);
+  return join(vault, ".skillwiki", "managed-write.lock");
+}
+function acquireManagedWriteLock(vault, command) {
+  const path = managedWriteLockPath(vault);
+  const ownerToken = randomBytes(16).toString("hex");
+  const acquired = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(
+      path,
+      `${JSON.stringify({ pid: process.pid, owner_token: ownerToken, acquired, command })}
+`,
+      { flag: "wx" }
+    );
+    return ok({ vault, path, ownerToken, acquired });
+  } catch (error) {
+    if (error.code === "EEXIST") return err("SYNC_LOCK_HELD", { path });
+    return err("WRITE_FAILED", { path, message: String(error) });
+  }
+}
+function releaseManagedWriteLock(handle) {
+  try {
+    const parsed = JSON.parse(readFileSync(handle.path, "utf8"));
+    if (parsed.owner_token !== handle.ownerToken || parsed.acquired !== handle.acquired) {
+      return err("SYNC_LOCK_HELD", {
+        path: handle.path,
+        message: "managed-write lock ownership changed"
+      });
+    }
+    unlinkSync(handle.path);
+    return ok({ released: true });
+  } catch (error) {
+    return err("WRITE_FAILED", { path: handle.path, message: String(error) });
+  }
+}
+
+// src/utils/managed-write-preflight.ts
+var DEFAULT_DEPS = {
+  converge: (input) => runVaultSyncPullHelper(input)
+};
+function preflightBlocker(vault) {
+  const unmerged = hasUnmergedPaths(vault);
+  if (unmerged.length > 0) {
+    return {
+      reason: "unmerged-paths",
+      operation_id: findReviewRequiredOp(vault),
+      unmerged_paths: unmerged
+    };
+  }
+  if (hasActiveGitSequencer(vault)) {
+    return { reason: "git-operation-in-progress" };
+  }
+  supersedeStaleReviewRequiredJournals(vault, { by: "skillwiki-managed-write-preflight" });
+  const op = findReviewRequiredOp(vault);
+  if (op) return { reason: "review-required", operation_id: op };
+  return null;
+}
+async function runManagedWritePreflight(input, deps = DEFAULT_DEPS) {
+  const vault = input.vault;
+  const blocker = preflightBlocker(vault);
+  if (blocker) {
+    return {
+      exitCode: ExitCode.PREFLIGHT_FAILED,
+      result: err("PREFLIGHT_FAILED", {
+        reason: blocker.reason,
+        operation_id: blocker.operation_id,
+        unmerged_paths: blocker.unmerged_paths
+      })
+    };
+  }
+  const fleet = await loadFleetManifestAndHost({
+    vault,
+    hostId: input.hostId,
+    env: input.env,
+    home: input.home,
+    osHostname: input.osHostname
+  });
+  if (!fleet) {
+    const head = git(vault, ["rev-parse", "HEAD"]) || null;
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        mode: "standalone",
+        base_oid: head,
+        converged: false
+      })
+    };
+  }
+  if (fleet.identityStatus === "unknown" || fleet.identityStatus === "invalid" || !fleet.hostId) {
+    return {
+      exitCode: ExitCode.PREFLIGHT_FAILED,
+      result: err("PREFLIGHT_FAILED", {
+        reason: "fleet-identity-unresolved",
+        identity_status: fleet.identityStatus,
+        host_id: fleet.hostId
+      })
+    };
+  }
+  const host = fleet.manifest.hosts[fleet.hostId];
+  if (!host) {
+    return {
+      exitCode: ExitCode.PREFLIGHT_FAILED,
+      result: err("PREFLIGHT_FAILED", { reason: "fleet-host-missing", host_id: fleet.hostId })
+    };
+  }
+  const writesGithub = host.writes_to.includes("github");
+  if (!writesGithub) {
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        mode: "immutable-record",
+        host_id: fleet.hostId,
+        base_oid: null,
+        converged: false
+      })
+    };
+  }
+  const converge = await deps.converge({
+    vault,
+    lockToken: input.lockToken,
+    env: input.env,
+    home: input.home
+  });
+  if (!converge.ok) {
+    const exitCode = converge.error === "PREFLIGHT_FAILED" ? ExitCode.PREFLIGHT_FAILED : ExitCode.SYNC_PULL_FAILED;
+    return { exitCode, result: converge };
+  }
+  const baseOid = git(vault, ["rev-parse", "HEAD"]);
+  if (!baseOid) {
+    return {
+      exitCode: ExitCode.PREFLIGHT_FAILED,
+      result: err("PREFLIGHT_FAILED", { reason: "missing-head-after-converge" })
+    };
+  }
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      mode: "git-writer",
+      host_id: fleet.hostId,
+      base_oid: baseOid,
+      converged: true,
+      helper_path: converge.data.helper_path
+    })
+  };
+}
+async function runManagedWriteTransaction(input, deps = DEFAULT_DEPS) {
+  const lock = acquireManagedWriteLock(input.vault, input.command);
+  if (!lock.ok) {
+    return { exitCode: ExitCode.SYNC_LOCK_HELD, result: lock };
+  }
+  let handle = lock.data;
+  try {
+    const preflight = await runManagedWritePreflight(
+      {
+        vault: input.vault,
+        command: input.command,
+        hostId: input.hostId,
+        lockToken: handle.ownerToken,
+        env: input.env,
+        home: input.home,
+        osHostname: input.osHostname
+      },
+      deps
+    );
+    if (!preflight.result.ok) {
+      return { exitCode: preflight.exitCode, result: preflight.result };
+    }
+    const receipt = preflight.result.data;
+    if (receipt.mode === "immutable-record" && !input.allowImmutableRecord) {
+      return {
+        exitCode: ExitCode.PREFLIGHT_FAILED,
+        result: err("PREFLIGHT_FAILED", {
+          reason: "immutable-record-not-enabled",
+          message: "Release A rejects immutable-record mode; event mode arrives in Release B",
+          host_id: receipt.host_id
+        })
+      };
+    }
+    return await input.mutate(receipt);
+  } finally {
+    releaseManagedWriteLock(handle);
+  }
+}
+
+export {
+  acquireManagedWriteLock,
+  releaseManagedWriteLock,
+  runManagedWritePreflight,
+  runManagedWriteTransaction
+};