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

package/vendor/chunk-QIIKMG3M.js

@@ -0,0 +1,103 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+
+// packages/koed-server/dist/component-manifest-catalog.js
+var record = (value, keys) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid component pin catalog record.");
+  const result = value;
+  if (Object.keys(result).length !== keys.length || keys.some((key) => !Object.hasOwn(result, key)))
+    throw new Error("Invalid component pin catalog fields.");
+  return result;
+};
+var validVersion = (value) => typeof value === "string" && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(value);
+var manifestPinKey = ({ component, target, variant }) => JSON.stringify([
+  component,
+  target.platform,
+  target.architecture,
+  target.libc?.family ?? null,
+  target.libc?.minimumVersion ?? null,
+  ...variant === void 0 ? [] : [variant]
+]);
+function validateEntry(value) {
+  const entry = record(value, [
+    "component",
+    "target",
+    "manifestSha256",
+    ...value && typeof value === "object" && Object.hasOwn(value, "variant") ? ["variant"] : []
+  ]);
+  if (entry.component !== "base" && entry.component !== "privacy" || typeof entry.manifestSha256 !== "string" || !/^[a-f0-9]{64}$/.test(entry.manifestSha256))
+    throw new Error("Invalid component pin catalog entry.");
+  if (Object.hasOwn(entry, "variant") && (entry.component !== "privacy" || !["cpu", "cuda"].includes(String(entry.variant))))
+    throw new Error("Invalid component pin variant.");
+  const rawTarget = entry.target;
+  const target = record(rawTarget, rawTarget && Object.hasOwn(rawTarget, "libc") ? ["platform", "architecture", "libc"] : ["platform", "architecture"]);
+  if (target.platform !== "linux" && target.platform !== "macos" || target.architecture !== "arm64" && target.architecture !== "x64")
+    throw new Error("Invalid component pin target.");
+  if (entry.variant !== void 0 && (target.platform !== "linux" || target.architecture !== "x64"))
+    throw new Error("Invalid component pin variant target.");
+  let libc;
+  if (Object.hasOwn(target, "libc")) {
+    const value2 = record(target.libc, ["family", "minimumVersion"]);
+    if (target.platform !== "linux" || value2.family !== "glibc" || typeof value2.minimumVersion !== "string" || !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:\.(?:0|[1-9]\d*))?$/.test(value2.minimumVersion))
+      throw new Error("Invalid component pin libc target.");
+    libc = Object.freeze({
+      family: "glibc",
+      minimumVersion: value2.minimumVersion
+    });
+  }
+  return Object.freeze({
+    component: entry.component,
+    ...entry.variant === void 0 ? {} : { variant: entry.variant },
+    manifestSha256: entry.manifestSha256,
+    target: Object.freeze({
+      platform: target.platform,
+      architecture: target.architecture,
+      ...libc ? { libc } : {}
+    })
+  });
+}
+function validateManifestCatalog(value) {
+  const input = record(value, ["schemaVersion", "productVersion", "entries"]);
+  if (input.schemaVersion !== 1 && input.schemaVersion !== 2 || !validVersion(input.productVersion) || !Array.isArray(input.entries) || input.entries.length === 0)
+    throw new Error("Invalid component pin catalog identity or entries.");
+  const entries = input.entries.map(validateEntry);
+  const identities = new Set(entries.map(manifestPinKey));
+  if (identities.size !== entries.length)
+    throw new Error("Duplicate component pin catalog identity.");
+  const variants = entries.filter((entry) => entry.variant !== void 0);
+  if (input.schemaVersion === 1 && variants.length)
+    throw new Error("Legacy component catalog cannot authenticate variants.");
+  if (input.schemaVersion === 2) {
+    if (variants.length === 0)
+      throw new Error("Privacy variant catalog is incomplete.");
+    for (const entry of entries.filter((entry2) => entry2.component === "privacy" && entry2.target.platform === "linux")) {
+      if (entry.variant === void 0 || !["cpu", "cuda"].every((variant) => entries.some((other) => other.component === "privacy" && other.variant === variant && manifestPinKey({ ...other, variant: void 0 }) === manifestPinKey({ ...entry, variant: void 0 }))))
+        throw new Error("Privacy variant catalog is incomplete or ambiguous.");
+    }
+  }
+  return Object.freeze({
+    schemaVersion: input.schemaVersion,
+    productVersion: input.productVersion,
+    entries: Object.freeze(entries)
+  });
+}
+function lookupManifestPin(catalog, identity) {
+  if (!catalog)
+    throw new Error("Component manifest pin catalog is unavailable; use a trusted versioned control plane.");
+  if (catalog.productVersion !== identity.productVersion)
+    throw new Error("Component pin catalog version mismatch.");
+  const key = manifestPinKey(identity);
+  const entry = catalog.entries.find((entry2) => manifestPinKey(entry2) === key);
+  if (!entry)
+    throw new Error("Required component manifest pin is missing from this control plane.");
+  return entry.manifestSha256;
+}
+
+// packages/koed-server/dist/component-manifest-catalog-data.js
+var productionComponentManifestCatalog = validateManifestCatalog({ "schemaVersion": 2, "productVersion": "0.10.3", "entries": [{ "component": "base", "manifestSha256": "cfa106faf481eb5a62e5dbe9c90a7447037adbee1996ddca7cd614b142364000", "target": { "platform": "linux", "architecture": "x64", "libc": { "family": "glibc", "minimumVersion": "2.35" } } }, { "component": "base", "manifestSha256": "c4c9052f81cbcd51285c0e35afedffa7e4db976f9e6a2fb45c9658004e84214c", "target": { "platform": "macos", "architecture": "arm64" } }, { "component": "privacy", "variant": "cpu", "manifestSha256": "ae4188f582c5bc6018f76f8e4c830b3cf2ea8baccaa2fb9bc850efc4fd0bd328", "target": { "platform": "linux", "architecture": "x64", "libc": { "family": "glibc", "minimumVersion": "2.35" } } }, { "component": "privacy", "variant": "cuda", "manifestSha256": "6d93a1e8d30643b5afa365a2cd48e3b6554e930b2ca0e71caa9b2fcc1a6f1819", "target": { "platform": "linux", "architecture": "x64", "libc": { "family": "glibc", "minimumVersion": "2.35" } } }, { "component": "privacy", "manifestSha256": "cf6f8fd24cfc42519fcbcd8ff072fc89aa1166aa37acd54add46fdce1f460857", "target": { "platform": "macos", "architecture": "arm64" } }] });
+
+export {
+  validateManifestCatalog,
+  lookupManifestPin,
+  productionComponentManifestCatalog
+};

