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

package/vendor/chunk-HFM6ROJL.js

@@ -0,0 +1,188 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  isProcessRunning
+} from "./chunk-G4IIVVJO.js";
+import {
+  require_proper_lockfile
+} from "./chunk-7NXKPDF3.js";
+import {
+  __toESM
+} from "./chunk-BTS4ZTF3.js";
+
+// packages/koed-server/dist/ports.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { createServer } from "node:net";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { mkdirSync } from "node:fs";
+var DEFAULT_PORTS = {
+  api: "43300",
+  postgres: "45432",
+  embedding: "43800",
+  privacy: "48092",
+  llamaEmbedding: "18080"
+};
+var localPortLeaseSchemaVersion = 1;
+var ENV_KEYS = {
+  api: ["API_HOST_PORT"],
+  postgres: ["POSTGRES_HOST_PORT"],
+  embedding: ["EMBEDDING_SERVICE_HOST_PORT"],
+  privacy: ["PRIVACY_SERVICE_PORT"],
+  llamaEmbedding: [
+    "EMBEDDING_LLAMA_EMBEDDING_SERVER_PORT",
+    "LLAMA_EMBEDDING_SERVER_PORT"
+  ]
+};
+var trim = (value) => {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+};
+var validPort = (value) => {
+  const trimmed = trim(value);
+  if (!trimmed)
+    return void 0;
+  const parsed = Number.parseInt(trimmed, 10);
+  return Number.isInteger(parsed) && parsed > 0 && parsed < 65536 ? String(parsed) : void 0;
+};
+var canListen = (port) => new Promise((resolve2) => {
+  const server = createServer();
+  server.once("error", () => resolve2(false));
+  server.listen(Number(port), "127.0.0.1", () => {
+    server.close(() => resolve2(true));
+  });
+});
+var nextFreePort = async (preferred, unavailablePorts, canListenOnPort) => {
+  const start = Number(preferred);
+  for (let port = start; port < Math.min(start + 1e3, 65536); port += 1) {
+    const candidate = String(port);
+    if (!unavailablePorts.has(candidate) && await canListenOnPort(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Could not find a free local port near ${preferred}.`);
+};
+var defaultLocalPortLeaseRegistryPath = () => resolve(homedir(), ".koed", "run", "local-port-leases.json");
+var resolveLocalPortLeaseRegistryPath = (environment, dependencyPath) => {
+  const configured = environment.KOED_LOCAL_PORT_LEASES_PATH?.trim();
+  return resolve(dependencyPath ?? configured ?? defaultLocalPortLeaseRegistryPath());
+};
+var emptyLocalPortLeaseRegistry = () => ({
+  schemaVersion: localPortLeaseSchemaVersion,
+  leases: {}
+});
+var isLocalPortLease = (value) => typeof value === "object" && value !== null && typeof value.koedHome === "string" && typeof value.pid === "number" && typeof value.ports === "object" && value.ports !== null;
+var ensureLocalPortLeaseRegistry = (path) => {
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  if (!existsSync(path)) {
+    writeFileSync(path, `${JSON.stringify(emptyLocalPortLeaseRegistry())}
+`, {
+      mode: 384
+    });
+  }
+};
+var readLocalPortLeaseRegistry = (path) => {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.schemaVersion !== localPortLeaseSchemaVersion || !parsed.leases || typeof parsed.leases !== "object") {
+      return emptyLocalPortLeaseRegistry();
+    }
+    return {
+      schemaVersion: localPortLeaseSchemaVersion,
+      leases: Object.fromEntries(Object.entries(parsed.leases).filter(([, lease]) => isLocalPortLease(lease)))
+    };
+  } catch {
+    return emptyLocalPortLeaseRegistry();
+  }
+};
+var writeLocalPortLeaseRegistry = (path, registry) => {
+  writeFileSync(path, `${JSON.stringify(registry, null, 2)}
+`, {
+    mode: 384
+  });
+};
+var readPersistedLocalPorts = (paths) => {
+  if (!existsSync(paths.localPortsPath))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(paths.localPortsPath, "utf8"));
+    return {
+      ...validPort(parsed.api) ? { api: validPort(parsed.api) } : {},
+      ...validPort(parsed.postgres) ? { postgres: validPort(parsed.postgres) } : {},
+      ...validPort(parsed.embedding) ? { embedding: validPort(parsed.embedding) } : {},
+      ...validPort(parsed.privacy) ? { privacy: validPort(parsed.privacy) } : {},
+      ...validPort(parsed.llamaEmbedding) ? { llamaEmbedding: validPort(parsed.llamaEmbedding) } : {}
+    };
+  } catch {
+    return {};
+  }
+};
+var writePersistedLocalPorts = (paths, ports) => {
+  mkdirSync(dirname(paths.localPortsPath), { recursive: true, mode: 448 });
+  writeFileSync(paths.localPortsPath, `${JSON.stringify(ports, null, 2)}
+`, {
+    mode: 384
+  });
+};
+var applyPersistedLocalPorts = (paths, environment, options = {}) => {
+  if (!options.force && environment.KOED_AUTO_PORTS !== "1")
+    return environment;
+  const persisted = readPersistedLocalPorts(paths);
+  return {
+    ...environment,
+    ...persisted.api && !trim(environment.API_HOST_PORT) ? { API_HOST_PORT: persisted.api } : {},
+    ...persisted.postgres && !trim(environment.POSTGRES_HOST_PORT) ? { POSTGRES_HOST_PORT: persisted.postgres } : {},
+    ...persisted.embedding && !trim(environment.EMBEDDING_SERVICE_HOST_PORT) ? { EMBEDDING_SERVICE_HOST_PORT: persisted.embedding } : {},
+    ...persisted.privacy && !trim(environment.PRIVACY_SERVICE_PORT) ? { PRIVACY_SERVICE_PORT: persisted.privacy } : {},
+    ...persisted.llamaEmbedding && !ENV_KEYS.llamaEmbedding.some((key) => trim(environment[key])) ? { EMBEDDING_LLAMA_EMBEDDING_SERVER_PORT: persisted.llamaEmbedding } : {}
+  };
+};
+var allocateAndPersistLocalPorts = async (paths, environment, dependencies = {}) => {
+  if (environment.KOED_AUTO_PORTS !== "1")
+    return environment;
+  const registryPath = resolveLocalPortLeaseRegistryPath(environment, dependencies.leaseRegistryPath);
+  ensureLocalPortLeaseRegistry(registryPath);
+  const release = await import_proper_lockfile.default.lock(registryPath, {
+    realpath: false,
+    retries: { retries: 20, factor: 1.2, minTimeout: 25, maxTimeout: 250 }
+  });
+  try {
+    const processIsRunning = dependencies.isProcessRunning ?? isProcessRunning;
+    const canListenOnPort = dependencies.canListen ?? canListen;
+    const registry = readLocalPortLeaseRegistry(registryPath);
+    const activeLeases = Object.values(registry.leases).filter((lease) => lease.koedHome !== paths.koedHome && processIsRunning(lease.pid));
+    registry.leases = Object.fromEntries(Object.entries(registry.leases).filter(([, lease]) => lease.koedHome === paths.koedHome || processIsRunning(lease.pid)));
+    const unavailablePorts = new Set(activeLeases.flatMap((lease) => Object.keys(DEFAULT_PORTS).map((key) => lease.ports[key])));
+    const persisted = readPersistedLocalPorts(paths);
+    const allocated = { ...DEFAULT_PORTS, ...persisted };
+    for (const key of Object.keys(ENV_KEYS)) {
+      const fromEnv = ENV_KEYS[key].map((envKey) => validPort(environment[envKey])).find((port) => port !== void 0);
+      const preferred = fromEnv ?? validPort(allocated[key]) ?? DEFAULT_PORTS[key];
+      allocated[key] = !unavailablePorts.has(preferred) && await canListenOnPort(preferred) ? preferred : await nextFreePort(preferred, unavailablePorts, canListenOnPort);
+      unavailablePorts.add(allocated[key]);
+    }
+    writePersistedLocalPorts(paths, allocated);
+    registry.leases[paths.koedHome] = {
+      koedHome: paths.koedHome,
+      pid: dependencies.processId ?? process.pid,
+      ports: allocated,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writeLocalPortLeaseRegistry(registryPath, registry);
+    return {
+      ...environment,
+      API_HOST_PORT: allocated.api,
+      POSTGRES_HOST_PORT: allocated.postgres,
+      EMBEDDING_SERVICE_HOST_PORT: allocated.embedding,
+      PRIVACY_SERVICE_PORT: allocated.privacy,
+      EMBEDDING_LLAMA_EMBEDDING_SERVER_PORT: allocated.llamaEmbedding
+    };
+  } finally {
+    await release();
+  }
+};
+
+export {
+  applyPersistedLocalPorts,
+  allocateAndPersistLocalPorts
+};

package/vendor/chunk-HK2H3MVE.js

@@ -0,0 +1,328 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import "./chunk-BTS4ZTF3.js";
+
+// packages/koed-server/dist/runtime-homebrew.js
+import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { spawnSync as nodeSpawnSync } from "node:child_process";
+var REQUIRED_PACKAGES = [
+  "postgresql@17",
+  "pgvector",
+  "llama.cpp"
+];
+var trim = (value) => {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+};
+var homebrewCommandCandidates = (platform, environment, exists) => {
+  const configuredPrefix = trim(environment.HOMEBREW_PREFIX);
+  const configuredCommand = configuredPrefix && isAbsolute(configuredPrefix) ? resolve(configuredPrefix, "bin", "brew") : void 0;
+  const platformCommands = platform === "darwin" ? ["/opt/homebrew/bin/brew", "/usr/local/bin/brew"] : platform === "linux" ? ["/home/linuxbrew/.linuxbrew/bin/brew"] : [];
+  return [
+    .../* @__PURE__ */ new Set([
+      ...[configuredCommand, ...platformCommands].filter((command) => Boolean(command && exists(command))),
+      "brew"
+    ])
+  ];
+};
+var run = (command, args, spawnSync) => spawnSync(command, args, {
+  encoding: "utf8",
+  stdio: ["ignore", "pipe", "pipe"]
+});
+var brewPrefix = (formula, command, spawnSync) => {
+  const args = formula ? ["--prefix", formula] : ["--prefix"];
+  const result = run(command, args, spawnSync);
+  if (result.error) {
+    return { ok: false, error: result.error.message };
+  }
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      error: result.stderr.trim() || `brew ${args.join(" ")} failed`
+    };
+  }
+  return { ok: true, prefix: result.stdout.trim() };
+};
+var resolveHomebrewCommand = (platform, environment, exists, spawnSync) => {
+  let error = "Homebrew is not available";
+  for (const command of homebrewCommandCandidates(platform, environment, exists)) {
+    const result = brewPrefix(null, command, spawnSync);
+    if (result.ok && result.prefix) {
+      return { ok: true, command, prefix: result.prefix };
+    }
+    error = result.error ?? error;
+  }
+  return { ok: false, error };
+};
+var packageStatus = (name, command, spawnSync) => {
+  const listed = run(command, ["list", "--versions", name], spawnSync);
+  if (listed.error || listed.status !== 0 || !listed.stdout.trim()) {
+    return {
+      name,
+      installed: false,
+      missing: [
+        listed.stderr.trim() || listed.error?.message || "not installed"
+      ]
+    };
+  }
+  const result = brewPrefix(name, command, spawnSync);
+  return result.ok && result.prefix ? { name, installed: true, prefix: result.prefix } : { name, installed: false, missing: [result.error ?? "not installed"] };
+};
+var binary = (paths, key, path, exists) => {
+  paths[key] = path;
+  return { path, exists: exists(path) };
+};
+var candidatePgvectorControlPaths = (postgresPrefix, pgvectorPrefix, pgSharedir2) => [
+  pgSharedir2 ? resolve(pgSharedir2, "extension", "vector.control") : void 0,
+  postgresPrefix ? resolve(postgresPrefix, "share", "postgresql@17", "extension", "vector.control") : void 0,
+  postgresPrefix ? resolve(postgresPrefix, "share", "postgresql", "extension", "vector.control") : void 0,
+  pgvectorPrefix ? resolve(pgvectorPrefix, "share", "postgresql@17", "extension", "vector.control") : void 0,
+  pgvectorPrefix ? resolve(pgvectorPrefix, "share", "postgresql", "extension", "vector.control") : void 0
+].filter((value) => Boolean(value));
+var candidatePgvectorSqlPaths = (controlPath) => controlPath ? [resolve(dirname(controlPath), "vector--*.sql")] : [];
+var pgSharedir = (pgConfigBin, exists, spawnSync) => {
+  if (!exists(pgConfigBin))
+    return void 0;
+  const result = run(pgConfigBin, ["--sharedir"], spawnSync);
+  if (result.status !== 0 || result.error)
+    return void 0;
+  return trim(result.stdout);
+};
+var runtimePaths = (paths) => ({
+  postgresBinDir: resolve(paths.koedHome, "runtime", "postgres", "bin"),
+  llamaServerBin: resolve(paths.koedHome, "runtime", "llama.cpp", "llama-server"),
+  metadataPath: resolve(paths.cacheDir, "runtime-homebrew.json")
+});
+var emptyBinaries = () => ({
+  initdb: { path: "", exists: false },
+  pg_ctl: { path: "", exists: false },
+  psql: { path: "", exists: false },
+  pg_dump: { path: "", exists: false },
+  pg_restore: { path: "", exists: false },
+  pg_config: { path: "", exists: false },
+  llama_server: { path: "", exists: false }
+});
+var binaryEntries = (binaries) => Object.entries(binaries);
+var isSupportedHomebrewPlatform = (platform) => platform === "darwin" || platform === "linux";
+var statusFrom = ({ paths, platform, environment, exists, spawnSync }) => {
+  const koedRuntime = runtimePaths(paths);
+  if (!isSupportedHomebrewPlatform(platform)) {
+    return {
+      ok: false,
+      state: "not_supported",
+      provider: "homebrew",
+      platform,
+      koedHome: paths.koedHome,
+      homebrew: { installed: false },
+      packages: [],
+      binaries: emptyBinaries(),
+      pgvector: { compatible: false, sqlPaths: [], missing: ["macOS/Linux"] },
+      koedRuntime: { ...koedRuntime, linked: false },
+      message: "Homebrew-backed bundled-local runtime provisioning is supported on macOS, Linux, and WSL only.",
+      action: "Use external dependency mode or a supported Homebrew/Linuxbrew environment on macOS, Linux, or WSL."
+    };
+  }
+  const homebrew = resolveHomebrewCommand(platform, environment, exists, spawnSync);
+  if (!homebrew.ok) {
+    return {
+      ok: false,
+      state: "missing",
+      provider: "homebrew",
+      platform,
+      koedHome: paths.koedHome,
+      homebrew: { installed: false, error: homebrew.error },
+      packages: REQUIRED_PACKAGES.map((name) => ({
+        name,
+        installed: false,
+        missing: ["Homebrew is not available"]
+      })),
+      binaries: emptyBinaries(),
+      pgvector: { compatible: false, sqlPaths: [], missing: ["Homebrew"] },
+      koedRuntime: { ...koedRuntime, linked: false },
+      message: "Homebrew is required for Homebrew-backed bundled-local runtime provisioning.",
+      action: "Install Homebrew or Linuxbrew on macOS, Linux, or WSL, then run koed runtime install --provider homebrew --dependency-mode bundled-local --json."
+    };
+  }
+  const command = homebrew.command;
+  const packages = REQUIRED_PACKAGES.map((name) => packageStatus(name, command, spawnSync));
+  const postgres = packages.find((pkg) => pkg.name === "postgresql@17");
+  const pgvectorPackage = packages.find((pkg) => pkg.name === "pgvector");
+  const llama = packages.find((pkg) => pkg.name === "llama.cpp");
+  const binaryPaths = {};
+  const postgresBin = (name) => postgres?.prefix ? resolve(postgres.prefix, "bin", name) : "";
+  const llamaBin = (name) => llama?.prefix ? resolve(llama.prefix, "bin", name) : "";
+  const binaries = {
+    initdb: binary(binaryPaths, "initdb", postgresBin("initdb"), exists),
+    pg_ctl: binary(binaryPaths, "pg_ctl", postgresBin("pg_ctl"), exists),
+    psql: binary(binaryPaths, "psql", postgresBin("psql"), exists),
+    pg_dump: binary(binaryPaths, "pg_dump", postgresBin("pg_dump"), exists),
+    pg_restore: binary(binaryPaths, "pg_restore", postgresBin("pg_restore"), exists),
+    pg_config: binary(binaryPaths, "pg_config", postgresBin("pg_config"), exists),
+    llama_server: binary(binaryPaths, "llama_server", llamaBin("llama-server"), exists)
+  };
+  const sharedir = pgSharedir(binaries.pg_config.path, exists, spawnSync);
+  const controlPath = candidatePgvectorControlPaths(postgres?.prefix, pgvectorPackage?.prefix, sharedir).find((candidate) => exists(candidate));
+  const missing = [
+    ...packages.flatMap((pkg) => pkg.installed ? [] : [pkg.name]),
+    ...binaryEntries(binaries).flatMap(([name, info]) => info.exists ? [] : [name]),
+    ...controlPath ? [] : ["pgvector extension files"]
+  ];
+  const linked = exists(resolve(koedRuntime.postgresBinDir, "initdb")) && exists(resolve(koedRuntime.postgresBinDir, "pg_ctl")) && exists(resolve(koedRuntime.postgresBinDir, "psql")) && exists(resolve(koedRuntime.postgresBinDir, "pg_dump")) && exists(resolve(koedRuntime.postgresBinDir, "pg_restore")) && exists(koedRuntime.llamaServerBin);
+  const ok = missing.length === 0 && linked;
+  return {
+    ok,
+    state: ok ? "installed" : missing.length === 0 ? "missing" : "missing",
+    provider: "homebrew",
+    platform,
+    koedHome: paths.koedHome,
+    homebrew: { installed: true, prefix: homebrew.prefix },
+    packages,
+    binaries,
+    pgvector: {
+      compatible: Boolean(controlPath),
+      controlPath,
+      sqlPaths: candidatePgvectorSqlPaths(controlPath),
+      ...controlPath ? {} : { missing: ["vector.control"] }
+    },
+    koedRuntime: { ...koedRuntime, linked },
+    message: ok ? "Homebrew-backed bundled-local runtime is installed under KOED_HOME." : "Homebrew-backed bundled-local runtime is missing required assets or KOED_HOME links.",
+    action: ok ? void 0 : "Run koed runtime install --provider homebrew --dependency-mode bundled-local --json."
+  };
+};
+var collectHomebrewRuntimeStatus = (paths, environment = process.env, dependencies = {}) => {
+  return statusFrom({
+    paths,
+    platform: dependencies.platform ?? process.platform,
+    environment,
+    exists: dependencies.existsSync ?? existsSync,
+    spawnSync: dependencies.spawnSync ?? nodeSpawnSync
+  });
+};
+var linkRuntimePath = (source, target, koedHome, deps) => {
+  const resolvedTarget = resolve(target);
+  const resolvedKoedHome = resolve(koedHome);
+  if (resolvedTarget !== resolvedKoedHome && !resolvedTarget.startsWith(`${resolvedKoedHome}/`)) {
+    throw new Error(`Refusing to link runtime asset outside KOED_HOME: ${target}`);
+  }
+  deps.mkdirSync(dirname(resolvedTarget), { recursive: true, mode: 448 });
+  deps.rmSync(resolvedTarget, { force: true });
+  deps.symlinkSync(source, resolvedTarget);
+};
+var installHomebrewRuntime = (paths, environment = process.env, dependencies = {}) => {
+  const deps = {
+    platform: dependencies.platform ?? process.platform,
+    existsSync: dependencies.existsSync ?? existsSync,
+    mkdirSync: dependencies.mkdirSync ?? mkdirSync,
+    rmSync: dependencies.rmSync ?? rmSync,
+    symlinkSync: dependencies.symlinkSync ?? symlinkSync,
+    writeFileSync: dependencies.writeFileSync ?? writeFileSync,
+    readFileSync: dependencies.readFileSync ?? readFileSync,
+    spawnSync: dependencies.spawnSync ?? nodeSpawnSync
+  };
+  const before = collectHomebrewRuntimeStatus(paths, environment, deps);
+  if (before.state === "not_supported") {
+    return { ...before, installedPackages: [], linkedPaths: [] };
+  }
+  if (!before.homebrew.installed) {
+    return {
+      ...before,
+      state: "needs_attention",
+      message: "Homebrew is required before installing bundled-local runtime assets.",
+      action: "Install Homebrew or Linuxbrew on macOS, Linux, or WSL, then rerun koed runtime install --provider homebrew --dependency-mode bundled-local --json.",
+      installedPackages: [],
+      linkedPaths: []
+    };
+  }
+  const missingPackages = before.packages.filter((pkg) => !pkg.installed).map((pkg) => pkg.name);
+  if (missingPackages.length > 0) {
+    const homebrew = resolveHomebrewCommand(deps.platform, environment, deps.existsSync, deps.spawnSync);
+    if (!homebrew.ok) {
+      return {
+        ...before,
+        state: "needs_attention",
+        message: "Homebrew became unavailable before package installation.",
+        action: homebrew.error,
+        installedPackages: [],
+        linkedPaths: []
+      };
+    }
+    const result = run(homebrew.command, ["install", ...missingPackages], deps.spawnSync);
+    if (result.error || result.status !== 0) {
+      return {
+        ...before,
+        state: "needs_attention",
+        message: "Homebrew package installation failed.",
+        action: result.stderr.trim() || result.error?.message || "Inspect Homebrew output and retry.",
+        installedPackages: [],
+        linkedPaths: []
+      };
+    }
+  }
+  const afterInstall = collectHomebrewRuntimeStatus(paths, environment, deps);
+  const missingAfterInstall = [
+    ...afterInstall.packages.flatMap((pkg) => pkg.installed ? [] : [pkg.name]),
+    ...binaryEntries(afterInstall.binaries).flatMap(([name, info]) => info.exists ? [] : [name]),
+    ...afterInstall.pgvector.compatible ? [] : ["pgvector"]
+  ];
+  if (missingAfterInstall.length > 0) {
+    return {
+      ...afterInstall,
+      state: "needs_attention",
+      message: `Homebrew runtime assets are still missing: ${missingAfterInstall.join(", ")}.`,
+      installedPackages: missingPackages,
+      linkedPaths: []
+    };
+  }
+  const linkedPaths = [
+    [
+      afterInstall.binaries.initdb.path,
+      resolve(afterInstall.koedRuntime.postgresBinDir, "initdb")
+    ],
+    [
+      afterInstall.binaries.pg_ctl.path,
+      resolve(afterInstall.koedRuntime.postgresBinDir, "pg_ctl")
+    ],
+    [
+      afterInstall.binaries.psql.path,
+      resolve(afterInstall.koedRuntime.postgresBinDir, "psql")
+    ],
+    [
+      afterInstall.binaries.pg_dump.path,
+      resolve(afterInstall.koedRuntime.postgresBinDir, "pg_dump")
+    ],
+    [
+      afterInstall.binaries.pg_restore.path,
+      resolve(afterInstall.koedRuntime.postgresBinDir, "pg_restore")
+    ],
+    [
+      afterInstall.binaries.pg_config.path,
+      resolve(afterInstall.koedRuntime.postgresBinDir, "pg_config")
+    ],
+    [
+      afterInstall.binaries.llama_server.path,
+      afterInstall.koedRuntime.llamaServerBin
+    ]
+  ];
+  for (const [source, target] of linkedPaths) {
+    linkRuntimePath(source, target, paths.koedHome, deps);
+  }
+  deps.mkdirSync(paths.cacheDir, { recursive: true, mode: 448 });
+  deps.writeFileSync(afterInstall.koedRuntime.metadataPath, `${JSON.stringify({
+    provider: "homebrew",
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    packages: afterInstall.packages,
+    binaries: afterInstall.binaries,
+    pgvector: afterInstall.pgvector
+  }, null, 2)}
+`, { mode: 384 });
+  const finalStatus = collectHomebrewRuntimeStatus(paths, environment, deps);
+  return {
+    ...finalStatus,
+    installedPackages: missingPackages,
+    linkedPaths: linkedPaths.map(([, target]) => target)
+  };
+};
+export {
+  collectHomebrewRuntimeStatus,
+  installHomebrewRuntime
+};