@koed-labs/server 0.0.0-stage → 0.10.3

package/vendor/chunk-A4NKL2PK.js

@@ -0,0 +1,153 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+
+// packages/koed-server/dist/app-runtime.js
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+var sourceCheckoutRoot = resolve(packageRoot, "..", "..");
+var isSourceCheckoutControlPlane = () => existsSync(resolve(sourceCheckoutRoot, "pnpm-workspace.yaml")) && existsSync(resolve(packageRoot, "package.json"));
+var resolveKoedAppRuntimeExecution = () => isSourceCheckoutControlPlane() ? "source" : "packaged";
+var resolveKoedRuntimeOwner = () => ({
+  kind: "standalone",
+  installationId: createHash("sha256").update(realpathSync.native(packageRoot)).digest("hex").slice(0, 32)
+});
+var resolveKoedControlPlaneVersion = () => {
+  const value = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8"));
+  if (!value || typeof value !== "object" || !("version" in value) || typeof value.version !== "string" || !/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/.test(value.version))
+    throw new Error("Koed server control-plane version is invalid.");
+  return value.version;
+};
+var sourceRuntime = (paths, exists) => {
+  const root = paths.repoRoot;
+  const apiEntry = resolve(root, "apps/api/dist/index.js");
+  const workerEntry = resolve(root, "apps/worker/dist/index.js");
+  const embeddingServiceEntry = resolve(root, "apps/embedding-service/dist/index.js");
+  const privacyServiceEntry = resolve(root, "apps/privacy-service/dist/index.js");
+  const mcpCli = resolve(root, "packages/mcp-server/dist/cli.js");
+  const localAiRuntime = resolve(root, "packages/mcp-server/dist/local-runtime-cli.js");
+  const captureHook = resolve(root, "packages/mcp-server/dist/capture-hook.js");
+  const dbPackageRoot = resolve(root, "packages/db");
+  const required = [
+    resolve(root, "scripts/setup-env.mjs"),
+    resolve(root, "apps/api/package.json"),
+    resolve(root, "apps/worker/package.json"),
+    resolve(root, "apps/privacy-service/package.json"),
+    resolve(root, "packages/db/package.json"),
+    resolve(root, "packages/mcp-server/package.json")
+  ];
+  return {
+    kind: "source",
+    artifactSource: "source-checkout",
+    root,
+    apiEntry,
+    workerEntry,
+    embeddingServiceEntry,
+    privacyServiceEntry,
+    mcpCli,
+    localAiRuntime,
+    captureHook,
+    dbPackageRoot,
+    missing: required.filter((entry) => !exists(entry))
+  };
+};
+var requiredProcesses = [
+  "api",
+  "worker",
+  "local-ai-runtime",
+  "embedding-service"
+];
+var effectiveRequirements = (requirements) => requirements ?? {
+  components: ["base"],
+  processes: requiredProcesses,
+  queue: "bullmq",
+  native: [],
+  models: []
+};
+var packagedRuntime = (selection, requirements, exists) => {
+  const root = selection?.base.root ?? "";
+  const apiEntry = resolve(root, "api/dist/index.js");
+  const workerEntry = resolve(root, "worker/dist/index.js");
+  const embeddingServiceEntry = resolve(root, "embedding-service/dist/index.js");
+  const privacyServiceEntry = selection?.privacy ? resolve(selection.privacy.root, "privacy-service/dist/index.js") : void 0;
+  const mcpCli = resolve(root, "mcp-server/dist/cli.js");
+  const localAiRuntime = resolve(root, "mcp-server/dist/local-runtime-cli.js");
+  const captureHook = resolve(root, "mcp-server/dist/capture-hook.js");
+  const dbPackageRoot = resolve(root, "node_modules/@koed/db");
+  const required = [
+    ...selection ? [] : ["authenticated base generation"],
+    ...requirements.processes.includes("api") ? [apiEntry] : [],
+    ...requirements.processes.includes("worker") ? [workerEntry] : [],
+    ...requirements.processes.includes("embedding-service") ? [embeddingServiceEntry] : [],
+    ...requirements.processes.includes("local-ai-runtime") ? [mcpCli, localAiRuntime, captureHook] : [],
+    ...requirements.components.includes("privacy") ? [
+      ...privacyServiceEntry ? [privacyServiceEntry] : ["authenticated privacy generation"]
+    ] : [],
+    ...requirements.processes.includes("api") || requirements.processes.includes("worker") ? [
+      resolve(dbPackageRoot, "dist/index.js"),
+      resolve(dbPackageRoot, "dist/connection.js"),
+      resolve(dbPackageRoot, "dist/user-api-token-repository.js"),
+      resolve(dbPackageRoot, "drizzle/meta/_journal.json")
+    ] : []
+  ];
+  return {
+    kind: "packaged",
+    artifactSource: "verified-generation",
+    ...selection ? { generationId: selection.id } : {},
+    ...selection?.privacy ? {
+      privacyManifestDigest: selection.privacy.manifestDigest,
+      ...selection.privacy.manifest.variant ? { privacyVariant: selection.privacy.manifest.variant } : {}
+    } : {},
+    root,
+    apiEntry,
+    workerEntry,
+    embeddingServiceEntry,
+    ...privacyServiceEntry ? { privacyServiceEntry } : {},
+    mcpCli,
+    localAiRuntime,
+    captureHook,
+    dbPackageRoot,
+    missing: required.filter((entry) => entry.startsWith("authenticated ") ? true : !exists(entry))
+  };
+};
+var rejectUntrustedPackagedOverrides = (environment) => {
+  const overrideNames = [
+    "KOED_JS_RUNTIME_ROOT",
+    "KOED_REPO_ROOT",
+    "KOED_PACKAGED_RESOURCES_PATH",
+    "KOED_ALLOW_PACKAGED_SOURCE_FALLBACK"
+  ];
+  const supplied = overrideNames.filter((name) => environment[name]?.trim());
+  if (supplied.length > 0) {
+    throw new Error(`Unsupported packaged runtime override: ${supplied.join(", ")}. Packaged services require a verified generation.`);
+  }
+};
+var resolveKoedAppRuntimeForExecution = (paths, environment, exists, selection, requirements, execution) => {
+  if (execution === "source")
+    return sourceRuntime(paths, exists);
+  rejectUntrustedPackagedOverrides(environment);
+  return packagedRuntime(selection, effectiveRequirements(requirements), exists);
+};
+var resolveKoedAppRuntime = (paths, environment = process.env, exists = existsSync, selection, requirements) => resolveKoedAppRuntimeForExecution(paths, environment, exists, selection, requirements, resolveKoedAppRuntimeExecution());
+var assertKoedAppRuntimeAvailable = (runtime, paths) => {
+  if (runtime.missing.length === 0)
+    return;
+  if (runtime.kind === "packaged") {
+    throw new Error([
+      "Packaged Koed JS runtime artifacts are missing.",
+      `Missing authenticated runtime files under ${runtime.root || "verified generation"}: ${runtime.missing.join(", ")}.`,
+      "Install a compatible signed Koed runtime generation; packaged startup never downloads or uses checkout files."
+    ].join(" "));
+  }
+  void paths;
+};
+
+export {
+  resolveKoedAppRuntimeExecution,
+  resolveKoedRuntimeOwner,
+  resolveKoedControlPlaneVersion,
+  resolveKoedAppRuntimeForExecution,
+  resolveKoedAppRuntime,
+  assertKoedAppRuntimeAvailable
+};