package/vendor/chunk-QT24SAW6.js

@@ -0,0 +1,110 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+
+// packages/koed-server/dist/credentials.js
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname, resolve } from "node:path";
+var usableToken = (value) => {
+  const trimmed = value?.trim();
+  return trimmed && !trimmed.startsWith("replace_with_") ? trimmed : null;
+};
+var tokenFrom = (values) => {
+  for (const value of values) {
+    const token = usableToken(value);
+    if (token) {
+      return token;
+    }
+  }
+  return null;
+};
+var resolveLocalApiToken = (environment, repoEnv) => {
+  const envToken = tokenFrom([
+    environment.MEMORY_API_TOKEN,
+    environment.CODEX_MEMORY_API_TOKEN
+  ]);
+  if (envToken) {
+    return { token: envToken, source: "environment" };
+  }
+  const repoToken = tokenFrom([
+    repoEnv.MEMORY_API_TOKEN,
+    repoEnv.CODEX_MEMORY_API_TOKEN
+  ]);
+  if (repoToken) {
+    return { token: repoToken, source: "repo-env" };
+  }
+  return null;
+};
+var writeLocalAppCredential = (paths, credential) => {
+  const target = resolve(paths.localAppCredentialPath);
+  mkdirSync(dirname(target), { recursive: true, mode: 448 });
+  try {
+    if (lstatSync(target).isSymbolicLink()) {
+      throw new Error("Local API Token credential must not be a symbolic link.");
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify(credential, null, 2)}
+`, {
+      mode: 384,
+      flag: "wx"
+    });
+    chmodSync(temporary, 384);
+    renameSync(temporary, target);
+    chmodSync(target, 384);
+  } catch (error) {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+    throw error;
+  }
+};
+var loadLocalAppCredential = (paths) => {
+  if (!existsSync(paths.localAppCredentialPath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(paths.localAppCredentialPath, "utf8"));
+    if (typeof parsed?.apiToken !== "string" || !parsed.apiToken.trim()) {
+      return null;
+    }
+    return {
+      apiToken: parsed.apiToken.trim(),
+      provisionedAt: parsed.provisionedAt ?? "unknown",
+      source: parsed.source ?? "repo-env"
+    };
+  } catch {
+    return null;
+  }
+};
+var resolveActiveIntegrationApiToken = (paths, environment, repoEnv) => {
+  const localAppCredential = loadLocalAppCredential(paths);
+  if (environment.KOED_AUTO_PORTS === "1" && localAppCredential?.apiToken) {
+    return {
+      token: localAppCredential.apiToken,
+      source: "local-app-credential"
+    };
+  }
+  const localToken = resolveLocalApiToken(environment, repoEnv);
+  if (localToken) {
+    return localToken;
+  }
+  if (localAppCredential?.apiToken) {
+    return {
+      token: localAppCredential.apiToken,
+      source: "local-app-credential"
+    };
+  }
+  return null;
+};
+
+export {
+  resolveLocalApiToken,
+  writeLocalAppCredential,
+  loadLocalAppCredential,
+  resolveActiveIntegrationApiToken
+};

package/vendor/chunk-RVYJKKWA.js

@@ -0,0 +1,22 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  cancelUpstreamEnrollment,
+  disconnectUpstreamBackendEnrollment,
+  getUpstreamEnrollmentStatus,
+  invalidateUpstreamEnrollmentReferences,
+  readUpstreamEnrollmentBinding,
+  startUpstreamEnrollment
+} from "./chunk-SKVYP7NY.js";
+import "./chunk-YJWREXN6.js";
+import "./chunk-XNFVSVBS.js";
+import "./chunk-7NXKPDF3.js";
+import "./chunk-473OA62O.js";
+import "./chunk-BTS4ZTF3.js";
+export {
+  cancelUpstreamEnrollment,
+  disconnectUpstreamBackendEnrollment,
+  getUpstreamEnrollmentStatus,
+  invalidateUpstreamEnrollmentReferences,
+  readUpstreamEnrollmentBinding,
+  startUpstreamEnrollment
+};