@koed-labs/server 0.0.0-bootstrap.0 → 0.10.3

package/vendor/chunk-2DA7EFZV.js

@@ -0,0 +1,924 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+
+// packages/koed-server/dist/package-runtime.js
+import { createHash, createPublicKey, verify } from "node:crypto";
+
+// packages/koed-server/dist/artifact-canonical-json.mjs
+import { Buffer as Buffer2 } from "node:buffer";
+function canonicalArtifactJson(value) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const encode = (item) => {
+    if (item === null)
+      return "null";
+    if (typeof item === "string" || typeof item === "boolean")
+      return JSON.stringify(item);
+    if (typeof item === "number" && Number.isFinite(item))
+      return JSON.stringify(item);
+    if (typeof item !== "object")
+      throw new TypeError("artifact has unsupported JSON value");
+    const array = Array.isArray(item);
+    const prototype = Object.getPrototypeOf(item);
+    if (!array && prototype !== Object.prototype && prototype !== null)
+      throw new TypeError("artifact has unsupported JSON object");
+    if (Object.getOwnPropertySymbols(item).length)
+      throw new TypeError("artifact has unsupported JSON symbol key");
+    if (ancestors.has(item))
+      throw new TypeError("artifact has cyclic JSON value");
+    ancestors.add(item);
+    try {
+      if (array) {
+        const entries = [];
+        for (let index = 0; index < item.length; index++) {
+          if (!Object.hasOwn(item, index))
+            throw new TypeError("artifact has sparse JSON array");
+          entries.push(encode(item[index]));
+        }
+        return `[${entries.join(",")}]`;
+      }
+      return `{${Object.keys(item).sort().map((key) => `${JSON.stringify(key)}:${encode(item[key])}`).join(",")}}`;
+    } finally {
+      ancestors.delete(item);
+    }
+  };
+  return encode(value);
+}
+function canonicalArtifactBytes(value) {
+  return Buffer2.from(canonicalArtifactJson(value), "utf8");
+}
+
+// packages/koed-server/dist/package-runtime.js
+import { createGunzip } from "node:zlib";
+import { chmodSync, closeSync, cpSync, createReadStream, createWriteStream, existsSync, lstatSync, openSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, symlinkSync, writeSync } from "node:fs";
+import { constants as fsConstants, statSync } from "node:fs";
+import { basename, dirname, relative, resolve } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Readable, Transform } from "node:stream";
+var standalonePackageSchemaVersion = 2;
+var standalonePackageId = "koed-server";
+var standalonePackageKind = "app-runtime";
+var packageProvenanceSchemaVersion = 1;
+var packageExtractionLimits = {
+  compressedBytes: 2 * 1024 * 1024 * 1024,
+  expandedBytes: 8 * 1024 * 1024 * 1024,
+  fileCount: 2e5,
+  individualFileBytes: 2 * 1024 * 1024 * 1024,
+  pathBytes: 4096,
+  manifestBytes: 8 * 1024 * 1024,
+  paxHeaderBytes: 1024 * 1024
+};
+var requiredPackageRuntimeFiles = [
+  "api/dist/index.js",
+  "worker/dist/index.js",
+  "embedding-service/dist/index.js",
+  "mcp-server/dist/cli.js",
+  "mcp-server/dist/capture-hook.js",
+  "mcp-server/dist/prompts/codex-global-agent-guidance.md",
+  "node_modules/@koed/db/dist/index.js",
+  "node_modules/@koed/db/dist/connection.js",
+  "node_modules/@koed/db/dist/user-api-token-repository.js",
+  "node_modules/@koed/db/drizzle/meta/_journal.json"
+];
+var excludedPackagePatterns = [
+  /^koed-runtime\/explorer-dist(?:\/|$)/,
+  /^koed-server\/dist\/explorer-static-(?:proxy|server)(?:\.|$)/,
+  /^koed-runtime\/postgres(?:\/|$)/,
+  /^koed-runtime\/llama\.cpp(?:\/|$)/,
+  /^koed-runtime\/runtime-asset-manifest\.json$/,
+  /^koed-runtime\/.*\.gguf$/,
+  /^koed-runtime\/.*\.safetensors$/,
+  /^koed-runtime\/.*\.onnx$/,
+  /^koed-runtime\/embedding-service\/\.venv(?:\/|$)/,
+  /^koed-runtime\/embedding-service\/.*\.py$/,
+  /^koed-runtime\/embedding-service\/requirements\.txt$/,
+  /^koed-runtime\/embedding-service\/pyproject\.toml$/
+];
+var pnpmWorkspaceSelfSymlinkPattern = /^(?<root>koed-server|koed-runtime\/api|koed-runtime\/worker|koed-runtime\/embedding-service|koed-runtime\/mcp-server)\/node_modules\/\.pnpm\/node_modules\/@koed\/(?<name>[^/]+)$/;
+var packageSelfNames = {
+  "koed-server": "koed-server",
+  "koed-runtime/api": "api",
+  "koed-runtime/worker": "worker",
+  "koed-runtime/embedding-service": "embedding-service",
+  "koed-runtime/mcp-server": "mcp-server"
+};
+var platformKey = (platform = process.platform) => {
+  if (platform === "darwin")
+    return "macos";
+  if (platform === "win32")
+    return "windows";
+  return platform;
+};
+var normalizeSha256 = (value) => {
+  const normalized = value.trim().toLowerCase().split(/\s+/)[0] ?? "";
+  if (!/^[a-f0-9]{64}$/.test(normalized)) {
+    throw new Error("Package SHA-256 must be 64 hex characters.");
+  }
+  return normalized;
+};
+var validatePackageVersion = (version) => {
+  if (!/^[0-9A-Za-z][0-9A-Za-z._+-]*$/.test(version)) {
+    throw new Error("Package version must be a safe filename segment containing only letters, numbers, dots, underscores, plus signs, or hyphens.");
+  }
+  if (version === "." || version === ".." || version.includes("..")) {
+    throw new Error("Package version must not contain path traversal.");
+  }
+  return version;
+};
+var isInside = (base, child) => {
+  const rel = relative(resolve(base), resolve(child));
+  return rel === "" || !rel.startsWith("..") && rel !== "..";
+};
+var safeResolve = (base, path) => {
+  if (path.includes("\0")) {
+    throw new Error(`Package path contains NUL byte: ${path}`);
+  }
+  const resolved = resolve(base, path);
+  if (!isInside(base, resolved)) {
+    throw new Error(`Package path escapes base directory: ${path}`);
+  }
+  return resolved;
+};
+var packageRoot = (paths) => resolve(paths.koedHome, "runtime", "koed-server");
+var packageVersionsDir = (paths) => resolve(packageRoot(paths), "versions");
+var packageCacheDir = (paths) => resolve(paths.cacheDir, "koed-server-packages");
+var packageCurrentPath = (paths) => resolve(packageRoot(paths), "current");
+var isPnpmWorkspaceSelfSymlink = (path) => {
+  const match = path.match(pnpmWorkspaceSelfSymlinkPattern);
+  if (!match?.groups)
+    return false;
+  const { name, root } = match.groups;
+  return Boolean(root && name && name === packageSelfNames[root]);
+};
+var listFiles = (root, dir = root) => readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+  const path = resolve(dir, entry.name);
+  const relativePath = relative(root, path).replaceAll("\\", "/");
+  if (isPnpmWorkspaceSelfSymlink(relativePath))
+    return [];
+  if (entry.isDirectory())
+    return listFiles(root, path);
+  return [relativePath];
+});
+var sha256File = (path) => {
+  const hash = createHash("sha256");
+  const stat = lstatSync(path);
+  if (stat.isSymbolicLink()) {
+    hash.update("symlink");
+    hash.update("\0");
+    hash.update(readlinkSync(path));
+  } else {
+    hash.update(readFileSync(path));
+  }
+  return hash.digest("hex");
+};
+var sha256Files = (root, files) => {
+  const hash = createHash("sha256");
+  for (const file of [...new Set(files)].sort()) {
+    const path = resolve(root, file);
+    const stat = lstatSync(path);
+    if (stat.isDirectory())
+      continue;
+    hash.update(file.replaceAll("\\", "/"));
+    hash.update("\0");
+    if (stat.isSymbolicLink()) {
+      hash.update("symlink");
+      hash.update("\0");
+      hash.update(readlinkSync(path));
+    } else {
+      hash.update(readFileSync(path));
+    }
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+};
+var readJson = (path) => JSON.parse(readFileSync(path, "utf8"));
+var compareIdentifiers = (left, right) => {
+  if (left === right)
+    return 0;
+  const leftNumeric = /^\d+$/.test(left);
+  const rightNumeric = /^\d+$/.test(right);
+  if (leftNumeric && rightNumeric)
+    return BigInt(left) < BigInt(right) ? -1 : BigInt(left) > BigInt(right) ? 1 : 0;
+  if (leftNumeric !== rightNumeric)
+    return leftNumeric ? -1 : 1;
+  return left < right ? -1 : 1;
+};
+var compareVersions = (a, b) => {
+  const parts = (version) => {
+    const withoutBuild = version.split("+")[0];
+    const separator = withoutBuild.indexOf("-");
+    return {
+      core: (separator < 0 ? withoutBuild : withoutBuild.slice(0, separator)).split("."),
+      prerelease: separator < 0 ? [] : withoutBuild.slice(separator + 1).split(".")
+    };
+  };
+  const left = parts(a), right = parts(b);
+  for (let index = 0; index < 3; index++) {
+    const order = compareIdentifiers(left.core[index] ?? "0", right.core[index] ?? "0");
+    if (order)
+      return order;
+  }
+  if (!left.prerelease.length || !right.prerelease.length)
+    return Number(right.prerelease.length > 0) - Number(left.prerelease.length > 0);
+  for (let index = 0; index < Math.max(left.prerelease.length, right.prerelease.length); index++) {
+    const l = left.prerelease[index], r = right.prerelease[index];
+    if (l === void 0)
+      return -1;
+    if (r === void 0)
+      return 1;
+    const order = compareIdentifiers(l, r);
+    if (order)
+      return order;
+  }
+  return 0;
+};
+var validateManifestShape = (manifest) => {
+  const errors = [];
+  if (!manifest || typeof manifest !== "object") {
+    return ["Package manifest must be an object."];
+  }
+  if (manifest.schemaVersion !== standalonePackageSchemaVersion) {
+    errors.push("Package manifest schemaVersion must be 2 for shared staging; upgrade koed-server or rebuild the package with the current release tooling.");
+  }
+  if (manifest.id !== standalonePackageId) {
+    errors.push("Package manifest id must be koed-server.");
+  }
+  if (manifest.packageKind !== standalonePackageKind) {
+    errors.push("Package manifest packageKind must be app-runtime.");
+  }
+  for (const key of [
+    "version",
+    "platform",
+    "architecture",
+    "createdAt"
+  ]) {
+    const value = manifest[key];
+    if (typeof value !== "string" || value.length === 0) {
+      errors.push(`Package manifest ${key} must be a non-empty string.`);
+    }
+  }
+  if (typeof manifest.version === "string" && manifest.version.length > 0) {
+    try {
+      validatePackageVersion(manifest.version);
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (manifest.koedRuntime?.path !== "koed-runtime") {
+    errors.push("Package manifest koedRuntime.path must be koed-runtime.");
+  }
+  if (!Array.isArray(manifest.koedRuntime?.requiredFiles)) {
+    errors.push("Package manifest koedRuntime.requiredFiles must be an array.");
+  }
+  if (!Array.isArray(manifest.files)) {
+    errors.push("Package manifest files must be an array.");
+  }
+  if (!/^[a-f0-9]{64}$/.test(manifest.sha256 ?? "")) {
+    errors.push("Package manifest sha256 must be 64 hex characters.");
+  }
+  if (!manifest.database || typeof manifest.database !== "object") {
+    errors.push("Package manifest database must be an object.");
+  }
+  if (!manifest.provenance || typeof manifest.provenance !== "object") {
+    errors.push("Package manifest provenance must be an object.");
+  }
+  return errors;
+};
+var validateCompatibility = (manifest, platform = platformKey(), architecture = process.arch, nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10)) => {
+  if (!manifest)
+    return [];
+  const errors = [];
+  if (manifest.platform !== platform) {
+    errors.push(`Package platform ${manifest.platform} is incompatible with ${platform}.`);
+  }
+  if (manifest.architecture !== architecture) {
+    errors.push(`Package architecture ${manifest.architecture} is incompatible with ${architecture}.`);
+  }
+  const minimumNodeMajor = manifest.nodeRuntime?.minimumNodeMajor;
+  if (typeof minimumNodeMajor === "number" && Number.isFinite(minimumNodeMajor) && nodeMajor < minimumNodeMajor) {
+    errors.push(`Package requires Node ${minimumNodeMajor} or newer; current Node major is ${nodeMajor}.`);
+  }
+  return errors;
+};
+var validateServerPackageRoot = (root) => {
+  const resolvedRoot = resolve(root);
+  const manifestPath = resolve(resolvedRoot, "koed-server-package-manifest.json");
+  const manifest = existsSync(manifestPath) ? readJson(manifestPath) : null;
+  const manifestErrors = validateManifestShape(manifest);
+  const runtimePath = manifest?.koedRuntime?.path ?? "koed-runtime";
+  const runtimeRoot = resolve(resolvedRoot, runtimePath);
+  const requiredFiles = Array.isArray(manifest?.koedRuntime?.requiredFiles) ? manifest.koedRuntime.requiredFiles : requiredPackageRuntimeFiles;
+  const missing = [
+    !existsSync(manifestPath) ? "koed-server-package-manifest.json" : null,
+    !existsSync(resolve(resolvedRoot, "README.txt")) ? "README.txt" : null,
+    !existsSync(resolve(resolvedRoot, "bin", "koed")) && !existsSync(resolve(resolvedRoot, "bin", "koed-server")) ? "bin/koed" : null,
+    !existsSync(resolve(runtimeRoot, "koed-server", "dist", "cli.js")) ? "koed-runtime/koed-server/dist/cli.js" : null,
+    ...requiredFiles.map((file) => existsSync(resolve(runtimeRoot, file)) ? null : `${runtimePath}/${file}`)
+  ].filter((file) => Boolean(file));
+  const files = existsSync(resolvedRoot) ? listFiles(resolvedRoot) : [];
+  const excluded = files.filter((file) => excludedPackagePatterns.some((pattern) => pattern.test(file)));
+  const actualFiles = files.filter((file) => file !== "koed-server-package-manifest.json");
+  const actualSha256 = existsSync(resolvedRoot) && actualFiles.length > 0 ? sha256Files(resolvedRoot, actualFiles) : void 0;
+  const manifestFileErrors = Array.isArray(manifest?.files) ? manifest.files.flatMap((entry) => {
+    if (!entry || typeof entry.path !== "string" || !/^[a-f0-9]{64}$/.test(entry.sha256 ?? "")) {
+      return ["Package manifest files entries require path and sha256."];
+    }
+    const path = safeResolve(resolvedRoot, entry.path);
+    if (!existsSync(path))
+      return [`Manifest file is missing: ${entry.path}`];
+    const actual = sha256File(path);
+    return actual === entry.sha256 ? [] : [`Manifest file SHA-256 mismatch: ${entry.path}`];
+  }) : [];
+  const shaErrors = manifest?.sha256 && actualSha256 && manifest.sha256 !== actualSha256 ? ["Package manifest sha256 does not match package files."] : [];
+  const compatibilityErrors = validateCompatibility(manifest);
+  const errors = [
+    ...manifestErrors,
+    ...missing.map((file) => `Missing required package file: ${file}`),
+    ...excluded.map((file) => `Excluded file is present: ${file}`),
+    ...manifestFileErrors,
+    ...shaErrors,
+    ...compatibilityErrors
+  ];
+  return {
+    ok: errors.length === 0,
+    packageRoot: resolvedRoot,
+    manifestPath,
+    manifest,
+    version: manifest?.version,
+    errors
+  };
+};
+var summarizeManifest = (manifest) => {
+  if (!manifest)
+    return null;
+  return {
+    schemaVersion: manifest.schemaVersion,
+    id: manifest.id,
+    version: manifest.version,
+    platform: manifest.platform,
+    architecture: manifest.architecture,
+    packageKind: manifest.packageKind,
+    createdAt: manifest.createdAt,
+    ...manifest.minimumDesktopVersion ? { minimumDesktopVersion: manifest.minimumDesktopVersion } : {},
+    ...manifest.maximumDesktopMajor !== void 0 ? { maximumDesktopMajor: manifest.maximumDesktopMajor } : {},
+    ...manifest.nodeRuntime ? { nodeRuntime: manifest.nodeRuntime } : {},
+    ...manifest.koedRuntime ? { koedRuntime: manifest.koedRuntime } : {},
+    ...manifest.database ? { database: manifest.database } : {},
+    ...manifest.provenance ? { provenance: manifest.provenance } : {},
+    ...manifest.sha256 ? { sha256: manifest.sha256 } : {},
+    fileCount: manifest.files?.length ?? 0
+  };
+};
+var readCurrentTarget = (paths) => {
+  const current = packageCurrentPath(paths);
+  if (!existsSync(current))
+    return void 0;
+  const stat = lstatSync(current);
+  return stat.isSymbolicLink() ? resolve(dirname(current), readlinkSync(current)) : current;
+};
+var collectServerPackageStatus = (paths) => {
+  const root = packageRoot(paths);
+  const versionsDir = packageVersionsDir(paths);
+  const cacheDir = packageCacheDir(paths);
+  const currentPath = packageCurrentPath(paths);
+  const currentTarget = readCurrentTarget(paths);
+  const versionNames = existsSync(versionsDir) ? readdirSync(versionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort() : [];
+  const installed = versionNames.map((version) => {
+    const path = resolve(versionsDir, version);
+    const validation = validateServerPackageRoot(path);
+    return {
+      version,
+      path,
+      ok: validation.ok,
+      active: currentTarget === path,
+      manifest: summarizeManifest(validation.manifest),
+      errors: validation.errors
+    };
+  });
+  const active = installed.find((entry) => entry.active);
+  const invalid = installed.filter((entry) => !entry.ok);
+  const currentVersion = active?.version;
+  const state = installed.length === 0 ? "missing" : active && active.ok && invalid.length === 0 ? "installed" : active && !active.ok ? "incompatible" : "partial";
+  return {
+    ok: state === "installed",
+    state,
+    koedHome: paths.koedHome,
+    packageRoot: root,
+    versionsDir,
+    cacheDir,
+    currentPath,
+    ...currentVersion ? { currentVersion } : {},
+    ...currentTarget ? { currentTarget } : {},
+    installed,
+    message: state === "installed" ? `koed-server package ${currentVersion} is active.` : state === "missing" ? "No koed-server package is installed." : "koed-server package installation needs attention.",
+    ...state === "missing" ? {
+      action: "Run koed package install --source <artifact> --sha256 <sha256>."
+    } : {},
+    ...invalid.length > 0 ? { errors: invalid.flatMap((entry) => entry.errors) } : {}
+  };
+};
+var readExpectedSha256 = (options) => {
+  if (options.sha256)
+    return normalizeSha256(options.sha256);
+  if (options.sha256File) {
+    return normalizeSha256(readFileSync(options.sha256File, "utf8"));
+  }
+  throw new Error("--sha256 or --sha256-file is required.");
+};
+var extractVerifiedPackageArchive = (archivePath, destination) => extractTarGz(archivePath, destination);
+var adjacentProvenancePath = (archivePath) => {
+  const archiveName = basename(archivePath);
+  const releaseName = archiveName.replace(/^koed-server-/, "koed-server-app-runtime-").replace(/\.tar\.gz$/, ".provenance.json");
+  const candidates = [
+    `${archivePath}.provenance.json`,
+    archivePath.replace(/\.tar\.gz$/, ".provenance.json"),
+    resolve(dirname(archivePath), releaseName)
+  ];
+  return candidates.find((candidate) => existsSync(candidate));
+};
+var readTrustedPublicKey = (options) => {
+  if (options.trustedPublicKey)
+    return options.trustedPublicKey;
+  if (options.trustedPublicKeyFile) {
+    return readFileSync(options.trustedPublicKeyFile, "utf8");
+  }
+  return process.env.KOED_SERVER_PACKAGE_TRUSTED_PUBLIC_KEY_PEM;
+};
+var verifyProvenanceSignature = ({ provenance, signature, publicKey }) => {
+  if (provenance.signature?.algorithm !== "ed25519") {
+    throw new Error("Package provenance signature algorithm must be ed25519.");
+  }
+  const key = createPublicKey(publicKey);
+  const payload = canonicalArtifactBytes(provenance.statement);
+  const ok = verify(null, payload, key, Buffer.from(signature, "base64"));
+  if (!ok) {
+    throw new Error("Package provenance signature verification failed.");
+  }
+};
+var validatePackageProvenance = ({ options, archivePath, archiveSha256, manifest }) => {
+  const policy = options.trustPolicy ?? "sha256-only";
+  const provenancePath = options.provenanceFile ?? adjacentProvenancePath(archivePath);
+  const publicKey = readTrustedPublicKey(options);
+  if (!provenancePath) {
+    if (policy === "sha256-only" && !publicKey) {
+      return { status: "not_checked", policy };
+    }
+    throw new Error("Package provenance metadata is required.");
+  }
+  const provenance = readJson(provenancePath);
+  const statement = provenance.statement;
+  if (statement?.schemaVersion !== packageProvenanceSchemaVersion) {
+    throw new Error("Package provenance schemaVersion must be 1.");
+  }
+  const subject = statement.subject;
+  if (subject?.id !== manifest.id || subject.packageKind !== manifest.packageKind) {
+    throw new Error("Package provenance subject does not match manifest.");
+  }
+  if (subject.version !== manifest.version || subject.platform !== manifest.platform || subject.architecture !== manifest.architecture) {
+    throw new Error("Package provenance version target does not match manifest.");
+  }
+  if (subject.archiveSha256 !== archiveSha256) {
+    throw new Error("Package provenance archive SHA-256 does not match.");
+  }
+  if (subject.packageSha256 !== manifest.sha256) {
+    throw new Error("Package provenance package SHA-256 does not match.");
+  }
+  const inlineSignature = provenance.signature?.value ?? void 0;
+  const signaturePath = options.signatureFile ?? (existsSync(`${provenancePath}.sig`) ? `${provenancePath}.sig` : void 0);
+  const signature = signaturePath ? readFileSync(signaturePath, "utf8").trim() : inlineSignature;
+  if (publicKey) {
+    if (!signature) {
+      throw new Error("Package provenance signature is required.");
+    }
+    verifyProvenanceSignature({ provenance, signature, publicKey });
+    return { status: "verified", policy, source: provenancePath };
+  }
+  if (policy === "require-signature") {
+    throw new Error("Package signature trust root is required.");
+  }
+  if (provenance.signature?.status === "unsigned-placeholder") {
+    return { status: "unsigned-placeholder", policy, source: provenancePath };
+  }
+  return { status: "not_checked", policy, source: provenancePath };
+};
+var activePackageManifest = (paths) => {
+  const target = readCurrentTarget(paths);
+  if (!target)
+    return null;
+  const validation = validateServerPackageRoot(target);
+  return validation.ok ? validation.manifest : null;
+};
+var migrationTimestamp = (manifest) => {
+  const value = manifest?.database?.migrationSet?.latestMigrationTimestamp;
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+};
+var isVersionDowngrade = (currentVersion, candidateVersion) => compareVersions(candidateVersion, currentVersion) < 0;
+var assertPackageMigrationCompatible = (currentManifest, nextManifest, allowDowngrade = false) => {
+  if (!isVersionDowngrade(currentManifest.version, nextManifest.version))
+    return;
+  if (!allowDowngrade) {
+    throw new Error(`Installing koed-server ${nextManifest.version} over active ${currentManifest.version} is a downgrade and requires --allow-downgrade.`);
+  }
+  const currentMigration = migrationTimestamp(currentManifest);
+  const nextMigration = migrationTimestamp(nextManifest);
+  if (currentMigration !== void 0 && nextMigration !== void 0 && nextMigration < currentMigration && nextManifest.database?.allowsRollback !== true) {
+    throw new Error("Downgrade would roll back the package migration set, and the target package does not allow rollback.");
+  }
+};
+var assertUpgradeCompatible = ({ paths, nextManifest, allowDowngrade = false }) => {
+  const currentManifest = activePackageManifest(paths);
+  if (!currentManifest?.version)
+    return;
+  assertPackageMigrationCompatible(currentManifest, nextManifest, allowDowngrade);
+};
+var copyAdjacentProvenanceSidecars = (sourcePath, targetPath) => {
+  const provenancePath = adjacentProvenancePath(sourcePath);
+  if (!provenancePath)
+    return;
+  const targetProvenancePath = resolve(dirname(targetPath), basename(provenancePath));
+  if (provenancePath !== targetProvenancePath) {
+    cpSync(provenancePath, targetProvenancePath);
+  }
+  const signaturePath = `${provenancePath}.sig`;
+  if (!existsSync(signaturePath))
+    return;
+  const targetSignaturePath = `${targetProvenancePath}.sig`;
+  if (signaturePath !== targetSignaturePath) {
+    cpSync(signaturePath, targetSignaturePath);
+  }
+};
+var copyOrDownloadArchive = async (source, cacheDir) => {
+  mkdirSync(cacheDir, { recursive: true, mode: 448 });
+  if (/^https?:\/\//i.test(source)) {
+    const response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(`Package download failed with HTTP ${response.status}.`);
+    }
+    if (!response.body)
+      throw new Error("Package download returned no body.");
+    const target2 = resolve(cacheDir, basename(new URL(source).pathname));
+    const temporaryTarget = `${target2}.download-${process.pid}-${Date.now()}`;
+    let received = 0;
+    const limiter = new Transform({
+      transform(chunk, _encoding, callback) {
+        received += chunk.length;
+        callback(received > packageExtractionLimits.compressedBytes ? new Error("Package archive exceeds the compressed byte limit.") : null, chunk);
+      }
+    });
+    try {
+      await pipeline(Readable.fromWeb(response.body), limiter, createWriteStream(temporaryTarget, { flags: "wx", mode: 384 }));
+      renameSync(temporaryTarget, target2);
+    } catch (error) {
+      rmSync(temporaryTarget, { force: true });
+      throw error;
+    }
+    return target2;
+  }
+  const sourcePath = resolve(source);
+  const target = resolve(cacheDir, basename(sourcePath));
+  if (sourcePath !== target) {
+    cpSync(sourcePath, target);
+  }
+  copyAdjacentProvenanceSidecars(sourcePath, target);
+  return target;
+};
+var tarString = (buffer, start, length) => buffer.subarray(start, start + length).toString("utf8").replace(/\0.*$/s, "");
+var tarNumber = (buffer, start, length) => {
+  const value = tarString(buffer, start, length).trim();
+  if (!value)
+    return 0;
+  if (!/^[0-7]+$/.test(value))
+    throw new Error("Malformed tar numeric field.");
+  const result = Number.parseInt(value, 8);
+  if (!Number.isSafeInteger(result))
+    throw new Error("Oversized tar numeric field.");
+  return result;
+};
+var parsePax = (content) => {
+  const result = {};
+  let offset = 0;
+  while (offset < content.length) {
+    const space = content.indexOf(32, offset);
+    if (space < 0)
+      throw new Error("Malformed pax header.");
+    const lengthText = content.subarray(offset, space).toString("ascii");
+    if (!/^\d+$/.test(lengthText))
+      throw new Error("Malformed pax header length.");
+    const length = Number.parseInt(lengthText, 10);
+    if (length <= space - offset + 1 || offset + length > content.length) {
+      throw new Error("Truncated pax header.");
+    }
+    const record = content.subarray(space + 1, offset + length - 1).toString("utf8");
+    const equals = record.indexOf("=");
+    if (equals <= 0)
+      throw new Error("Malformed pax header record.");
+    result[record.slice(0, equals)] = record.slice(equals + 1);
+    offset += length;
+  }
+  return result;
+};
+var assertSafeParents = (destination, target) => {
+  let current = dirname(target);
+  while (current !== destination) {
+    if (existsSync(current) && lstatSync(current).isSymbolicLink()) {
+      throw new Error("Package archive would write through a symlinked parent.");
+    }
+    const next = dirname(current);
+    if (next === current)
+      throw new Error("Package archive path escaped destination.");
+    current = next;
+  }
+};
+var extractTarGz = async (archivePath, destination) => {
+  if (statSync(archivePath).size > packageExtractionLimits.compressedBytes) {
+    throw new Error("Package archive exceeds the compressed byte limit.");
+  }
+  mkdirSync(destination, { recursive: true, mode: 448 });
+  const stream = createReadStream(archivePath).pipe(createGunzip());
+  let buffer = Buffer.alloc(0);
+  let pax = {};
+  const seen = /* @__PURE__ */ new Set();
+  let expandedBytes = 0;
+  let fileCount = 0;
+  let current;
+  let ended = false;
+  try {
+    for await (const chunk of stream) {
+      const bytes = Buffer.from(chunk);
+      buffer = buffer.length === 0 ? bytes : Buffer.concat([buffer, bytes]);
+      while (true) {
+        if (current) {
+          if (current.remaining > 0 && buffer.length > 0) {
+            const length = Math.min(current.remaining, buffer.length);
+            const part = buffer.subarray(0, length);
+            buffer = buffer.subarray(length);
+            current.remaining -= length;
+            if (current.fd !== void 0)
+              writeSync(current.fd, part);
+            else
+              current.chunks?.push(Buffer.from(part));
+          }
+          if (current.remaining > 0)
+            break;
+          if (current.fd !== void 0) {
+            closeSync(current.fd);
+            current.fd = void 0;
+            if (current.path && current.mode !== void 0) {
+              chmodSync(current.path, current.mode);
+            }
+          }
+          if (buffer.length < current.padding)
+            break;
+          buffer = buffer.subarray(current.padding);
+          if (current.type === "x")
+            pax = parsePax(Buffer.concat(current.chunks ?? []));
+          current = void 0;
+          continue;
+        }
+        if (buffer.length < 512)
+          break;
+        const header = buffer.subarray(0, 512);
+        buffer = buffer.subarray(512);
+        if (header.every((byte) => byte === 0)) {
+          ended = true;
+          break;
+        }
+        const storedChecksum = tarNumber(header, 148, 8);
+        const checksumHeader = Buffer.from(header);
+        checksumHeader.fill(32, 148, 156);
+        const actualChecksum = checksumHeader.reduce((sum, byte) => sum + byte, 0);
+        if (storedChecksum !== actualChecksum)
+          throw new Error("Malformed tar header checksum.");
+        const type = tarString(header, 156, 1) || "0";
+        const size = tarNumber(header, 124, 12);
+        if (size > packageExtractionLimits.individualFileBytes) {
+          throw new Error("Package archive entry exceeds the individual file limit.");
+        }
+        expandedBytes += size;
+        if (expandedBytes > packageExtractionLimits.expandedBytes) {
+          throw new Error("Package archive exceeds the expanded byte limit.");
+        }
+        const padding = (512 - size % 512) % 512;
+        if (type === "x") {
+          if (size > packageExtractionLimits.paxHeaderBytes) {
+            throw new Error("Pax header exceeds limit.");
+          }
+          current = { type, remaining: size, padding, chunks: [] };
+          continue;
+        }
+        const name = tarString(header, 0, 100);
+        const prefix = tarString(header, 345, 155);
+        const rawPath = pax.path ?? (prefix ? `${prefix}/${name}` : name);
+        pax = {};
+        if (Buffer.byteLength(rawPath) > packageExtractionLimits.pathBytes) {
+          throw new Error("Package archive path exceeds the path length limit.");
+        }
+        const target = safeResolve(destination, rawPath);
+        const normalized = relative(destination, target).replaceAll("\\", "/");
+        if (seen.has(normalized))
+          throw new Error(`Duplicate package archive path: ${normalized}`);
+        seen.add(normalized);
+        if (type === "5") {
+          if (size !== 0)
+            throw new Error("Directory tar entry must be empty.");
+          assertSafeParents(destination, target);
+          mkdirSync(target, { recursive: true, mode: 493 });
+        } else if (type === "0" || type === "") {
+          fileCount += 1;
+          if (fileCount > packageExtractionLimits.fileCount)
+            throw new Error("Package archive exceeds the file count limit.");
+          if (basename(target) === "koed-server-package-manifest.json" && size > packageExtractionLimits.manifestBytes) {
+            throw new Error("Package manifest exceeds the manifest size limit.");
+          }
+          mkdirSync(dirname(target), { recursive: true, mode: 493 });
+          assertSafeParents(destination, target);
+          const mode = tarNumber(header, 100, 8) & 73 ? 493 : 420;
+          const flags = fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY | (fsConstants.O_NOFOLLOW ?? 0);
+          const fd = openSync(target, flags, mode);
+          current = { type, remaining: size, padding, fd, path: target, mode };
+          continue;
+        } else if (type === "1") {
+          throw new Error("Package archives must not contain hard links.");
+        } else if (type === "2") {
+          throw new Error("Package archives must not contain symbolic links.");
+        } else {
+          throw new Error(`Package archives contain unsupported tar entry type: ${type}`);
+        }
+      }
+      if (ended)
+        break;
+    }
+  } finally {
+    if (current?.fd !== void 0)
+      closeSync(current.fd);
+  }
+  if (current || !ended)
+    throw new Error("Package archive is truncated.");
+};
+var findExtractedPackageRoot = (extractDir) => {
+  const entries = readdirSync(extractDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  if (entries.length !== 1) {
+    throw new Error("Package archive must contain exactly one root directory.");
+  }
+  return resolve(extractDir, entries[0].name);
+};
+var activateVersion = (paths, version, options = {}) => {
+  const versionsDir = packageVersionsDir(paths);
+  const safeVersion = validatePackageVersion(version);
+  const target = safeResolve(versionsDir, safeVersion);
+  const validation = validateServerPackageRoot(target);
+  if (!validation.ok) {
+    throw new Error(validation.errors.join(" "));
+  }
+  if (!validation.manifest) {
+    throw new Error("Package manifest is required.");
+  }
+  assertUpgradeCompatible({
+    paths,
+    nextManifest: validation.manifest,
+    allowDowngrade: options.allowDowngrade
+  });
+  const current = packageCurrentPath(paths);
+  mkdirSync(dirname(current), { recursive: true, mode: 448 });
+  const tempLink = resolve(dirname(current), `.current-${process.pid}-${Date.now()}`);
+  rmSync(tempLink, { force: true, recursive: true });
+  symlinkSync(relative(dirname(current), target), tempLink, "dir");
+  renameSync(tempLink, current);
+  const status = collectServerPackageStatus(paths);
+  return {
+    ...status,
+    ok: true,
+    state: "activated",
+    activatedVersion: safeVersion,
+    message: `koed-server package ${safeVersion} activated.`
+  };
+};
+var installServerPackage = async (paths, options) => {
+  const expectedSha256 = readExpectedSha256(options);
+  const cacheDir = packageCacheDir(paths);
+  const archivePath = await copyOrDownloadArchive(options.source, cacheDir);
+  const actualSha256 = sha256File(archivePath);
+  if (actualSha256 !== expectedSha256) {
+    throw new Error("Package archive SHA-256 mismatch.");
+  }
+  const root = packageRoot(paths);
+  const versionsDir = packageVersionsDir(paths);
+  mkdirSync(versionsDir, { recursive: true, mode: 448 });
+  const extractDir = resolve(root, `.install-${process.pid}-${Date.now()}`);
+  rmSync(extractDir, { recursive: true, force: true });
+  try {
+    await extractTarGz(archivePath, extractDir);
+    const extractedRoot = findExtractedPackageRoot(extractDir);
+    const validation = validateServerPackageRoot(extractedRoot);
+    if (!validation.ok || !validation.version) {
+      throw new Error(validation.errors.join(" "));
+    }
+    if (!validation.manifest) {
+      throw new Error("Package manifest is required.");
+    }
+    assertUpgradeCompatible({
+      paths,
+      nextManifest: validation.manifest,
+      allowDowngrade: options.allowDowngrade
+    });
+    const provenanceValidation = validatePackageProvenance({
+      options,
+      archivePath,
+      archiveSha256: actualSha256,
+      manifest: validation.manifest
+    });
+    const safeVersion = validatePackageVersion(validation.version);
+    const target = safeResolve(versionsDir, safeVersion);
+    const tempTarget = resolve(versionsDir, `.${safeVersion}-${process.pid}-${Date.now()}`);
+    rmSync(tempTarget, { recursive: true, force: true });
+    renameSync(extractedRoot, tempTarget);
+    rmSync(target, { recursive: true, force: true });
+    renameSync(tempTarget, target);
+    rmSync(extractDir, { recursive: true, force: true });
+    const status = options.activate ? activateVersion(paths, validation.version, {
+      allowDowngrade: options.allowDowngrade
+    }) : collectServerPackageStatus(paths);
+    return {
+      ...status,
+      ok: true,
+      state: options.activate ? "activated" : "installed",
+      archivePath,
+      archiveSha256: actualSha256,
+      installedPath: target,
+      provenance: provenanceValidation,
+      message: options.activate ? `koed-server package ${safeVersion} installed and activated.` : `koed-server package ${safeVersion} installed.`
+    };
+  } catch (error) {
+    rmSync(extractDir, { recursive: true, force: true });
+    throw error;
+  }
+};
+var activateServerPackage = (paths, version, options = {}) => activateVersion(paths, version, options);
+var compareVersionsDesc = (a, b) => {
+  const left = a.split(".").map((part) => Number.parseInt(part, 10));
+  const right = b.split(".").map((part) => Number.parseInt(part, 10));
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const diff = (right[index] ?? 0) - (left[index] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return b.localeCompare(a);
+};
+var cleanupServerPackages = (paths, keep = 1) => {
+  if (!Number.isInteger(keep) || keep < 0) {
+    throw new Error("--keep must be a non-negative integer.");
+  }
+  const status = collectServerPackageStatus(paths);
+  const activeVersion = status.currentVersion;
+  const inactive = status.installed.filter((entry) => entry.version !== activeVersion).map((entry) => entry.version).sort(compareVersionsDesc);
+  const retained = new Set(inactive.slice(0, keep));
+  const removedVersions = [];
+  for (const version of inactive) {
+    if (retained.has(version))
+      continue;
+    rmSync(safeResolve(packageVersionsDir(paths), validatePackageVersion(version)), {
+      recursive: true,
+      force: true
+    });
+    removedVersions.push(version);
+  }
+  const removedCacheEntries = [];
+  const cacheDir = packageCacheDir(paths);
+  if (existsSync(cacheDir)) {
+    for (const entry of readdirSync(cacheDir)) {
+      const path = resolve(cacheDir, entry);
+      const keepCache = activeVersion && entry.includes(activeVersion) ? true : [...retained].some((version) => entry.includes(version));
+      if (!keepCache) {
+        rmSync(path, { recursive: true, force: true });
+        removedCacheEntries.push(path);
+      }
+    }
+  }
+  const next = collectServerPackageStatus(paths);
+  return {
+    ...next,
+    ok: true,
+    state: "cleaned",
+    removedVersions,
+    removedCacheEntries,
+    message: `Removed ${removedVersions.length} inactive package version(s) and ${removedCacheEntries.length} cached package artifact(s).`
+  };
+};
+
+export {
+  canonicalArtifactJson,
+  canonicalArtifactBytes,
+  standalonePackageSchemaVersion,
+  standalonePackageId,
+  standalonePackageKind,
+  packageProvenanceSchemaVersion,
+  packageExtractionLimits,
+  requiredPackageRuntimeFiles,
+  sha256File,
+  validateServerPackageRoot,
+  collectServerPackageStatus,
+  extractVerifiedPackageArchive,
+  isVersionDowngrade,
+  assertPackageMigrationCompatible,
+  installServerPackage,
+  activateServerPackage,
+  cleanupServerPackages
+};