@mnemonik/cli 0.0.0 → 7.99.5

package/dist/runtime/store.js

@@ -0,0 +1,977 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+
+// packages/shared/dist/runtimeSigners.js
+import { lstatSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, dirname, join, resolve, sep, win32 } from "node:path";
+import { createHash, createPublicKey, randomUUID, timingSafeEqual, verify as verifySignature } from "node:crypto";
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+function decodeBase64(text, length) {
+  const bytes = Buffer.from(text, "base64");
+  if (bytes.length !== length || bytes.toString("base64") !== text)
+    throw new Error("unsigned");
+  return bytes;
+}
+async function verifyMinisign(path, signaturePath, identity) {
+  const [message, signatureText] = await Promise.all([
+    readFile(path),
+    readFile(signaturePath, "utf8")
+  ]);
+  const publicPacket = decodeBase64(identity, 42);
+  const lines = signatureText.trimEnd().split(/\r?\n/);
+  const [untrustedComment, encodedSignature, trustedLine, encodedGlobalSignature] = lines;
+  if (publicPacket.subarray(0, 2).toString() !== "Ed" || lines.length !== 4 || !untrustedComment?.startsWith("untrusted comment:") || !encodedSignature || !trustedLine?.startsWith("trusted comment: ") || !encodedGlobalSignature)
+    throw new Error("unsigned");
+  const signaturePacket = decodeBase64(encodedSignature, 74);
+  const globalSignature = decodeBase64(encodedGlobalSignature, 64);
+  const algorithm = signaturePacket.subarray(0, 2).toString();
+  if (algorithm !== "ED" && algorithm !== "Ed" || !timingSafeEqual(publicPacket.subarray(2, 10), signaturePacket.subarray(2, 10)))
+    throw new Error("unsigned");
+  const publicKey = createPublicKey({
+    key: Buffer.concat([Buffer.from("302a300506032b6570032100", "hex"), publicPacket.subarray(10)]),
+    format: "der",
+    type: "spki"
+  });
+  const fileSignature = signaturePacket.subarray(10);
+  const signedMessage = algorithm === "ED" ? createHash("blake2b512").update(message).digest() : message;
+  const trustedComment = trustedLine.slice("trusted comment: ".length);
+  if (!verifySignature(null, signedMessage, publicKey, fileSignature) || !verifySignature(null, Buffer.concat([fileSignature, Buffer.from(trustedComment)]), publicKey, globalSignature))
+    throw new Error("unsigned");
+}
+async function verifySigner(path, signer, run = execute) {
+  if (signer.platform === "darwin" && /^[A-Z0-9]{10}$/.test(signer.identity)) {
+    await run("/usr/bin/codesign", [
+      "--verify",
+      "--strict",
+      "-R",
+      `=anchor apple generic and certificate leaf[subject.OU] = "${signer.identity}"`,
+      path
+    ]);
+  } else if (signer.platform === "win32" && /^[A-Fa-f0-9]{40}$/.test(signer.identity)) {
+    await run("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      `$ErrorActionPreference = 'Stop'; $s = Get-AuthenticodeSignature -LiteralPath ${quote(path)}; if ($s.Status -ne 'Valid' -or $s.SignerCertificate.Thumbprint -ne ${quote(signer.identity)}) { exit 1 }`
+    ]);
+  } else if (signer.platform === "linux") {
+    try {
+      await verifyMinisign(path, signer.signature, signer.identity);
+    } catch {
+      throw new Error("unsigned");
+    }
+  } else
+    throw new Error("unsigned");
+}
+async function verifyWindowsPermission(path, run = hookExecute, state) {
+  const verdicts = await auditWindowsPermissions(path, [path], run, false, state);
+  if (verdicts.get(path) === "acl_unavailable")
+    throw new Error("acl_unavailable");
+  if (verdicts.get(path) !== "ok")
+    throw new Error("acl_permissions");
+}
+function windowsCommand(file) {
+  const root = process.env.SystemRoot;
+  if (!root || !win32.isAbsolute(root))
+    throw new Error("acl_system_root_unavailable");
+  return win32.join(root, "System32", file);
+}
+function readIdentity(stdout2) {
+  const match = /^"([^"\r\n]+)","(S-1-(?:\d+-)+\d+)"$/.exec(stdout2.trim());
+  if (!match?.[1] || !match[2] || stdout2.includes("\uFFFD"))
+    throw new Error("acl_identity_unavailable");
+  return { name: match[1], sid: match[2] };
+}
+async function windowsIdentity(run) {
+  if (currentIdentity)
+    return currentIdentity;
+  identityPending ??= run(windowsCommand("whoami.exe"), identityArgs).then((result) => currentIdentity = readIdentity(stdout(result))).finally(() => {
+    identityPending = void 0;
+  });
+  return identityPending;
+}
+async function verifyWindowsAcl(path, run = hookExecute, state) {
+  const user = await windowsIdentity(run);
+  if (!privateEntries((await drive(saveAcl(path, false, [path], state), run)).get(path), user, false))
+    throw new Error("acl_permissions");
+}
+function hookInvocation(file, args) {
+  if (win32.basename(file) === "whoami.exe") {
+    if ([file, ...args].some((arg) => /[%!"\r\n]/.test(arg)))
+      throw new Error("acl_path_unavailable");
+    const command = args.map((arg) => /^(?:[a-z0-9]+|\/[a-z]+)$/i.test(arg) ? arg : `"${arg}"`).join(" ");
+    return [
+      windowsCommand("cmd.exe"),
+      ["/d", "/v:off", "/s", "/c", `"chcp 65001>nul & "${file}" ${command}"`]
+    ];
+  }
+  if (win32.basename(file) === "cmd.exe")
+    return [file, ["/u", ...args]];
+  return [file, args];
+}
+function aclRecords(output, root, paths, onLookup) {
+  const records = /* @__PURE__ */ new Map();
+  const wanted = new Set(paths);
+  const lines = output.replace(/^\uFEFF/, "").trimEnd().split(/\r?\n/);
+  if (lines.length % 2)
+    throw new Error("acl_unavailable");
+  for (let index = 0; index < lines.length; index += 2) {
+    onLookup?.();
+    const relativePath = lines[index];
+    const descriptor = lines[index + 1];
+    if (relativePath === void 0 || descriptor === void 0)
+      throw new Error("acl_unavailable");
+    const path = resolve(dirname(root), relativePath.replaceAll("\\", sep));
+    if (!wanted.has(path))
+      continue;
+    if (records.has(path))
+      throw new Error("acl_unavailable");
+    const dacl = /^D:(?:P|AI|AR)*((?:\([^()]*\))*)$/.exec(descriptor);
+    records.set(path, dacl?.[1]?.match(/\([^()]*\)/g) ?? []);
+  }
+  return records;
+}
+function privateEntries(entries, user, directory) {
+  if (!entries?.length)
+    throw new Error("acl_unavailable");
+  return entries.every((line) => {
+    const ace = /^\(([AD]);((?:OI|CI|NP|IO|ID|SA|FA)*);[A-Za-z0-9]+;;;((?:S-1-(?:\d+-)+\d+)|[A-Z]{2})\)$/.exec(line);
+    if (!ace)
+      throw new Error("acl_unavailable");
+    return (!directory || !ace[2]?.includes("ID")) && (ace[1] === "D" || ace[3] === user.sid);
+  });
+}
+function* prepareAclDirectory(state) {
+  const directory = join(state, "audit-tmp");
+  if (auditDirectories.has(directory)) {
+    const stat2 = lstatSync(directory);
+    if (!stat2.isDirectory() || stat2.isSymbolicLink())
+      throw new Error("acl_permissions");
+    return directory;
+  }
+  let created = false;
+  try {
+    mkdirSync(directory, { mode: 448 });
+    created = true;
+  } catch (error) {
+    if (error.code !== "EEXIST")
+      throw error;
+  }
+  const stat = lstatSync(directory);
+  if (!stat.isDirectory() || stat.isSymbolicLink())
+    throw new Error("acl_permissions");
+  if (!auditDirectories.has(directory)) {
+    currentIdentity ??= readIdentity(yield [windowsCommand("whoami.exe"), identityArgs]);
+    yield [windowsCommand("icacls.exe"), aclArgs(directory, currentIdentity.sid)];
+    if (!created) {
+      const temp = join(directory, `.acl-${randomUUID()}.tmp`);
+      writeFileSync(temp, "", { flag: "wx", mode: 384 });
+      try {
+        yield [windowsCommand("icacls.exe"), [directory, "/save", temp, "/l"]];
+        if (!privateEntries(aclRecords(readFileSync(temp, "utf16le"), directory, [directory]).get(directory), currentIdentity, true))
+          throw new Error("acl_permissions");
+      } finally {
+        unlinkSync(temp);
+      }
+    }
+    auditDirectories.add(directory);
+  }
+  return directory;
+}
+async function prepareWindowsAclDirectory(state, run = hookExecute) {
+  let pending = directoryPending.get(state);
+  if (!pending) {
+    pending = drive(prepareAclDirectory(state), run).then(() => {
+    }).finally(() => directoryPending.delete(state));
+    directoryPending.set(state, pending);
+  }
+  await pending;
+}
+function* saveAcl(path, recursive, paths = [path], state = lstatSync(path).isDirectory() ? path : dirname(path)) {
+  const directory = yield* prepareAclDirectory(state);
+  const temp = join(directory, `.acl-${randomUUID()}.tmp`);
+  writeFileSync(temp, "", { flag: "wx", mode: 384 });
+  try {
+    yield [windowsCommand("icacls.exe"), [path, "/save", temp, ...recursive ? ["/t"] : [], "/l"]];
+    return aclRecords(readFileSync(temp, "utf16le"), path, paths.filter((item) => item !== directory && !item.startsWith(directory + sep)));
+  } finally {
+    unlinkSync(temp);
+  }
+}
+async function drive(commands, run) {
+  try {
+    let step = commands.next();
+    while (!step.done)
+      step = commands.next(stdout(await run(...step.value)));
+    return step.value;
+  } finally {
+    commands.return(void 0);
+  }
+}
+function dirEntry(line) {
+  const metadata = /^\S+\s+\S+(?:\s+\S+)?\s+(?:<DIR>|\d[\d,.\s]*)\s+/.exec(line)?.[0];
+  if (!metadata)
+    return void 0;
+  const ownerColumn = metadata.length;
+  const owner = line.slice(ownerColumn, ownerColumn + ownerWidth).trim().toLowerCase();
+  const name = line.slice(ownerColumn + ownerWidth);
+  return owner && name ? { owner, name } : void 0;
+}
+function ownerLookup(paths) {
+  if (paths.some((path) => /[\t\r\n]/.test(path)))
+    throw new Error("acl_path_unavailable");
+  const script = `$ErrorActionPreference = 'Stop'
+[Console]::InputEncoding = [System.Text.UTF8Encoding]::new($false)
+[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)
+while ($null -ne ($path = [Console]::ReadLine())) {
+  $owner = (Get-Acl -LiteralPath $path).GetOwner([System.Security.Principal.SecurityIdentifier]).Value
+  [Console]::WriteLine($path + "\`t" + $owner)
+}`;
+  return [
+    windowsCommand("WindowsPowerShell\\v1.0\\powershell.exe"),
+    ["-NoProfile", "-NonInteractive", "-Command", script],
+    paths.join("\n") + "\n"
+  ];
+}
+function ownerSids(output) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const line of output.split(/\r?\n/)) {
+    const [path, sid] = line.split("	");
+    if (path && sid && /^S-1-(?:\d+-)+\d+$/.test(sid))
+      owners.set(path, sid.toLowerCase());
+  }
+  return owners;
+}
+async function auditWindowsPermissions(state, paths, run = hookExecute, recursive = true, tempState = lstatSync(state).isDirectory() ? state : dirname(state)) {
+  const user = await windowsIdentity(run);
+  const root = resolve(state);
+  for (const path of paths)
+    if (resolve(path) !== root && !resolve(path).startsWith(root + sep))
+      throw new Error("acl_path_unavailable");
+  if (/[%!"\r\n]/.test(root))
+    throw new Error("acl_path_unavailable");
+  const owners = /* @__PURE__ */ new Map();
+  for (const [directory, descend] of [
+    [dirname(root), false],
+    ...recursive ? [[root, true]] : []
+  ]) {
+    if (/[%!"\r\n]/.test(directory))
+      throw new Error("acl_path_unavailable");
+    const output = stdout(await run(windowsCommand("cmd.exe"), [
+      "/d",
+      "/v:off",
+      "/s",
+      "/c",
+      `dir /q /a ${descend ? "/s " : ""}"${directory}"`
+    ]));
+    let current = directory;
+    for (const line of output.split(/\r?\n/)) {
+      const entry = dirEntry(line);
+      if (entry) {
+        if (entry.name !== "..")
+          owners.set(join(current, entry.name), unknownOwner(entry.owner, user) ? "..." : entry.owner);
+      } else {
+        const header = /(?:^|\s)((?:[A-Za-z]:\\|\\\\|\/).*)$/.exec(line.trim());
+        if (header?.[1])
+          current = header[1];
+      }
+    }
+  }
+  const verdicts = /* @__PURE__ */ new Map();
+  const ownerPaths = [...owners.keys()].filter((path) => path === root || path.startsWith(root + sep));
+  const truncated = new Set(ownerPaths.filter((path) => owners.get(path)?.includes("...")));
+  if (truncated.size) {
+    const result = await run(...ownerLookup([...truncated])).catch(() => ({ stdout: "" }));
+    for (const [path, sid] of ownerSids(stdout(result)))
+      if (truncated.has(path))
+        owners.set(path, sid);
+  }
+  for (const [path, entries] of await drive(saveAcl(root, recursive, ownerPaths, tempState), run)) {
+    const owner = owners.get(path) ?? "...";
+    const owned = owner === user.name.toLowerCase() || owner === user.sid.toLowerCase();
+    try {
+      if (!entries.length || owner.includes("..."))
+        throw new Error("acl_unavailable");
+      verdicts.set(path, !owned ? "owner" : privateEntries(entries, user, false) ? "ok" : "ace");
+    } catch {
+      verdicts.set(path, "acl_unavailable");
+    }
+  }
+  return verdicts;
+}
+var execute, quote, identityArgs, currentIdentity, ttl, identityPending, aclArgs, hookOptions, hookExecute, stdout, auditDirectories, directoryPending, ownerWidth, unknownOwner;
+var init_runtimeSigners = __esm({
+  "packages/shared/dist/runtimeSigners.js"() {
+    "use strict";
+    execute = (file, args, input) => {
+      const result = promisify(execFile)(file, args);
+      if (input === void 0)
+        return result;
+      return new Promise((resolve3, reject) => {
+        void result.then(resolve3, reject);
+        result.child.stdin?.on("error", reject);
+        result.child.stdin?.end(input);
+      });
+    };
+    quote = (text) => `'${text.replaceAll("'", "''")}'`;
+    identityArgs = ["/user", "/fo", "csv", "/nh"];
+    ttl = 10 * 6e4;
+    aclArgs = (path, sid) => [
+      path,
+      "/inheritance:r",
+      "/grant:r",
+      `*${sid}:(OI)(CI)F`
+    ];
+    hookOptions = (file, args) => ({
+      encoding: args.includes("/u") ? "utf16le" : "utf8",
+      timeout: win32.basename(file) === "powershell.exe" ? 3e4 : 5e3,
+      windowsHide: true,
+      maxBuffer: 16 * 1024 * 1024,
+      windowsVerbatimArguments: win32.basename(file) === "cmd.exe"
+    });
+    hookExecute = (file, args, input) => {
+      const treeListing = win32.basename(file) === "icacls.exe" && args.includes("/t") || win32.basename(file) === "cmd.exe" && args.some((arg) => arg.startsWith("dir /q /a /s "));
+      [file, args] = hookInvocation(file, args);
+      const options = hookOptions(file, args);
+      if (treeListing)
+        options.timeout = 3e4;
+      return new Promise((resolve3, reject) => {
+        const child = execFile(file, args, options, (error, stdout2) => error ? reject(error) : resolve3({ stdout: stdout2 }));
+        if (input !== void 0) {
+          child.stdin?.on("error", reject);
+          child.stdin?.end(input);
+        }
+      });
+    };
+    stdout = (value) => value.stdout;
+    auditDirectories = /* @__PURE__ */ new Set();
+    directoryPending = /* @__PURE__ */ new Map();
+    ownerWidth = 23;
+    unknownOwner = (owner, user) => user.name.length >= ownerWidth || owner.length >= ownerWidth || owner.includes("...");
+  }
+});
+
+// packages/shared/dist/projectIdentityFile.js
+var init_projectIdentityFile = __esm({
+  "packages/shared/dist/projectIdentityFile.js"() {
+    "use strict";
+  }
+});
+
+// packages/shared/dist/repositoryRoot.js
+var init_repositoryRoot = __esm({
+  "packages/shared/dist/repositoryRoot.js"() {
+    "use strict";
+    init_projectIdentityFile();
+  }
+});
+
+// packages/shared/dist/runtimeReader.js
+import { createHash as createHash2 } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, readdir } from "node:fs/promises";
+import { dirname as dirname2, join as join2, parse, resolve as resolve2, sep as sep2 } from "node:path";
+function safePath(path) {
+  if (typeof path !== "string" || !/^[a-zA-Z0-9_@.+/-]+$/.test(path) || path.split("/").some((p) => !p || p === "." || p === "..") || path.includes(":"))
+    throw new RuntimeError("permission");
+  return path;
+}
+var RuntimeError, hash, missing, versionName, statIdentity, RuntimeReader;
+var init_runtimeReader = __esm({
+  "packages/shared/dist/runtimeReader.js"() {
+    "use strict";
+    init_runtimeSigners();
+    init_runtimeSigners();
+    RuntimeError = class extends Error {
+      reason;
+      constructor(reason) {
+        super(reason);
+        this.reason = reason;
+        this.name = "RuntimeError";
+      }
+    };
+    hash = (bytes) => createHash2("sha256").update(bytes).digest("hex");
+    missing = (e) => e.code === "ENOENT";
+    versionName = (v) => {
+      if (!/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(v))
+        throw new RuntimeError("permission");
+      return v;
+    };
+    statIdentity = (stat) => [stat.dev, stat.ino, stat.mode, stat.uid, stat.size, stat.mtimeMs, stat.ctimeMs].join(":");
+    RuntimeReader = class _RuntimeReader {
+      run;
+      options;
+      now;
+      state;
+      static windowsSignatures = /* @__PURE__ */ new Map();
+      // Omitted batch verdicts use the per-path fallback before entering the cache.
+      windowsAudit = /* @__PURE__ */ new Map();
+      windowsStats = /* @__PURE__ */ new Map();
+      windowsDirectories = /* @__PURE__ */ new Set();
+      audits = Promise.resolve();
+      auditsInFlight = /* @__PURE__ */ new Map();
+      activeOperation = false;
+      operations = Promise.resolve();
+      constructor(state, run, options = {}, now = () => performance.now()) {
+        this.run = run;
+        this.options = options;
+        this.now = now;
+        this.state = resolve2(state);
+      }
+      pointerPath(artifact) {
+        if (!["cli", "scanner", "claude-code", "codex", "cursor", "grok"].includes(artifact))
+          throw new RuntimeError("permission");
+        return join2(this.state, "runtimes", artifact, "current");
+      }
+      guardedPath(path) {
+        const absolute = resolve2(path);
+        if (absolute !== this.state && !absolute.startsWith(this.state + sep2) || process.platform === "win32" && /[\r\n\t]/.test(absolute))
+          throw new RuntimeError("permission");
+        return absolute;
+      }
+      auditRoot(path) {
+        const [area, artifact] = path.slice(this.state.length + 1).split(sep2);
+        return area === "runtimes" ? join2(this.state, area, ...artifact ? [artifact] : []) : path;
+      }
+      traceAudit(event) {
+        const level = process.env.MNEMONIK_AUDIT_TRACE;
+        if (level !== "1" && (level !== "misses" || event.cache === "hit"))
+          return;
+        process.stderr.write(JSON.stringify({
+          type: "runtime-audit",
+          pid: process.pid,
+          module: import.meta.url,
+          activeOperation: this.activeOperation,
+          ...event
+        }) + "\n");
+      }
+      invalidateAudit(path) {
+        const root = this.auditRoot(path);
+        for (const key of this.windowsAudit.keys())
+          if (key === root || (!this.options.cacheDirectories || root.startsWith(join2(this.state, "runtimes") + sep2)) && key.startsWith(root + sep2))
+            this.windowsAudit.delete(key);
+      }
+      audit(paths) {
+        const root = this.auditRoot(paths.at(-1) ?? this.state);
+        const pending = this.auditsInFlight.get(root);
+        if (pending)
+          return pending;
+        const audit = this.audits.then(() => this.auditPending(paths)).finally(() => this.auditsInFlight.delete(root));
+        this.auditsInFlight.set(root, audit);
+        this.audits = audit.catch(() => {
+        });
+        return audit;
+      }
+      async auditPending(paths) {
+        if (process.platform !== "win32")
+          return;
+        const pending = /* @__PURE__ */ new Set();
+        for (const path of paths) {
+          let part = this.guardedPath(path);
+          while (true) {
+            const cached = this.windowsAudit.get(part);
+            const expired = !!cached && !this.activeOperation && !(this.options.cacheDirectories && this.windowsDirectories.has(part)) && this.now() - cached.checkedAt >= 2e3;
+            this.traceAudit({
+              event: "cache",
+              requested: path,
+              path: part,
+              root: this.auditRoot(path),
+              cache: !cached ? "miss" : expired ? "ttl-expired" : "hit"
+            });
+            if (!cached || expired)
+              pending.add(part);
+            if (part === this.state)
+              break;
+            part = dirname2(part);
+          }
+        }
+        if (!pending.size)
+          return;
+        try {
+          const root = this.auditRoot(paths.at(-1) ?? this.state);
+          const ancestors = [...pending].filter((path) => path !== root && !path.startsWith(root + sep2));
+          const tree = [...pending].filter((path) => !ancestors.includes(path));
+          for (const part of [...ancestors, ...tree.length ? [root] : []]) {
+            const recursive = part === root && root.startsWith(join2(this.state, "runtimes") + sep2);
+            this.traceAudit({ event: "audit", root: part, recursive });
+            const requested = part === root ? tree : [part];
+            if (this.options.cacheDirectories && !this.windowsDirectories.has(part) && this.windowsAudit.get(part)?.verdict === "ok") {
+              await verifyWindowsAcl(part, this.run, this.state);
+              this.windowsAudit.set(part, { verdict: "ok", checkedAt: this.now() });
+              continue;
+            }
+            const verdicts = await auditWindowsPermissions(part, requested, this.run, recursive, this.state);
+            const checkedAt = this.now();
+            for (const path of /* @__PURE__ */ new Set([...requested, ...verdicts.keys()])) {
+              let verdict = verdicts.get(path);
+              if (verdict === void 0) {
+                await verifyWindowsPermission(path, this.run, this.state);
+                verdict = "ok";
+              }
+              this.windowsAudit.set(path, { verdict, checkedAt });
+            }
+          }
+        } catch (error) {
+          throw new RuntimeError(error instanceof Error && error.message === "acl_permissions" ? "permission" : "acl_unavailable");
+        }
+      }
+      async inspect(path, directory = false, allowMissing = false, replacing = false) {
+        const absolute = this.guardedPath(path);
+        const windowsPaths = [];
+        let part = parse(absolute).root;
+        for (const name of absolute.slice(part.length).split(sep2)) {
+          part = join2(part, name);
+          const stat = await lstat(part).catch((e) => {
+            if (allowMissing && missing(e))
+              return null;
+            throw e;
+          });
+          if (!stat)
+            break;
+          if (stat.isSymbolicLink() || (part === absolute ? directory ? !stat.isDirectory() : !stat.isFile() : !stat.isDirectory()))
+            throw new RuntimeError("permission");
+          if (part !== this.state && !part.startsWith(this.state + sep2))
+            continue;
+          if (process.platform === "win32") {
+            if (replacing && part === absolute)
+              continue;
+            if (part === this.state && !this.windowsStats.has(part)) {
+              await prepareWindowsAclDirectory(this.state, this.run).catch((error) => {
+                throw new RuntimeError(error instanceof Error && error.message === "acl_permissions" ? "permission" : "acl_unavailable");
+              });
+              Object.assign(stat, await lstat(part));
+            }
+            if (stat.isDirectory())
+              this.windowsDirectories.add(part);
+            const identity = statIdentity(stat);
+            const previous = this.windowsStats.get(part);
+            if (previous !== void 0 && previous !== identity) {
+              this.traceAudit({
+                event: "invalidate",
+                requested: absolute,
+                path: part,
+                root: this.auditRoot(part),
+                reason: "stat-identity",
+                previous,
+                current: identity
+              });
+              this.invalidateAudit(part);
+            }
+            this.windowsStats.set(part, identity);
+            windowsPaths.push(part);
+          } else if (stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
+            throw new RuntimeError("permission");
+        }
+        await this.audit(windowsPaths);
+        for (const part2 of windowsPaths) {
+          const verdict = this.windowsAudit.get(part2)?.verdict;
+          if (verdict !== "ok")
+            throw new RuntimeError(verdict === void 0 || verdict === "acl_unavailable" ? "acl_unavailable" : "permission");
+        }
+      }
+      /** Call only after an owned atomic replacement: its parent ctime is our own write. */
+      async recordReplacement(path) {
+        if (process.platform !== "win32" || !this.options.cacheDirectories)
+          return;
+        const absolute = this.guardedPath(path);
+        const parent = dirname2(absolute);
+        const stat = await lstat(parent);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || !this.windowsStats.get(parent)?.startsWith(`${stat.dev}:${stat.ino}:`))
+          throw new RuntimeError("permission");
+        this.windowsStats.set(parent, statIdentity(stat));
+        this.windowsAudit.delete(absolute);
+        this.windowsStats.delete(absolute);
+      }
+      async bytes(path) {
+        await this.inspect(path);
+        const fd = await open(path, constants.O_RDONLY | (process.platform === "win32" ? 0 : constants.O_NOFOLLOW));
+        try {
+          return await fd.readFile();
+        } finally {
+          await fd.close();
+        }
+      }
+      /** An owned inheritable ACL update can change every cached descendant's ctime. */
+      async recordAclWrite(path) {
+        const root = this.guardedPath(path);
+        for (const known of this.windowsStats.keys())
+          if (known === root || known.startsWith(root + sep2))
+            this.windowsStats.set(known, statIdentity(await lstat(known)));
+        this.invalidateAudit(root);
+      }
+      async pointer(artifact) {
+        try {
+          const p = JSON.parse((await this.bytes(this.pointerPath(artifact))).toString());
+          for (const ref of [p.current, ...p.previous ? [p.previous] : []]) {
+            versionName(ref.version);
+            if (!/^[a-f0-9]{64}$/.test(ref.manifestSha256))
+              throw new RuntimeError("digest_mismatch");
+          }
+          return p;
+        } catch (e) {
+          if (missing(e))
+            return void 0;
+          throw e instanceof RuntimeError ? e : new RuntimeError("digest_mismatch");
+        }
+      }
+      async operation(work) {
+        const operation = this.operations.then(async () => {
+          this.activeOperation = true;
+          try {
+            return await work();
+          } finally {
+            this.activeOperation = false;
+          }
+        });
+        this.operations = operation.catch(() => void 0);
+        return operation;
+      }
+      verifyAt(artifact, ref, directory) {
+        return this.operation(() => this.verifyOpen(artifact, ref, directory));
+      }
+      async verifyOpen(artifact, ref, directory) {
+        let bytes;
+        try {
+          bytes = await this.bytes(join2(directory, "manifest.json"));
+        } catch (e) {
+          if (missing(e))
+            throw new RuntimeError("manifest_missing");
+          throw e;
+        }
+        if (hash(bytes) !== ref.manifestSha256)
+          throw new RuntimeError("digest_mismatch");
+        let m;
+        try {
+          m = JSON.parse(bytes.toString());
+        } catch {
+          throw new RuntimeError("digest_mismatch");
+        }
+        if (!m || m.schemaVersion !== 1 || !m.source || m.artifact !== artifact || m.version !== ref.version || !m.files || !m.files[safePath(m.entry)])
+          throw new RuntimeError("digest_mismatch");
+        if (artifact === "scanner" && (m.source.kind !== "release" || typeof m.source.url !== "string" || !m.source.url.startsWith("https://") || (!m.signer || m.signer.platform !== process.platform) && !(this.options.allowUnsigned && !m.signer && m.signingStatus === "unsigned")))
+          throw new RuntimeError("unsigned");
+        if (artifact === "cli" && (m.source.kind !== "npm" || !Array.isArray(m.source.packages) || !m.source.packages.some((p) => p.name === "@mnemonik/cli" && p.version === m.version)))
+          throw new RuntimeError("unsigned");
+        if (process.platform === "win32")
+          await this.audit(Object.keys(m.files).map((name) => join2(directory, safePath(name))));
+        const actual = [];
+        const walk = async (dir, prefix = "") => {
+          await this.inspect(dir, true);
+          for (const name of await readdir(dir)) {
+            const key = prefix + name;
+            if (!prefix && name === "manifest.json")
+              continue;
+            const path = join2(dir, name);
+            if ((await lstat(path)).isDirectory())
+              await walk(path, key + "/");
+            else {
+              await this.inspect(path);
+              actual.push(key);
+            }
+          }
+        };
+        await walk(directory);
+        if (actual.sort().join("\n") !== Object.keys(m.files).sort().join("\n"))
+          throw new RuntimeError("digest_mismatch");
+        let total = 0;
+        for (const [name, expected] of Object.entries(m.files)) {
+          if (!expected || !/^[a-f0-9]{64}$/.test(expected.sha256) || !Number.isSafeInteger(expected.size) || expected.size < 0 || typeof expected.executable !== "boolean")
+            throw new RuntimeError("digest_mismatch");
+          const path = join2(directory, safePath(name));
+          const contents = await this.bytes(path);
+          if (hash(contents) !== expected.sha256 || contents.length !== expected.size)
+            throw new RuntimeError("digest_mismatch");
+          if (process.platform !== "win32" && ((await lstat(path)).mode & 511) !== (expected.executable ? 448 : 384))
+            throw new RuntimeError("permission");
+          total += contents.length;
+        }
+        if (total !== m.totalSize)
+          throw new RuntimeError("digest_mismatch");
+        if (m.signer) {
+          const signer = m.signer.platform === "linux" ? { ...m.signer, signature: join2(directory, safePath(m.signer.signature)) } : m.signer;
+          if (m.signer.platform === "linux" && !m.files[m.signer.signature])
+            throw new RuntimeError("unsigned");
+          try {
+            const entry = join2(directory, m.entry);
+            if (signer.platform === "win32") {
+              const key = JSON.stringify([entry, m.files[m.entry]?.sha256, signer.identity]);
+              let verification = _RuntimeReader.windowsSignatures.get(key);
+              if (!verification) {
+                verification = verifySigner(entry, signer, this.run).catch((error) => {
+                  _RuntimeReader.windowsSignatures.delete(key);
+                  throw error;
+                });
+                _RuntimeReader.windowsSignatures.set(key, verification);
+              }
+              await verification;
+            } else
+              await verifySigner(entry, signer, this.run);
+          } catch {
+            throw new RuntimeError("unsigned");
+          }
+        }
+        return { directory, manifest: m, entry: join2(directory, m.entry), reference: ref };
+      }
+      async verifyRuntime(artifact) {
+        return this.operation(async () => {
+          const p = await this.pointer(artifact);
+          if (!p)
+            throw new RuntimeError("manifest_missing");
+          return this.verifyOpen(artifact, p.current, join2(dirname2(this.pointerPath(artifact)), p.current.version));
+        });
+      }
+    };
+  }
+});
+
+// packages/shared/dist/projectSetupHandoff.js
+var init_projectSetupHandoff = __esm({
+  "packages/shared/dist/projectSetupHandoff.js"() {
+    "use strict";
+    init_runtimeSigners();
+    init_runtimeReader();
+  }
+});
+
+// packages/shared/dist/hookRuntime.js
+var init_hookRuntime = __esm({
+  "packages/shared/dist/hookRuntime.js"() {
+    "use strict";
+    init_runtimeSigners();
+    init_repositoryRoot();
+    init_runtimeReader();
+    init_runtimeSigners();
+    init_projectSetupHandoff();
+  }
+});
+
+// packages/cli/src/runtime/store.ts
+init_hookRuntime();
+init_hookRuntime();
+import { createHash as createHash3 } from "node:crypto";
+import { lstat as lstat2, mkdir, mkdtemp, open as open2, readdir as readdir2, rename, rm } from "node:fs/promises";
+import { dirname as dirname3, join as join3 } from "node:path";
+var RuntimeStore = class extends RuntimeReader {
+  async withMutationLock(artifact, work) {
+    const { withLock } = await import('../vendor/local-setup.js');
+    return withLock(join3(dirname3(this.pointerPath(artifact)), "mutation"), 5e3, work);
+  }
+  async installRuntime(artifact, version, source) {
+    const base = dirname3(this.pointerPath(artifact));
+    versionName(version);
+    if (source.manifest.version !== version || source.manifest.artifact !== artifact)
+      throw new RuntimeError("digest_mismatch");
+    const manifest = Buffer.from(JSON.stringify(source.manifest));
+    const ref = { version, manifestSha256: hash(manifest) };
+    const pointer = await this.pointer(artifact);
+    const installed = pointer?.current;
+    if (installed?.version === version && installed.manifestSha256 === ref.manifestSha256)
+      return this.verifyAt(artifact, installed, join3(base, installed.version));
+    const { atomicWrite, withLock, windowsCurrentUserAcl } = await import('../vendor/local-setup.js');
+    await this.inspect(base, true, true);
+    const created = [];
+    if (process.platform === "win32")
+      for (const path of [this.state, dirname3(base), base])
+        await lstat2(path).catch((error) => {
+          if (!missing(error)) throw error;
+          created.push(path);
+        });
+    await mkdir(base, { recursive: true, mode: 448 });
+    for (const path of created) {
+      await windowsCurrentUserAcl(path, true);
+      await this.recordAclWrite(path);
+    }
+    await this.inspect(base, true);
+    return withLock(join3(base, "mutation"), 5e3, async (assertOwned) => {
+      const previous = await this.pointer(artifact);
+      if (previous) await this.verifyRuntime(artifact);
+      const stage = await mkdtemp(join3(base, ".stage-"));
+      const target = join3(base, version);
+      try {
+        for (const [name, bytes] of Object.entries(source.files)) {
+          const path = join3(stage, safePath(name));
+          if (name === "manifest.json") throw new RuntimeError("permission");
+          await mkdir(dirname3(path), { recursive: true, mode: 448 });
+          const fd = await open2(
+            path,
+            "wx",
+            source.manifest.files[name]?.executable ? 448 : 384
+          );
+          try {
+            await fd.writeFile(bytes);
+            await fd.sync();
+          } finally {
+            await fd.close();
+          }
+        }
+        await atomicWrite(join3(stage, "manifest.json"), manifest, void 0, assertOwned);
+        await this.verifyAt(artifact, ref, stage);
+        const known = [previous?.current, previous?.previous].find((r) => r?.version === version);
+        if (known) {
+          const existing = await this.verifyAt(artifact, known, target);
+          if (JSON.stringify(existing.manifest.files) !== JSON.stringify(source.manifest.files) || existing.manifest.entry !== source.manifest.entry)
+            throw new RuntimeError("digest_mismatch");
+          ref.manifestSha256 = known.manifestSha256;
+        }
+        if (process.platform !== "win32") {
+          const sync = async (dir) => {
+            for (const entry of await readdir2(dir, { withFileTypes: true }))
+              if (entry.isDirectory()) await sync(join3(dir, entry.name));
+            const fd = await open2(dir, "r");
+            try {
+              await fd.sync();
+            } finally {
+              await fd.close();
+            }
+          };
+          await sync(stage);
+        }
+        await assertOwned();
+        try {
+          await lstat2(target);
+          await this.verifyAt(artifact, ref, target);
+        } catch (e) {
+          if (!missing(e)) throw e;
+          await rename(stage, target);
+        }
+        await this.verifyAt(artifact, ref, target);
+        if (previous?.current.version !== version)
+          await atomicWrite(
+            this.pointerPath(artifact),
+            Buffer.from(JSON.stringify({ current: ref, previous: previous?.current })),
+            void 0,
+            assertOwned
+          );
+        return this.verifyRuntime(artifact);
+      } finally {
+        await rm(stage, { recursive: true, force: true });
+      }
+    });
+  }
+  async rollbackRuntime(artifact, expectedCurrent) {
+    await this.inspect(dirname3(this.pointerPath(artifact)), true);
+    const { atomicWrite, withLock } = await import('../vendor/local-setup.js');
+    return withLock(
+      join3(dirname3(this.pointerPath(artifact)), "mutation"),
+      5e3,
+      async (assertOwned) => {
+        const p = await this.pointer(artifact);
+        if (!p?.previous) throw new RuntimeError("manifest_missing");
+        if (expectedCurrent && p.current.manifestSha256 !== expectedCurrent.manifestSha256)
+          throw new RuntimeError("digest_mismatch");
+        await this.verifyAt(
+          artifact,
+          p.previous,
+          join3(dirname3(this.pointerPath(artifact)), p.previous.version)
+        );
+        await atomicWrite(
+          this.pointerPath(artifact),
+          Buffer.from(JSON.stringify({ current: p.previous, previous: p.current })),
+          void 0,
+          assertOwned
+        );
+        return this.verifyRuntime(artifact);
+      }
+    );
+  }
+};
+async function updateRuntime(update) {
+  const source = await update.source();
+  const { artifact, version } = source.manifest;
+  const before = await update.store.verifyRuntime(artifact);
+  const installed = await update.store.installRuntime(artifact, version, source);
+  try {
+    await update.restartManagedServices(update.store.pointerPath(artifact));
+  } catch (e) {
+    if (before.reference.version !== version)
+      await update.store.rollbackRuntime(artifact, installed.reference);
+    await update.restartManagedServices(update.store.pointerPath(artifact));
+    throw e;
+  }
+  return installed;
+}
+async function hostNpmSource(host, pin, fetcher = fetch) {
+  const { releaseBytes } = await import("./releaseSource.js");
+  const { unpack } = await import("./bootstrap.js");
+  if (pin.package !== `@mnemonik/${host}-hooks` || !/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(pin.version) || !pin.closure.length || pin.closure.length > 100 || pin.closure[0]?.name !== pin.package || pin.closure[0]?.version !== pin.version)
+    throw new RuntimeError("unsigned");
+  const files = {};
+  const packages = [];
+  const seen = /* @__PURE__ */ new Set();
+  const exactBytes = async (address, name, version) => {
+    try {
+      return await releaseBytes(address, fetcher);
+    } catch (error) {
+      if (error instanceof RuntimeError && error.reason === "manifest_missing")
+        error.message = `manifest_missing: ${name}@${version}`;
+      throw error;
+    }
+  };
+  for (const expected of pin.closure) {
+    const { name, version, integrity } = expected;
+    if (!/^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/.test(name) || !/^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(version) || seen.has(name))
+      throw new RuntimeError("unsigned");
+    seen.add(name);
+    const metadata = JSON.parse(
+      (await exactBytes(
+        `https://registry.npmjs.org/${encodeURIComponent(name)}/${version}`,
+        name,
+        version
+      )).toString()
+    );
+    if (metadata.name !== name || metadata.version !== version) throw new RuntimeError("unsigned");
+    if (metadata.dist.integrity !== integrity) throw new RuntimeError("digest_mismatch");
+    const tarball = await exactBytes(metadata.dist.tarball, name, version);
+    const match = /^(sha512|sha256)-([A-Za-z0-9+/=]+)$/.exec(integrity);
+    if (!match || createHash3(match[1] ?? "sha512").update(tarball).digest("base64") !== match[2])
+      throw new RuntimeError("digest_mismatch");
+    const contents = unpack(tarball);
+    const pkg = JSON.parse(contents["package.json"]?.toString() ?? "{}");
+    if (pkg.name !== name || pkg.version !== version || ["preinstall", "install", "postinstall", "prepare"].some((k) => pkg.scripts?.[k]) || Object.keys(pkg.optionalDependencies ?? {}).length)
+      throw new RuntimeError("unsigned");
+    const prefix = `node_modules/${name}/`;
+    for (const [path, bytes] of Object.entries(contents)) files[prefix + path] = bytes;
+    packages.push({
+      name,
+      version: pkg.version,
+      integrity,
+      tarball: metadata.dist.tarball,
+      tarballSha256: hash(tarball)
+    });
+  }
+  return {
+    files,
+    manifest: {
+      schemaVersion: 1,
+      artifact: host,
+      version: pin.version,
+      entry: `node_modules/${pin.package}/dist/hook.js`,
+      files: Object.fromEntries(
+        Object.entries(files).map(([name, bytes]) => [
+          name,
+          { sha256: hash(bytes), size: bytes.length, executable: false }
+        ])
+      ),
+      totalSize: Object.values(files).reduce((sum, bytes) => sum + bytes.length, 0),
+      source: { kind: "npm", packages, launchedFrom: "@mnemonik/cli" }
+    }
+  };
+}
+export {
+  RuntimeError,
+  RuntimeStore,
+  hash,
+  hostNpmSource,
+  safePath,
+  updateRuntime
+};