skillwiki 0.10.26 → 0.10.28

package/dist/chunk-BASWDOQB.js

@@ -1,455 +0,0 @@
-#!/usr/bin/env node
-import {
-  FLEET_REL_PATH,
-  findReviewRequiredOp,
-  git,
-  hasActiveGitSequencer,
-  hasUnmergedPaths,
-  loadFleetManifestAndHost,
-  resolveConfiguredSnapshotWorktree,
-  runVaultSyncPullHelper,
-  supersedeStaleReviewRequiredJournals
-} from "./chunk-PQG26AGJ.js";
-import {
-  ExitCode,
-  err,
-  ok
-} from "./chunk-C2DKFJFA.js";
-
-// src/utils/managed-write-preflight.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
-
-// src/utils/managed-write-lock.ts
-import { randomBytes } from "crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync
-} from "fs";
-import { hostname } from "os";
-import { dirname, join, resolve } 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 readLockRecord(path) {
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function isManagedWriteLockOwnerAlive(pid) {
-  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    if (error.code === "EPERM") return true;
-    return false;
-  }
-}
-function hasUnsafeGitState(vault) {
-  const gitDirRaw = git(vault, ["rev-parse", "--git-dir"]);
-  if (!gitDirRaw) return true;
-  const gitDir = gitDirRaw.startsWith("/") ? gitDirRaw : join(vault, gitDirRaw);
-  for (const rel of ["rebase-merge", "rebase-apply"]) {
-    if (existsSync(join(gitDir, rel))) return true;
-  }
-  for (const rel of ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD"]) {
-    if (existsSync(join(gitDir, rel))) return true;
-  }
-  const unmerged = git(vault, ["ls-files", "-u"]);
-  return Boolean(unmerged && unmerged.trim().length > 0);
-}
-function isGitBackedVault(vault) {
-  return Boolean(git(vault, ["rev-parse", "--absolute-git-dir"]));
-}
-function hasLocalOwnerProof(vault, record) {
-  return isGitBackedVault(vault) || typeof record.owner_hostname === "string" && record.owner_hostname === hostname();
-}
-function reclaimDeadManagedWriteLockOwner(vault, options = {}) {
-  const path = managedWriteLockPath(vault);
-  const gitStateVault = resolve(options.gitStateVault ?? vault);
-  if (!existsSync(path)) return ok({ reclaimed: false });
-  const record = readLockRecord(path);
-  if (!record) {
-    return err("SYNC_LOCK_HELD", { path, message: "managed-write lock unreadable" });
-  }
-  if (!hasLocalOwnerProof(vault, record)) {
-    return err("SYNC_LOCK_HELD", {
-      path,
-      owner_hostname: record.owner_hostname,
-      current_hostname: hostname(),
-      message: "managed-write lock origin is foreign or unknown"
-    });
-  }
-  if (isManagedWriteLockOwnerAlive(record.pid)) {
-    return err("SYNC_LOCK_HELD", { path, message: "managed-write lock owner is alive" });
-  }
-  if (hasUnsafeGitState(gitStateVault)) {
-    return err("SYNC_LOCK_HELD", {
-      path,
-      git_state_vault: gitStateVault,
-      message: "managed-write lock not reclaimed: unsafe git state"
-    });
-  }
-  try {
-    const recoveryDir = join(dirname(path), "recovery");
-    mkdirSync(recoveryDir, { recursive: true });
-    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
-    const recoveryPath = join(recoveryDir, `stale-managed-write-lock-${stamp}-${process.pid}.json`);
-    const meta = {
-      recovered_at: (/* @__PURE__ */ new Date()).toISOString(),
-      recovery_reason: "owner_pid_dead",
-      owner_pid_alive: false,
-      git_state_vault: gitStateVault,
-      lock: record
-    };
-    writeFileSync(recoveryPath, `${JSON.stringify(meta, null, 2)}
-`, { flag: "wx" });
-    unlinkSync(path);
-    return ok({ reclaimed: true, recoveryPath });
-  } catch (error) {
-    return err("WRITE_FAILED", { path, message: String(error) });
-  }
-}
-function tryCreateLock(path, command) {
-  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_hostname: hostname(),
-        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 acquireManagedWriteLock(vault, command, options = {}) {
-  const path = managedWriteLockPath(vault);
-  const first = tryCreateLock(path, command);
-  if (first.ok) {
-    return ok({ ...first.data, vault });
-  }
-  if (first.error !== "SYNC_LOCK_HELD") return first;
-  const reclaimed = reclaimDeadManagedWriteLockOwner(vault, options);
-  if (!reclaimed.ok || !reclaimed.data.reclaimed) {
-    return err("SYNC_LOCK_HELD", { path });
-  }
-  const second = tryCreateLock(path, command);
-  if (second.ok) return ok({ ...second.data, vault });
-  return second.ok === false ? second : err("SYNC_LOCK_HELD", { path });
-}
-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),
-  resolveConfiguredSnapshotWorktree
-};
-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",
-    requireClean: false
-  });
-  const op = findReviewRequiredOp(vault);
-  if (op) return { reason: "review-required", operation_id: op };
-  return null;
-}
-function hasFleetManifest(vault) {
-  return existsSync2(join2(vault, FLEET_REL_PATH));
-}
-function isGitVault(vault) {
-  return Boolean(git(vault, ["rev-parse", "--absolute-git-dir"]));
-}
-async function runManagedWritePreflight(input, deps = DEFAULT_DEPS) {
-  const mutationVault = resolve2(input.vault);
-  let convergenceVault = input.convergenceVault && resolve2(input.convergenceVault) !== mutationVault ? resolve2(input.convergenceVault) : void 0;
-  let convergenceSource = convergenceVault ? "explicit" : "single-path";
-  const mutationBlocker = preflightBlocker(mutationVault);
-  if (mutationBlocker) {
-    return {
-      exitCode: ExitCode.PREFLIGHT_FAILED,
-      result: err("PREFLIGHT_FAILED", {
-        reason: mutationBlocker.reason,
-        operation_id: mutationBlocker.operation_id,
-        unmerged_paths: mutationBlocker.unmerged_paths
-      })
-    };
-  }
-  const fleet = await loadFleetManifestAndHost({
-    vault: mutationVault,
-    hostId: input.hostId,
-    env: input.env,
-    home: input.home,
-    cwd: input.cwd,
-    osHostname: input.osHostname,
-    user: input.user
-  });
-  if (!fleet) {
-    const gitVault2 = isGitVault(mutationVault) ? mutationVault : null;
-    const head = gitVault2 ? git(gitVault2, ["rev-parse", "HEAD"]) || null : null;
-    return {
-      exitCode: ExitCode.OK,
-      result: ok({
-        mode: "standalone",
-        mutation_vault: mutationVault,
-        git_vault: gitVault2,
-        base_oid: head,
-        converged: false,
-        convergence_source: "single-path"
-      })
-    };
-  }
-  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,
-        mutation_vault: mutationVault,
-        git_vault: null,
-        base_oid: null,
-        converged: false,
-        ...convergenceVault ? { convergence_vault: convergenceVault } : {},
-        convergence_source: convergenceSource
-      })
-    };
-  }
-  if (!convergenceVault && host.role === "snapshotter" && host.protected === true) {
-    const home = input.home ?? input.env?.HOME ?? process.env.HOME ?? "";
-    const configured = (deps.resolveConfiguredSnapshotWorktree ?? resolveConfiguredSnapshotWorktree)(home);
-    if (!configured) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: "convergence-vault-not-configured",
-          host_id: fleet.hostId,
-          mutation_vault: mutationVault
-        })
-      };
-    }
-    convergenceVault = resolve2(configured);
-    convergenceSource = "configured";
-    if (convergenceVault === mutationVault) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: "convergence-vault-not-distinct",
-          host_id: fleet.hostId,
-          mutation_vault: mutationVault,
-          convergence_vault: convergenceVault
-        })
-      };
-    }
-  }
-  const gitVault = convergenceVault ?? mutationVault;
-  if (convergenceVault) {
-    if (!isGitVault(convergenceVault)) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: "convergence-vault-not-git",
-          convergence_vault: convergenceVault
-        })
-      };
-    }
-    const convergenceHasFleet = hasFleetManifest(convergenceVault);
-    if (convergenceSource === "configured" && !convergenceHasFleet) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: "convergence-vault-fleet-missing",
-          host_id: fleet.hostId,
-          convergence_vault: convergenceVault
-        })
-      };
-    }
-    const gitBlocker = preflightBlocker(convergenceVault);
-    if (gitBlocker) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: gitBlocker.reason,
-          operation_id: gitBlocker.operation_id,
-          unmerged_paths: gitBlocker.unmerged_paths,
-          convergence_vault: convergenceVault
-        })
-      };
-    }
-  }
-  if (convergenceVault && hasFleetManifest(convergenceVault)) {
-    const convergeFleetCtx = await loadFleetManifestAndHost({
-      vault: convergenceVault,
-      hostId: input.hostId ?? fleet.hostId,
-      env: input.env,
-      home: input.home,
-      cwd: input.cwd,
-      osHostname: input.osHostname,
-      user: input.user
-    });
-    if (!convergeFleetCtx || convergeFleetCtx.identityStatus !== "known" || convergeFleetCtx.hostId !== fleet.hostId) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: "convergence-vault-identity-mismatch",
-          host_id: fleet.hostId,
-          convergence_host_id: convergeFleetCtx?.hostId,
-          convergence_identity_status: convergeFleetCtx?.identityStatus,
-          convergence_vault: convergenceVault
-        })
-      };
-    }
-  }
-  const dualPathMeta = convergenceVault ? { convergence_vault: convergenceVault } : {};
-  const converge = await deps.converge({
-    vault: gitVault,
-    lockToken: convergenceVault ? void 0 : 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(gitVault, ["rev-parse", "HEAD"]);
-  if (!baseOid) {
-    return {
-      exitCode: ExitCode.PREFLIGHT_FAILED,
-      result: err("PREFLIGHT_FAILED", {
-        reason: "missing-head-after-converge",
-        ...dualPathMeta
-      })
-    };
-  }
-  return {
-    exitCode: ExitCode.OK,
-    result: ok({
-      mode: "git-writer",
-      host_id: fleet.hostId,
-      mutation_vault: mutationVault,
-      git_vault: gitVault,
-      base_oid: baseOid,
-      converged: true,
-      helper_path: converge.data.helper_path,
-      ...dualPathMeta,
-      convergence_source: convergenceSource
-    })
-  };
-}
-async function runManagedWriteTransaction(input, deps = DEFAULT_DEPS) {
-  const mutationVault = resolve2(input.vault);
-  const lock = acquireManagedWriteLock(mutationVault, input.command, {
-    gitStateVault: input.convergenceVault ? resolve2(input.convergenceVault) : mutationVault
-  });
-  if (!lock.ok) {
-    return { exitCode: ExitCode.SYNC_LOCK_HELD, result: lock };
-  }
-  const handle = lock.data;
-  try {
-    const preflightInput = {
-      vault: mutationVault,
-      command: input.command,
-      convergenceVault: input.convergenceVault,
-      hostId: input.hostId,
-      lockToken: handle.ownerToken,
-      env: input.env,
-      home: input.home,
-      cwd: input.cwd,
-      osHostname: input.osHostname,
-      user: input.user
-    };
-    const preflight = input.preflight ? await input.preflight(preflightInput) : await runManagedWritePreflight(preflightInput, deps);
-    if (!preflight.result.ok) {
-      return { exitCode: preflight.exitCode, result: preflight.result };
-    }
-    const receipt = preflight.result.data;
-    if (receipt.mutation_vault !== mutationVault) {
-      return {
-        exitCode: ExitCode.PREFLIGHT_FAILED,
-        result: err("PREFLIGHT_FAILED", {
-          reason: "mutation-vault-receipt-mismatch",
-          expected: mutationVault,
-          actual: receipt.mutation_vault
-        })
-      };
-    }
-    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 {
-  runManagedWritePreflight,
-  runManagedWriteTransaction
-};