@koed-labs/server 0.0.0-stage → 0.10.3

package/vendor/chunk-PT3AUPGE.js

@@ -0,0 +1,459 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  resolvePackagedKoedRuntimeRoot
+} from "./chunk-UI5RLBKQ.js";
+import "./chunk-BTS4ZTF3.js";
+
+// packages/koed-server/dist/runtime-packaged.js
+import { createHash } from "node:crypto";
+import { chmodSync, cpSync, existsSync, closeSync, openSync, mkdirSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { spawnSync as nodeSpawnSync } from "node:child_process";
+import { dirname, relative, resolve } from "node:path";
+var MANIFEST_FILENAME = "runtime-asset-manifest.json";
+var METADATA_FILENAME = "runtime-packaged.json";
+var platformKey = (platform) => {
+  if (platform === "darwin")
+    return "macos";
+  if (platform === "win32")
+    return "windows";
+  return platform;
+};
+var trim = (value) => {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+};
+var normalizeSha256 = (value) => {
+  const normalized = value.trim().toLowerCase();
+  if (!/^[a-f0-9]{64}$/.test(normalized)) {
+    throw new Error("Packaged runtime SHA-256 must be 64 hex characters.");
+  }
+  return normalized;
+};
+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(`Packaged runtime path contains NUL byte: ${path}`);
+  }
+  const resolved = resolve(base, path);
+  if (!isInside(base, resolved)) {
+    throw new Error(`Packaged runtime path escapes base directory: ${path}`);
+  }
+  return resolved;
+};
+var assetFiles = (entry) => [
+  .../* @__PURE__ */ new Set([
+    ...entry.expectedFiles,
+    ...Object.values(entry.executablePaths)
+  ])
+].sort();
+var executableModeOk = (path) => (statSync(path).mode & 73) !== 0;
+var updateHashFromFile = (hash, path) => {
+  const descriptor = openSync(path, "r");
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  try {
+    let bytesRead = 0;
+    do {
+      bytesRead = readSync(descriptor, buffer, 0, buffer.length, null);
+      if (bytesRead > 0)
+        hash.update(buffer.subarray(0, bytesRead));
+    } while (bytesRead > 0);
+  } finally {
+    closeSync(descriptor);
+  }
+};
+var run = (command, args, spawnSync) => spawnSync(command, args, {
+  encoding: "utf8",
+  stdio: ["ignore", "pipe", "pipe"]
+});
+var commandOutput = (result) => `${result.stdout ?? ""}
+${result.stderr ?? ""}`.trim();
+var postgres17Ok = (output) => /PostgreSQL\)?\s+17(?:\.|\s|$)/i.test(output) || /\(PostgreSQL\)\s+17(?:\.|\s|$)/i.test(output);
+var collectCommandValidation = (installPath, executablePaths, spawnSync) => {
+  const commands = [];
+  const postgresVersionExecutable = executablePaths.pg_config ?? executablePaths.initdb;
+  if (postgresVersionExecutable) {
+    const command = safeResolve(installPath, postgresVersionExecutable);
+    const result = run(command, ["--version"], spawnSync);
+    const output = commandOutput(result);
+    const ok = result.status === 0 && postgres17Ok(output);
+    commands.push({
+      name: "postgres-17",
+      command,
+      ok,
+      ...ok ? {} : {
+        message: output || `Postgres version check exited ${result.status ?? 1}`
+      }
+    });
+  }
+  const llamaServerExecutable = executablePaths.llama_server;
+  if (llamaServerExecutable) {
+    const command = safeResolve(installPath, llamaServerExecutable);
+    const version = run(command, ["--version"], spawnSync);
+    const help = version.status === 0 ? version : run(command, ["--help"], spawnSync);
+    const output = commandOutput(help);
+    const ok = help.status === 0 && /llama|version:|built with/i.test(output);
+    commands.push({
+      name: "llama-server",
+      command,
+      ok,
+      ...ok ? {} : {
+        message: output || `llama-server validation exited ${help.status ?? 1}`
+      }
+    });
+  }
+  return commands;
+};
+var isShellScript = (path) => {
+  try {
+    return readFileSync(path, "utf8").startsWith("#!");
+  } catch {
+    return false;
+  }
+};
+var collectLoaderValidation = (platform, executablePaths, installPath, spawnSync) => {
+  const tool = platform === "darwin" ? "otool" : platform === "linux" ? "ldd" : void 0;
+  if (!tool)
+    return [];
+  return Object.values(executablePaths).map((relativePath) => {
+    const command = safeResolve(installPath, relativePath);
+    if (isShellScript(command)) {
+      return {
+        command,
+        ok: true,
+        skipped: true,
+        message: "loader validation skipped for shell launcher script."
+      };
+    }
+    const result = run(tool, platform === "darwin" ? ["-L", command] : [command], spawnSync);
+    const output = commandOutput(result);
+    if (result.error && result.error.message.includes("ENOENT")) {
+      return {
+        command,
+        ok: true,
+        skipped: true,
+        message: `${tool} is not available; loader validation skipped.`
+      };
+    }
+    const missing = /not found/i.test(output);
+    const ok = result.status === 0 && !missing;
+    return {
+      command,
+      ok,
+      ...ok ? {} : {
+        message: output || `${tool} validation exited ${result.status ?? 1}`
+      }
+    };
+  });
+};
+var validateInstalledAsset = (platform, installPath, executablePaths, spawnSync) => {
+  const executablePermissions = Object.entries(executablePaths).map(([name, relativePath]) => {
+    const path = safeResolve(installPath, relativePath);
+    return { name, path, ok: executableModeOk(path) };
+  });
+  const commands = collectCommandValidation(installPath, executablePaths, spawnSync);
+  const loader = collectLoaderValidation(platform, executablePaths, installPath, spawnSync);
+  const errors = [
+    ...executablePermissions.flatMap((entry) => entry.ok ? [] : [`${entry.name} is not executable (${entry.path})`]),
+    ...commands.flatMap((entry) => entry.ok ? [] : [`${entry.name} validation failed: ${entry.message}`]),
+    ...loader.flatMap((entry) => entry.ok ? [] : [`loader validation failed for ${entry.command}: ${entry.message}`])
+  ];
+  return {
+    ok: errors.length === 0,
+    executablePermissions,
+    commands,
+    loader,
+    errors
+  };
+};
+var sha256PackagedRuntimeFiles = (root, files) => {
+  const hash = createHash("sha256");
+  for (const file of [...new Set(files)].sort()) {
+    const absolute = safeResolve(root, file);
+    const stat = statSync(absolute);
+    if (stat.isDirectory())
+      continue;
+    hash.update(file.replaceAll("\\", "/"));
+    hash.update("\0");
+    updateHashFromFile(hash, absolute);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+};
+var manifestPath = (paths, root) => root ? resolve(root, MANIFEST_FILENAME) : resolve(paths.cacheDir, MANIFEST_FILENAME);
+var metadataPath = (paths) => resolve(paths.cacheDir, METADATA_FILENAME);
+var readManifest = (paths, packagedRuntimeRoot) => {
+  const candidates = (packagedRuntimeRoot ? [manifestPath(paths, packagedRuntimeRoot)] : [manifestPath(paths)]).filter((value) => Boolean(value));
+  const path = candidates[0] ?? manifestPath(paths);
+  for (const candidate of candidates) {
+    if (!existsSync(candidate))
+      continue;
+    try {
+      return {
+        manifest: validateManifest(JSON.parse(readFileSync(candidate, "utf8"))),
+        path: candidate
+      };
+    } catch (error) {
+      return {
+        path: candidate,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  return { path, error: "manifest not found" };
+};
+var validateManifest = (value) => {
+  if (!value || typeof value !== "object") {
+    throw new Error("Packaged runtime manifest must be an object.");
+  }
+  const manifest = value;
+  if (manifest.schemaVersion !== 1 || !Array.isArray(manifest.assets)) {
+    throw new Error("Packaged runtime manifest schemaVersion 1 with assets is required.");
+  }
+  for (const asset of manifest.assets) {
+    if (!asset.id || !asset.platform || !asset.architecture || !asset.version) {
+      throw new Error("Packaged runtime asset requires id, platform, architecture, and version.");
+    }
+    if (!trim(asset.url) && !trim(asset.packagedResourcePath)) {
+      throw new Error("Packaged runtime asset requires url or packagedResourcePath.");
+    }
+    normalizeSha256(asset.sha256);
+    if (!Array.isArray(asset.expectedFiles)) {
+      throw new Error("Packaged runtime asset expectedFiles must be an array.");
+    }
+    if (!asset.executablePaths || typeof asset.executablePaths !== "object") {
+      throw new Error("Packaged runtime asset executablePaths must be an object.");
+    }
+    for (const variant of asset.variants ?? []) {
+      if (!["cpu", "metal", "cuda"].includes(variant.backend)) {
+        throw new Error("Packaged runtime variant backend is invalid.");
+      }
+      safeResolve("/runtime", variant.executablePath);
+      if (!asset.expectedFiles.includes(variant.executablePath) || !variant.requirements?.platform || !variant.requirements.architecture) {
+        throw new Error("Packaged runtime variant must reference an expected executable and host requirements.");
+      }
+    }
+  }
+  return manifest;
+};
+var linuxCompatibility = (platform, spawnSync) => {
+  if (platform !== "linux")
+    return { ok: true };
+  const result = run("ldd", ["--version"], spawnSync);
+  const output = commandOutput(result);
+  if (result.error || result.status !== 0) {
+    return {
+      ok: false,
+      message: "Linux packaged native runtime requires glibc 2.35+; ldd is unavailable or failed.",
+      action: "Use Ubuntu 22.04+/Debian 12+ or a WSL Linux distro with glibc 2.35+, or use external dependency mode."
+    };
+  }
+  if (/musl/i.test(output)) {
+    return {
+      ok: false,
+      message: "Linux packaged native runtime requires glibc 2.35+ and does not support musl/Alpine hosts.",
+      action: "Use Ubuntu 22.04+/Debian 12+ or a WSL Linux distro with glibc 2.35+, or use external dependency mode."
+    };
+  }
+  const match = output.match(/(?:glibc|GNU libc|ldd)\D+(\d+)\.(\d+)/i);
+  const major = match ? Number.parseInt(match[1] ?? "", 10) : Number.NaN;
+  const minor = match ? Number.parseInt(match[2] ?? "", 10) : Number.NaN;
+  if (!Number.isFinite(major) || !Number.isFinite(minor)) {
+    return {
+      ok: false,
+      message: "Linux packaged native runtime requires glibc 2.35+; could not determine glibc version from ldd.",
+      action: "Use Ubuntu 22.04+/Debian 12+ or a WSL Linux distro with glibc 2.35+, or use external dependency mode."
+    };
+  }
+  if (major < 2 || major === 2 && minor < 35) {
+    return {
+      ok: false,
+      message: `Linux packaged native runtime requires glibc 2.35+; host reports glibc ${major}.${minor}.`,
+      action: "Use Ubuntu 22.04+/Debian 12+ or a WSL Linux distro with glibc 2.35+, or use external dependency mode."
+    };
+  }
+  return { ok: true };
+};
+var matchesHost = (asset, platform, architecture) => {
+  const hostPlatform = platformKey(platform);
+  return (asset.platform === platform || asset.platform === hostPlatform) && asset.architecture === architecture;
+};
+var installRoot = (paths) => resolve(paths.koedHome, "runtime");
+var assetInstallPath = (paths, asset) => safeResolve(installRoot(paths), asset.installPath ?? asset.id);
+var assetSourceRoot = (root, asset) => root && asset.packagedResourcePath ? safeResolve(root, asset.packagedResourcePath) : void 0;
+var assetStatus = (paths, root, asset, platform, spawnSync, knownSourceSha256) => {
+  const expectedSha = normalizeSha256(asset.sha256);
+  const sourceRoot = assetSourceRoot(root, asset);
+  const targetRoot = assetInstallPath(paths, asset);
+  const files = assetFiles(asset);
+  const missingSource = sourceRoot ? files.filter((file) => !existsSync(safeResolve(sourceRoot, file))) : ["packagedResourcePath"];
+  const missingInstalled = files.filter((file) => !existsSync(safeResolve(targetRoot, file)));
+  const sourceSha256 = sourceRoot && missingSource.length === 0 ? knownSourceSha256 ?? sha256PackagedRuntimeFiles(sourceRoot, files) : void 0;
+  const installedSha256 = missingInstalled.length === 0 ? sha256PackagedRuntimeFiles(targetRoot, files) : void 0;
+  const installed = installedSha256 === expectedSha;
+  const validation = installed ? validateInstalledAsset(platform, targetRoot, asset.executablePaths, spawnSync) : void 0;
+  const mismatch = sourceSha256 !== void 0 && sourceSha256 !== expectedSha || installedSha256 !== void 0 && installedSha256 !== expectedSha || validation?.ok === false;
+  return {
+    id: asset.id,
+    platform: asset.platform,
+    architecture: asset.architecture,
+    version: asset.version,
+    source: asset.packagedResourcePath ? { type: "packaged-resource", path: sourceRoot } : { type: "url", url: asset.url },
+    sha256: expectedSha,
+    expectedFiles: asset.expectedFiles,
+    executablePaths: asset.executablePaths,
+    installPath: targetRoot,
+    state: installed && validation?.ok !== false ? "installed" : mismatch ? "incompatible" : "missing",
+    installed: installed && validation?.ok !== false,
+    sourceAvailable: missingSource.length === 0,
+    sourceSha256,
+    installedSha256,
+    validation,
+    missing: [
+      ...missingSource,
+      ...missingInstalled,
+      ...validation?.errors ?? []
+    ]
+  };
+};
+var statusFromAssets = (paths, platform, architecture, manifestFile, root, assets) => {
+  const incompatible = assets.some((asset) => asset.state === "incompatible");
+  const ok = assets.length > 0 && assets.every((asset) => asset.installed);
+  const state = ok ? "installed" : incompatible ? "incompatible" : "missing";
+  return {
+    ok,
+    state,
+    provider: "packaged",
+    platform: platformKey(platform),
+    architecture,
+    koedHome: paths.koedHome,
+    manifestPath: manifestFile,
+    packagedRuntimeRoot: root,
+    assets,
+    message: ok ? "Packaged bundled-local runtime is installed under KOED_HOME." : state === "incompatible" ? "Packaged bundled-local runtime manifest or installed assets are incompatible." : "Packaged bundled-local runtime assets are missing from KOED_HOME/runtime.",
+    action: ok ? void 0 : "Run koed runtime install --provider packaged --dependency-mode bundled-local --json."
+  };
+};
+var collectPackagedRuntimeStatusInternal = (paths, environment = process.env, dependencies = {}, knownSourceSha256 = /* @__PURE__ */ new Map()) => {
+  const root = resolvePackagedKoedRuntimeRoot(environment);
+  const platform = dependencies.platform ?? process.platform;
+  const architecture = dependencies.architecture ?? process.arch;
+  const spawnSync = dependencies.spawnSync ?? nodeSpawnSync;
+  const linux = linuxCompatibility(platform, spawnSync);
+  if (!linux.ok) {
+    return {
+      ok: false,
+      state: "not_supported",
+      provider: "packaged",
+      platform: platformKey(platform),
+      architecture,
+      koedHome: paths.koedHome,
+      manifestPath: manifestPath(paths, root),
+      packagedRuntimeRoot: root,
+      assets: [],
+      message: linux.message,
+      action: linux.action
+    };
+  }
+  const loaded = readManifest(paths, root);
+  if (!loaded.manifest) {
+    return {
+      ok: false,
+      state: "missing",
+      provider: "packaged",
+      platform: platformKey(platform),
+      architecture,
+      koedHome: paths.koedHome,
+      manifestPath: loaded.path,
+      packagedRuntimeRoot: root,
+      assets: [],
+      message: `Packaged runtime asset manifest is missing or invalid: ${loaded.error ?? "unknown error"}.`,
+      action: "Ship runtime-asset-manifest.json with packaged runtime resources."
+    };
+  }
+  const matching = loaded.manifest.assets.filter((asset) => matchesHost(asset, platform, architecture));
+  if (matching.length === 0) {
+    return {
+      ok: false,
+      state: "incompatible",
+      provider: "packaged",
+      platform: platformKey(platform),
+      architecture,
+      koedHome: paths.koedHome,
+      manifestPath: loaded.path,
+      packagedRuntimeRoot: root,
+      assets: [],
+      message: `Packaged runtime asset manifest has no assets for ${platformKey(platform)}/${architecture}.`,
+      action: platform === "linux" ? "Ship matching linux/x64 or linux/arm64 packaged assets for a glibc 2.35+ host, or use external dependency mode." : "Install Homebrew-backed runtime assets or ship matching packaged assets."
+    };
+  }
+  return statusFromAssets(paths, platform, architecture, loaded.path, root, matching.map((asset) => assetStatus(paths, root, asset, platform, spawnSync, knownSourceSha256.get(asset.id))));
+};
+var collectPackagedRuntimeStatus = (paths, environment = process.env, dependencies = {}) => collectPackagedRuntimeStatusInternal(paths, environment, dependencies);
+var copyAsset = (paths, root, asset) => {
+  const source = assetSourceRoot(root, asset);
+  if (!source) {
+    throw new Error(`Packaged runtime asset ${asset.id} has no packagedResourcePath.`);
+  }
+  const target = assetInstallPath(paths, asset);
+  const tmpName = `.install-${asset.id.replace(/[^a-zA-Z0-9._-]/g, "_")}-${process.pid}`;
+  const tmp = resolve(dirname(target), tmpName);
+  mkdirSync(dirname(target), { recursive: true, mode: 448 });
+  rmSync(tmp, { recursive: true, force: true });
+  rmSync(target, { recursive: true, force: true });
+  cpSync(source, tmp, {
+    recursive: true,
+    preserveTimestamps: true,
+    verbatimSymlinks: true
+  });
+  for (const executable of Object.values(asset.executablePaths)) {
+    chmodSync(safeResolve(tmp, executable), 493);
+  }
+  renameSync(tmp, target);
+  return target;
+};
+var installPackagedRuntime = (paths, environment = process.env, dependencies = {}) => {
+  const root = resolvePackagedKoedRuntimeRoot(environment);
+  const platform = dependencies.platform ?? process.platform;
+  const architecture = dependencies.architecture ?? process.arch;
+  const before = collectPackagedRuntimeStatus(paths, environment, dependencies);
+  const sourceChecksumMismatch = before.assets.some((asset) => asset.sourceSha256 !== void 0 && asset.sourceSha256 !== asset.sha256);
+  if (!root || before.assets.length === 0 || sourceChecksumMismatch) {
+    return { ...before, copiedPaths: [] };
+  }
+  const copiedPaths = [];
+  for (const asset of before.assets) {
+    if (asset.installed)
+      continue;
+    if (!asset.sourceAvailable || asset.sourceSha256 !== asset.sha256) {
+      return { ...before, copiedPaths };
+    }
+    const loaded = readManifest(paths, root);
+    const manifestAsset = loaded.manifest?.assets.find((entry) => entry.id === asset.id && matchesHost(entry, platform, architecture));
+    if (!manifestAsset)
+      continue;
+    copiedPaths.push(copyAsset(paths, root, manifestAsset));
+  }
+  mkdirSync(paths.cacheDir, { recursive: true, mode: 448 });
+  cpSync(manifestPath(paths, root), manifestPath(paths));
+  writeFileSync(metadataPath(paths), `${JSON.stringify({
+    provider: "packaged",
+    installedAt: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    manifestPath: manifestPath(paths),
+    packagedRuntimeRoot: root,
+    copiedPaths
+  }, null, 2)}
+`, { mode: 384 });
+  const verifiedSourceSha256 = new Map(before.assets.flatMap((asset) => asset.sourceSha256 ? [[asset.id, asset.sourceSha256]] : []));
+  return {
+    ...collectPackagedRuntimeStatusInternal(paths, environment, dependencies, verifiedSourceSha256),
+    copiedPaths
+  };
+};
+export {
+  collectPackagedRuntimeStatus,
+  installPackagedRuntime,
+  sha256PackagedRuntimeFiles
+};

package/vendor/chunk-PY5LYLV7.js

@@ -0,0 +1,143 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  checkCoreSetupNeeded,
+  createCliServiceContext,
+  getNoAgentsWarning,
+  persistDoctorVerification,
+  printJson,
+  safeLifecycle
+} from "./chunk-YCDEMYY6.js";
+import "./chunk-HZJK5RWC.js";
+import "./chunk-QT24SAW6.js";
+import "./chunk-SKVYP7NY.js";
+import "./chunk-HFM6ROJL.js";
+import "./chunk-AFLKCQHF.js";
+import "./chunk-NM5NXCVM.js";
+import "./chunk-G4IIVVJO.js";
+import "./chunk-JKOG52PE.js";
+import "./chunk-A4NKL2PK.js";
+import "./chunk-QIIKMG3M.js";
+import "./chunk-2DA7EFZV.js";
+import "./chunk-VPC5NLZG.js";
+import "./chunk-YJWREXN6.js";
+import "./chunk-J2L726BC.js";
+import "./chunk-2S3OGPUC.js";
+import "./chunk-XNFVSVBS.js";
+import "./chunk-7NXKPDF3.js";
+import "./chunk-K2EIFEQF.js";
+import "./chunk-UI5RLBKQ.js";
+import "./chunk-W2HNI6AA.js";
+import "./chunk-473OA62O.js";
+import "./chunk-ZUGNCQZE.js";
+import "./chunk-BTS4ZTF3.js";
+
+// packages/koed-server/dist/cli-lifecycle-operations.js
+var runLifecycleCommand = async (command, options, dependencies) => {
+  const { collectStatus, collectStartupStatus, collectDoctor, inspectDeviceIdentity, rotateIdentity, invalidateEnrollmentReferences, start, startDaemon, stop, restart, resolvePaths, stdout, stderr } = createCliServiceContext(dependencies);
+  const wantsJson = options.json;
+  const subcommand = options.identityAction;
+  try {
+    if (command === "status") {
+      const paths = resolvePaths();
+      const setupNeeded = checkCoreSetupNeeded(paths);
+      if (setupNeeded) {
+        stderr.write(`${setupNeeded}
+`);
+        return 1;
+      }
+      const isStartup = Boolean(options.startup);
+      const status = isStartup ? await collectStartupStatus() : await collectStatus();
+      if (wantsJson) {
+        printJson(stdout, isStartup ? status : { ...status, lifecycle: safeLifecycle(paths) });
+      } else {
+        stdout.write(`${status.state}
+`);
+        if (!isStartup && "codex" in status) {
+          const warning = getNoAgentsWarning(status);
+          if (warning)
+            stdout.write(`Warning: ${warning}
+`);
+        }
+      }
+      return 0;
+    }
+    if (command === "doctor") {
+      const doctor = await collectDoctor();
+      persistDoctorVerification(resolvePaths(), doctor);
+      if (wantsJson) {
+        printJson(stdout, doctor);
+      } else {
+        stdout.write(`${doctor.summary}
+`);
+        const status = await collectStatus();
+        const warning = getNoAgentsWarning(status);
+        if (warning)
+          stdout.write(`Warning: ${warning}
+`);
+      }
+      return doctor.ok ? 0 : 1;
+    }
+    if (command === "identity") {
+      const paths = resolvePaths();
+      const identity = subcommand === "status" ? await inspectDeviceIdentity(paths) : subcommand === "rotate" ? await rotateIdentity(paths, {
+        invalidateRemoteReferences: () => invalidateEnrollmentReferences(paths)
+      }) : null;
+      if (!identity) {
+        throw new Error("identity command must be status or rotate.");
+      }
+      if (wantsJson) {
+        printJson(stdout, identity);
+      } else {
+        stdout.write(`${identity.health}
+`);
+      }
+      return identity.remoteOperationsAllowed ? 0 : 1;
+    }
+    if (command === "start") {
+      if (options.daemon) {
+        const result = startDaemon();
+        if (wantsJson) {
+          printJson(stdout, result);
+        } else {
+          stdout.write(`${result.message}
+`);
+        }
+        return result.ok ? 0 : 1;
+      }
+      await start();
+      return 0;
+    }
+    if (command === "stop") {
+      const result = stop();
+      if (wantsJson) {
+        printJson(stdout, result);
+      } else {
+        stdout.write(`${result.message}
+`);
+      }
+      return result.ok ? 0 : 1;
+    }
+    if (command === "restart") {
+      const result = await restart();
+      if (wantsJson) {
+        printJson(stdout, result);
+      } else {
+        stdout.write(`${result.message}
+`);
+      }
+      return result.ok ? 0 : 1;
+    }
+    throw new Error("Unknown lifecycle operation.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (wantsJson)
+      printJson(stdout, { ok: false, error: message });
+    else
+      stderr.write(`${message}
+`);
+    return 1;
+  }
+};
+export {
+  runLifecycleCommand
+};