package/vendor/chunk-A6WMU2GG.js

@@ -0,0 +1,48 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  runApplicationSecretProvider
+} from "./chunk-2S3OGPUC.js";
+import "./chunk-K2EIFEQF.js";
+import "./chunk-UI5RLBKQ.js";
+import "./chunk-473OA62O.js";
+import "./chunk-BTS4ZTF3.js";
+
+// packages/koed-server/dist/cli-internal-operations.js
+import { readSync } from "node:fs";
+var readSecretStdin = () => {
+  const maximum = 2e6;
+  const buffer = Buffer.allocUnsafe(maximum + 1);
+  let offset = 0;
+  try {
+    while (offset < buffer.length) {
+      const count = readSync(0, buffer, offset, buffer.length - offset, null);
+      if (count === 0)
+        break;
+      offset += count;
+    }
+    if (offset > maximum)
+      return null;
+    return buffer.subarray(0, offset).toString("utf8");
+  } finally {
+    buffer.fill(0);
+  }
+};
+var runSecretProviderCommand = async (operation, reference, dependencies) => {
+  const stdout = dependencies.stdout ?? process.stdout;
+  try {
+    const value = operation === "put" ? readSecretStdin() : void 0;
+    if (operation === "put" && value === null)
+      return 1;
+    const result = await runApplicationSecretProvider(operation, reference, value ?? void 0, process.env);
+    if (!result.ok)
+      return 1;
+    if (operation === "get" && result.value !== null)
+      stdout.write(result.value);
+    return 0;
+  } catch {
+    return 1;
+  }
+};
+export {
+  runSecretProviderCommand
+};

package/vendor/chunk-AFLKCQHF.js

