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

package/vendor/chunk-YJ6XUZT6.js

@@ -0,0 +1,292 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  calculateRuntimeRequirements,
+  resolveEffectiveRuntimeConfig
+} from "./chunk-AFLKCQHF.js";
+import {
+  activateGeneration,
+  cleanupGenerations,
+  discoverActualRuntimeIdentity,
+  readCurrentDesktopGeneration,
+  readCurrentDesktopGenerationOrderingEvidence,
+  readCurrentGeneration,
+  readCurrentGenerationOrderingEvidence,
+  readGenerationComponentPresence,
+  readStagedGeneration,
+  readStoredComponents,
+  resolveComponentManifestPinTarget,
+  stageComponent,
+  stageGeneration
+} from "./chunk-NM5NXCVM.js";
+import "./chunk-G4IIVVJO.js";
+import {
+  resolveKoedAppRuntimeExecution,
+  resolveKoedControlPlaneVersion,
+  resolveKoedRuntimeOwner
+} from "./chunk-A4NKL2PK.js";
+import {
+  productionComponentManifestCatalog,
+  validateManifestCatalog
+} from "./chunk-QIIKMG3M.js";
+import "./chunk-2DA7EFZV.js";
+import {
+  resolveKoedServerPaths
+} from "./chunk-K2EIFEQF.js";
+import "./chunk-UI5RLBKQ.js";
+import "./chunk-W2HNI6AA.js";
+import "./chunk-473OA62O.js";
+import "./chunk-BTS4ZTF3.js";
+
+// packages/koed-server/dist/cli-component-operations.js
+import { existsSync as existsSync2 } from "node:fs";
+import { resolve } from "node:path";
+
+// packages/koed-server/dist/component-command-target.js
+function resolveComponentCommandTarget(runtime, catalog) {
+  const host = {
+    platform: runtime.platform,
+    architecture: runtime.architecture
+  };
+  if (catalog === null)
+    return host;
+  const targets = /* @__PURE__ */ new Map();
+  for (const { target } of validateManifestCatalog(catalog).entries) {
+    if (target.platform === host.platform && target.architecture === host.architecture)
+      targets.set(JSON.stringify(target), target);
+  }
+  if (targets.size === 0)
+    throw new Error("Component pin catalog has no target for actual runtime.");
+  if (targets.size !== 1)
+    throw new Error("Component pin catalog has ambiguous targets for actual runtime.");
+  return [...targets.values()][0];
+}
+
+// packages/koed-server/dist/component-commands.js
+import { existsSync, readdirSync } from "node:fs";
+var requirementsFor = (context) => calculateRuntimeRequirements(resolveEffectiveRuntimeConfig(context.paths, context.environment ?? process.env, context.execution ?? resolveKoedAppRuntimeExecution()));
+var requiredManifestPinsAvailable = (context, required) => {
+  const pinRequired = context.desktopRuntimeCapability ? required.filter((component) => component !== "base") : required;
+  if (pinRequired.length === 0)
+    return true;
+  if (!productionComponentManifestCatalog)
+    return false;
+  const catalog = validateManifestCatalog(productionComponentManifestCatalog);
+  return pinRequired.every((component) => {
+    try {
+      resolveComponentManifestPinTarget(catalog, {
+        component,
+        ...catalog.schemaVersion === 2 && component === "privacy" && context.target.platform === "linux" ? { variant: "cpu" } : {},
+        productVersion: context.controlPlaneVersion,
+        target: context.target,
+        runtime: context.runtime
+      });
+      return true;
+    } catch (error) {
+      if (error instanceof Error && (error.message.startsWith("Component pin catalog version mismatch") || error.message.startsWith("Required component manifest pin is missing") || error.message.startsWith("Component manifest pin target is ambiguous")))
+        return false;
+      throw error;
+    }
+  });
+};
+var storedGenerations = async (context) => {
+  if (!existsSync(context.paths.generationsDir))
+    return [];
+  const ids = readdirSync(context.paths.generationsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^[a-f0-9]{64}$/.test(entry.name)).map((entry) => entry.name);
+  const generations = [];
+  for (const id of ids) {
+    try {
+      const generation = await readStagedGeneration(context.paths, id);
+      if (generation.owner.kind === context.owner.kind && generation.owner.installationId === context.owner.installationId)
+        generations.push(generation);
+    } catch {
+    }
+  }
+  return generations;
+};
+var readOwnedCurrentGeneration = async (context) => {
+  try {
+    const evidence = context.desktopRuntimeCapability ? readCurrentDesktopGenerationOrderingEvidence(context.paths, context.desktopRuntimeCapability) : readCurrentGenerationOrderingEvidence(context.paths);
+    const currentBundle = evidence.kind !== "desktop-generation-ordering-evidence" || evidence.bundleDigest === context.desktopRuntimeCapability?.bundleDigest;
+    const generation = evidence.productVersion !== context.controlPlaneVersion || !currentBundle ? evidence : context.desktopRuntimeCapability ? await readCurrentDesktopGeneration(context.paths, context.desktopRuntimeCapability) : await readCurrentGeneration(context.paths);
+    return generation.owner.kind === context.owner.kind && generation.owner.installationId === context.owner.installationId ? generation : null;
+  } catch (error) {
+    if (error instanceof Error && error.message === "no active runtime generation")
+      return null;
+    throw error;
+  }
+};
+async function runComponentStatus(context) {
+  const required = requirementsFor(context).components;
+  const active = await readOwnedCurrentGeneration(context);
+  const priorPresence = active && "kind" in active ? active.kind === "desktop-generation-ordering-evidence" ? active.components : readGenerationComponentPresence(context.paths, active.id) : [];
+  const generations = await storedGenerations(context);
+  const installed = await readStoredComponents(context.paths, context.runtime);
+  const staged = generations.filter((generation) => generation.id !== active?.id);
+  const states = {
+    base: "not-required",
+    privacy: "not-required"
+  };
+  for (const component of ["base", "privacy"]) {
+    if (!required.includes(component))
+      continue;
+    if (active && !("kind" in active) && active[component]) {
+      states[component] = active.productVersion === context.controlPlaneVersion ? "active" : "incompatible";
+      continue;
+    }
+    const stored = staged.filter((generation) => generation[component] !== void 0);
+    states[component] = stored.some((generation) => generation.productVersion === context.controlPlaneVersion) ? "staged" : stored.length > 0 ? "incompatible" : installed.some((entry) => entry.manifest.component === component && entry.manifest.productVersion === context.controlPlaneVersion) ? "installed" : priorPresence.includes(component) || installed.some((entry) => entry.manifest.component === component) ? "incompatible" : "missing";
+  }
+  return {
+    components: states,
+    activeGeneration: active?.id ?? null,
+    activeVersion: active?.productVersion ?? null,
+    required,
+    requiredManifestPinsAvailable: requiredManifestPinsAvailable(context, required)
+  };
+}
+async function runComponentInstall(context, options) {
+  if (!options.source)
+    throw new Error("A manifest-pinned component source is required; provide offline archive and manifest paths or exact-version URLs.");
+  const version = options.version ?? context.controlPlaneVersion;
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error("component version must be an exact semantic version.");
+  const required = requirementsFor(context).components;
+  if (!required.includes(options.component))
+    throw new Error(`${options.component} component is not required by current runtime configuration.`);
+  if (options.component === "privacy" && context.target.platform === "linux" && productionComponentManifestCatalog?.schemaVersion === 2 && options.variant === void 0)
+    throw new Error("Linux Privacy installation requires --variant cpu or cuda with its matching authenticated source.");
+  const component = await stageComponent(context.paths, options.source, {
+    expectedComponent: options.component,
+    expectedVariant: options.variant,
+    expectedVersion: version,
+    target: context.target,
+    runtime: context.runtime,
+    signal: context.signal,
+    progress: context.progress
+  });
+  const selection = await readOwnedCurrentGeneration(context);
+  const active = selection && !("kind" in selection) ? selection : null;
+  const staged = await storedGenerations(context);
+  const installed = await readStoredComponents(context.paths, context.runtime);
+  const priorGeneration = staged.find((generation2) => generation2.productVersion === version);
+  const otherComponent = options.component === "base" ? active?.privacy?.manifest.productVersion === version ? active.privacy : priorGeneration?.privacy ?? installed.find((entry) => entry.manifest.component === "privacy" && entry.manifest.productVersion === version) : active?.base.kind === "manifest-pinned-component" && active.base.manifest.productVersion === version ? active.base : (priorGeneration?.base.kind === "manifest-pinned-component" ? priorGeneration.base : void 0) ?? installed.find((entry) => entry.manifest.component === "base" && entry.manifest.productVersion === version);
+  if (required.length > 1 && !otherComponent) {
+    if (options.component === "base")
+      await stageGeneration(context.paths, {
+        base: component,
+        owner: context.owner
+      });
+    return { state: "staged" };
+  }
+  const generation = await stageGeneration(context.paths, {
+    base: options.component === "base" ? component : otherComponent,
+    ...required.includes("privacy") ? {
+      privacy: options.component === "privacy" ? component : otherComponent
+    } : {},
+    owner: context.owner
+  });
+  if (version !== context.controlPlaneVersion || options.stageOnly || context.isRunning)
+    return { state: "staged" };
+  const activated = await activateGeneration(context.paths, generation.id, context.owner);
+  return { state: "active", generationId: activated.id };
+}
+async function runComponentActivate(context, version) {
+  if (version !== context.controlPlaneVersion)
+    throw new Error("Activation requires a matching control plane version; select the matching control-plane version before rollback activation.");
+  if (context.isRunning)
+    throw new Error("Stop Koed services before activating a component generation.");
+  const required = requirementsFor(context).components;
+  const candidates = (await storedGenerations(context)).filter((generation) => generation.productVersion === version).sort((left, right) => right.id.localeCompare(left.id));
+  const candidate = candidates.find((generation) => required.every((component) => generation[component] !== void 0));
+  if (!candidate)
+    throw new Error(`No complete staged generation for ${version}; install all required components first.`);
+  return activateGeneration(context.paths, candidate.id, context.owner, context.desktopRuntimeCapability);
+}
+async function runComponentCleanup(context) {
+  return cleanupGenerations(context.paths, 2, context.owner);
+}
+
+// packages/koed-server/dist/cli-component-operations.js
+var runComponentCommand = async (operation, options, dependencies) => {
+  const stdout = dependencies.stdout ?? process.stdout;
+  const stderr = dependencies.stderr ?? process.stderr;
+  try {
+    if (dependencies.desktopRuntimeCapability)
+      throw new Error("Koed Desktop manages components for its bundled runtime. Use Koed Desktop to install or update components.");
+    const paths = (dependencies.resolvePaths ?? resolveKoedServerPaths)();
+    const runtime = discoverActualRuntimeIdentity();
+    const target = resolveComponentCommandTarget(runtime, productionComponentManifestCatalog);
+    const context = {
+      paths,
+      controlPlaneVersion: resolveKoedControlPlaneVersion(),
+      target,
+      runtime,
+      owner: resolveKoedRuntimeOwner(),
+      isRunning: existsSync2(resolve(paths.runDir, "koed-server.lock"))
+    };
+    let result;
+    switch (operation) {
+      case "status":
+        result = await runComponentStatus(context);
+        break;
+      case "cleanup":
+        result = await runComponentCleanup(context);
+        break;
+      case "activate": {
+        if (!options.version)
+          throw new Error("--version is required.");
+        result = await runComponentActivate(context, options.version);
+        break;
+      }
+      case "install": {
+        const component = options.component;
+        if (!component)
+          throw new Error("--component is required.");
+        if (component !== "base" && component !== "privacy")
+          throw new Error("--component must be base or privacy.");
+        const variant = options.variant;
+        if (variant !== void 0 && (component !== "privacy" || target.platform !== "linux" || target.architecture !== "x64" || variant !== "cpu" && variant !== "cuda"))
+          throw new Error("--variant must be cpu or cuda for Linux x64 Privacy.");
+        const hasOffline = options.archive !== void 0 || options.manifest !== void 0;
+        const hasRemote = options.archiveUrl !== void 0 || options.manifestUrl !== void 0;
+        if (hasOffline === hasRemote)
+          throw new Error("Provide exactly one complete offline archive/manifest set or exact-version URL set.");
+        if (hasOffline && (options.archive === void 0 || options.manifest === void 0))
+          throw new Error("Offline install requires --archive and --manifest paths.");
+        if (hasRemote && (options.archiveUrl === void 0 || options.manifestUrl === void 0))
+          throw new Error("Network install requires --archive-url and --manifest-url.");
+        const source = hasOffline ? {
+          kind: "offline",
+          archivePath: options.archive,
+          manifestPath: options.manifest
+        } : {
+          kind: "remote",
+          archiveUrl: options.archiveUrl,
+          manifestUrl: options.manifestUrl
+        };
+        result = await runComponentInstall(context, {
+          component,
+          ...variant === "cpu" || variant === "cuda" ? { variant } : {},
+          version: options.version,
+          source,
+          stageOnly: Boolean(options.stageOnly)
+        });
+      }
+    }
+    stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (options.json)
+      stdout.write(`${JSON.stringify({ ok: false, error: message }, null, 2)}
+`);
+    else
+      stderr.write(`${message}
+`);
+    return 1;
+  }
+};
+export {
+  runComponentCommand
+};