@@ -0,0 +1,73 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  resolveKoedServerConfig
+} from "./chunk-NM5NXCVM.js";
+import {
+  parseEnvFile
+} from "./chunk-W2HNI6AA.js";
+import {
+  resolveTeamCollaborationEnabled
+} from "./chunk-473OA62O.js";
+
+// packages/koed-server/dist/effective-runtime-config.js
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+function resolveEffectiveRuntimeConfig(paths, environment, execution) {
+  const envPath = environment.KOED_ENV_PATH?.trim() ? resolve(environment.KOED_ENV_PATH) : execution === "source" ? resolve(paths.repoRoot, ".env") : void 0;
+  let fileEnvironment = {};
+  if (envPath) {
+    if (!existsSync(envPath)) {
+      if (environment.KOED_ENV_PATH?.trim()) {
+        throw new Error(`Explicit environment file does not exist: ${envPath}`);
+      }
+    } else {
+      fileEnvironment = parseEnvFile(readFileSync(envPath, "utf8"), {
+        strict: Boolean(environment.KOED_ENV_PATH?.trim()),
+        source: envPath
+      });
+    }
+  }
+  const effectiveEnvironment = { ...fileEnvironment, ...environment };
+  const config = resolveKoedServerConfig(paths, effectiveEnvironment, {
+    strict: execution === "packaged" || Boolean(environment.KOED_ENV_PATH?.trim())
+  });
+  return {
+    config,
+    environment: effectiveEnvironment,
+    teamEnabled: resolveTeamCollaborationEnabled(effectiveEnvironment),
+    explicitWorkQueueBackend: environment.WORK_QUEUE_BACKEND?.trim() || null
+  };
+}
+function calculateRuntimeRequirements(effective) {
+  const localPrivacy = effective.config.dependencyMode === "bundled-local" && effective.teamEnabled;
+  const components = localPrivacy ? ["base", "privacy"] : ["base"];
+  const processes = [
+    "api",
+    "worker"
+  ];
+  if (effective.config.runtimeMode !== "external")
+    processes.push("local-ai-runtime");
+  if (effective.config.dependencyMode === "bundled-local") {
+    processes.push("postgres", "embedding-service");
+    if (localPrivacy)
+      processes.push("privacy-service");
+  }
+  const bundled = effective.config.dependencyMode === "bundled-local";
+  const queueValue = effective.explicitWorkQueueBackend === null ? bundled ? void 0 : effective.environment.WORK_QUEUE_BACKEND?.trim() : effective.explicitWorkQueueBackend ?? effective.environment.WORK_QUEUE_BACKEND?.trim();
+  if (queueValue && queueValue !== "local" && queueValue !== "bullmq") {
+    throw new Error('WORK_QUEUE_BACKEND must be "local" or "bullmq"');
+  }
+  const queue = queueValue === "local" || queueValue === "bullmq" ? queueValue : effective.config.dependencyMode === "bundled-local" ? "local" : "bullmq";
+  return {
+    components,
+    processes,
+    queue,
+    native: bundled ? ["postgres", "llama-server"] : [],
+    models: bundled ? localPrivacy ? ["embedding", "privacy"] : ["embedding"] : []
+  };
+}
+
+export {
+  resolveEffectiveRuntimeConfig,
+  calculateRuntimeRequirements
+};

package/vendor/chunk-BTS4ZTF3.js

@@ -0,0 +1,43 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};

package/vendor/chunk-C3N4N5HR.js

@@ -0,0 +1,108 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  checkCoreSetupNeeded,
+  createCliServiceContext,
+  deviceRequestCommand,
+  printJson
+} 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-pair-operations.js
+var runPairCommand = async (subcommand, options, dependencies) => {
+  const { startDaemon, collectStartupStatus, resolvePaths, stdout, stderr } = createCliServiceContext(dependencies);
+  const deviceRequestCommand2 = dependencies.deviceRequest ?? deviceRequestCommand;
+  const wantsJson = options.json;
+  try {
+    const paths = resolvePaths();
+    const setupNeeded = checkCoreSetupNeeded(paths);
+    if (subcommand === "status" || subcommand === "cancel") {
+      const value = await deviceRequestCommand2(paths, subcommand);
+      if (wantsJson)
+        printJson(stdout, value);
+      else
+        stdout.write(`${value.state}
+`);
+      return 0;
+    }
+    if (setupNeeded) {
+      stderr.write(`${setupNeeded}
+`);
+      return 1;
+    }
+    let ready = await collectStartupStatus();
+    if (!ready.ok) {
+      const started = startDaemon();
+      if (!started.ok)
+        throw new Error(started.error ?? started.message);
+      for (let attempt = 0; attempt < 90 && !ready.ok; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        ready = await collectStartupStatus();
+      }
+    }
+    if (!ready.ok)
+      throw new Error("Koed could not start. Run koed doctor for setup guidance.");
+    const initial = await deviceRequestCommand2(paths, "create", options.deviceLabel);
+    if (wantsJson)
+      printJson(stdout, initial);
+    else
+      stdout.write(initial.link ? `Paste this request into Devices \u2192 Add device on your existing Koed installation:
+
+${initial.link}
+
+Expires ${initial.expiresAt}. Waiting for approval\u2026
+` : `Enrollment is ${initial.state}. Waiting\u2026
+`);
+    if (options.detach)
+      return 0;
+    let previous = initial.state;
+    for (; ; ) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      const value = await deviceRequestCommand2(paths, "status");
+      if (value.state !== previous) {
+        if (wantsJson)
+          printJson(stdout, value);
+        else
+          stdout.write(`${value.state}
+`);
+        previous = value.state;
+      }
+      if (value.state === "connected")
+        return 0;
+      if (["failed", "expired", "cancelled"].includes(value.state))
+        return 1;
+    }
+  } 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 {
+  runPairCommand
+};

package/vendor/chunk-DXTAWHY3.js

@@ -0,0 +1,25 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  decryptRecoveryKit,
+  encryptRecoveryKit,
+  parseLoopbackOrigin,
+  personalSyncProviderEnvironment,
+  redeemPairingLink,
+  runPersonalSyncCommand
+} from "./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-BTS4ZTF3.js";
+export {
+  decryptRecoveryKit,
+  encryptRecoveryKit,
+  parseLoopbackOrigin,
+  personalSyncProviderEnvironment,
+  redeemPairingLink,
+  runPersonalSyncCommand
+};

package/vendor/chunk-G4IIVVJO.js

@@ -0,0 +1,56 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+
+// packages/koed-server/dist/runtime-state.js
+import { readFileSync as nodeReadFileSync } from "node:fs";
+
+// packages/koed-server/dist/process-liveness.js
+var isProcessRunning = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// packages/koed-server/dist/runtime-state.js
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var validHttpUrl = (value) => {
+  if (typeof value !== "string")
+    return false;
+  try {
+    return ["http:", "https:"].includes(new URL(value).protocol);
+  } catch {
+    return false;
+  }
+};
+var validProcessMap = (value) => value === void 0 || isRecord(value) && Object.values(value).every((pid) => typeof pid === "number" && Number.isInteger(pid) && pid >= 0);
+var validRuntimeState = (value) => {
+  if (!isRecord(value))
+    return false;
+  const validRuntimeMode = value.runtimeMode === void 0 || value.runtimeMode === "local-personal" || value.runtimeMode === "external" || value.runtimeMode === "developer";
+  const validDependencyMode = value.dependencyMode === void 0 || value.dependencyMode === "bundled-local" || value.dependencyMode === "external";
+  const validAutomaticPorts = value.automaticPorts === void 0 || typeof value.automaticPorts === "boolean";
+  return typeof value.pid === "number" && Number.isInteger(value.pid) && value.pid > 0 && typeof value.startedAt === "string" && !Number.isNaN(Date.parse(value.startedAt)) && typeof value.repoRoot === "string" && Boolean(value.repoRoot.trim()) && validHttpUrl(value.apiUrl) && Array.isArray(value.services) && value.services.every((service) => typeof service === "string") && validRuntimeMode && validDependencyMode && validAutomaticPorts && validProcessMap(value.processes);
+};
+var isRuntimeGenerationState = (value) => isRecord(value) && (Object.keys(value).length === 7 || Object.keys(value).length === 8 && ["manifest-pinned-store", "signed-store", "desktop-bundle"].includes(String(value.source))) && value.schemaVersion === 1 && typeof value.generationId === "string" && /^[a-f0-9]{64}$/.test(value.generationId) && typeof value.pid === "number" && Number.isInteger(value.pid) && value.pid > 0 && typeof value.processIdentity === "string" && value.processIdentity.length > 0 && typeof value.startedAt === "string" && !Number.isNaN(Date.parse(value.startedAt)) && isRecord(value.owner) && Object.keys(value.owner).length === 2 && ["cli", "desktop", "standalone"].includes(String(value.owner.kind)) && typeof value.owner.installationId === "string" && /^[A-Za-z0-9._-]{1,128}$/.test(value.owner.installationId) && typeof value.pinToken === "string" && /^[a-f0-9]{64}$/.test(value.pinToken);
+var readActiveRuntimeState = (path, readFileSync = nodeReadFileSync, checkPid = isProcessRunning) => {
+  try {
+    const parsed = JSON.parse(String(readFileSync(path, "utf8")));
+    return validRuntimeState(parsed) && checkPid(parsed.pid) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+var applyActiveRuntimeUrls = (environment, runtime) => ({
+  ...environment,
+  ...runtime?.apiUrl ? { MEMORY_API_URL: runtime.apiUrl } : {},
+  ...runtime?.automaticPorts ? { KOED_AUTO_PORTS: "1" } : {}
+});
+
+export {
+  isProcessRunning,
+  isRuntimeGenerationState,
+  readActiveRuntimeState,
+  applyActiveRuntimeUrls
+};