@koed-labs/server 0.0.0-stage → 0.10.3

package/vendor/chunk-YK4F4VY2.js

@@ -0,0 +1,173 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  createCliServiceContext,
+  printJson
+} from "./chunk-YCDEMYY6.js";
+import {
+  evaluateAiClientReadiness
+} from "./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-integration-operations.js
+var runIntegrationCommand = async (command, options, dependencies) => {
+  const { collectStatus, setupCoreIntegration, setup, setupClaudeIntegration, setupPiIntegration, removeClaudeIntegration, removePiIntegration, removeCodexIntegrationFn, repairCodex, stdout, stderr } = createCliServiceContext(dependencies);
+  const subcommand = options.client;
+  const wantsJson = options.json;
+  try {
+    if (command === "setup" && subcommand === "core") {
+      const result = await setupCoreIntegration();
+      if (wantsJson) {
+        printJson(stdout, result);
+      } else {
+        stdout.write(result.ok ? "Koed core setup completed.\n" : `${result.error ?? "Koed core setup failed."}
+`);
+      }
+      return result.ok ? 0 : 1;
+    }
+    if (command === "setup" && subcommand === "codex") {
+      const withoutGuidance = Boolean(options.withoutMemoryGuidance);
+      const withGuidance = Boolean(options.withMemoryGuidance);
+      if (withoutGuidance && withGuidance) {
+        throw new Error("Use only one of --with-memory-guidance or --without-memory-guidance.");
+      }
+      const deferredRecall = Boolean(options.deferredRecall);
+      const blockingRecall = Boolean(options.blockingRecall);
+      if (deferredRecall && blockingRecall)
+        throw new Error("Use only one of --deferred-recall or --blocking-recall.");
+      if (deferredRecall || blockingRecall) {
+        stderr.write("Legacy recall flags are deprecated; select delivery_mode on memory_answer instead.\n");
+      }
+      const result = await setup({
+        environment: {
+          ...process.env,
+          ...withoutGuidance || withGuidance ? {
+            KOED_CODEX_GLOBAL_MEMORY_GUIDANCE_ENABLED: String(withGuidance)
+          } : {},
+          ...deferredRecall || blockingRecall ? { KOED_CODEX_STOP_DELIVERY: deferredRecall ? "1" : "0" } : {}
+        }
+      });
+      if (wantsJson) {
+        printJson(stdout, result);
+      } else {
+        stdout.write(result.ok ? "Codex setup completed.\n" : `${result.error ?? "Codex setup failed."}
+`);
+      }
+      return result.ok ? 0 : 1;
+    }
+    if (command === "setup" && subcommand === "pi") {
+      const result = await setupPiIntegration();
+      if (wantsJson) {
+        printJson(stdout, result);
+      } else {
+        stdout.write(result.ok ? result.authenticationState === "authenticated" ? "Pi setup completed.\n" : "Pi profile configured. Authenticate at least one model through Pi, then refresh capabilities; Pi-executed work remains unavailable until authentication.\n" : `${result.error ?? "Pi setup failed."}
+`);
+      }
+      return result.ok ? 0 : 1;
+    }
+    if (command === "setup" && subcommand === "claude") {
+      const result = await (options.backgroundRecall ? setupClaudeIntegration(void 0, void 0, {
+        backgroundRecall: true
+      }) : setupClaudeIntegration());
+      if (wantsJson) {
+        printJson(stdout, result);
+      } else {
+        stdout.write(result.ok ? result.authenticationState === "authenticated" ? "Claude Code setup completed. Restart Claude Code before verifying capture and recall.\n" : "Claude Code profile configured. Run `claude auth login`, then refresh capabilities; Claude-executed work remains unavailable until sign-in.\n" : `${result.error ?? "Claude Code setup failed."}
+`);
+      }
+      if (!wantsJson && result.backgroundRecall)
+        stdout.write(`${result.backgroundRecall.message}
+`);
+      return result.ok ? 0 : 1;
+    }
+    if (command === "repair" && subcommand === "codex") {
+      const result = await repairCodex();
+      if (wantsJson) {
+        printJson(stdout, result);
+      } else {
+        stdout.write(result.ok ? "Codex integration repaired. Restart Codex and trust updated hooks if prompted.\n" : `${result.error ?? "Codex integration repair failed."}
+`);
+      }
+      return result.ok ? 0 : 1;
+    }
+    if (command === "check" && subcommand) {
+      const status = await collectStatus(void 0, void 0, {
+        capabilitiesRefreshedSince: options.capabilitiesRefreshedSince
+      });
+      const components = {
+        codex: status.codex,
+        claude: status.claudeCode,
+        pi: status.pi
+      };
+      const readiness = components[subcommand] ? status.aiClients?.[subcommand] : void 0;
+      if (!components[subcommand])
+        throw new Error("check client must be codex, claude, or pi.");
+      const result = {
+        client: subcommand,
+        readiness: readiness ?? null,
+        ...options.includeStatus ? { status } : {},
+        ...evaluateAiClientReadiness(readiness)
+      };
+      if (wantsJson)
+        printJson(stdout, result);
+      else
+        stdout.write(`${result.message}
+`);
+      return result.ok ? 0 : 1;
+    }
+    if (command === "repair" && subcommand) {
+      const result = subcommand === "codex" ? await repairCodex() : subcommand === "claude" ? await setupClaudeIntegration() : subcommand === "pi" ? await setupPiIntegration() : null;
+      if (!result)
+        throw new Error("repair client must be codex, claude, or pi.");
+      if (wantsJson)
+        printJson(stdout, result);
+      else
+        stdout.write(`${result.ok ? "AI Client integration repaired." : result.error ?? "AI Client integration repair failed."}
+`);
+      return result.ok ? 0 : 1;
+    }
+    if (command === "remove" && subcommand) {
+      const result = subcommand === "codex" ? removeCodexIntegrationFn() : subcommand === "claude" ? removeClaudeIntegration() : subcommand === "pi" ? removePiIntegration() : null;
+      if (!result)
+        throw new Error("remove client must be codex, claude, or pi.");
+      if (wantsJson)
+        printJson(stdout, result);
+      else
+        stdout.write(`${result.ok ? "AI Client integration removed." : result.error ?? "AI Client integration removal failed."}
+`);
+      return result.ok ? 0 : 1;
+    }
+    throw new Error("Unknown AI Client integration 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 {
+  runIntegrationCommand
+};

package/vendor/chunk-YOFI4PCH.js

@@ -0,0 +1,36 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  activateServerPackage,
+  assertPackageMigrationCompatible,
+  cleanupServerPackages,
+  collectServerPackageStatus,
+  extractVerifiedPackageArchive,
+  installServerPackage,
+  isVersionDowngrade,
+  packageExtractionLimits,
+  packageProvenanceSchemaVersion,
+  requiredPackageRuntimeFiles,
+  sha256File,
+  standalonePackageId,
+  standalonePackageKind,
+  standalonePackageSchemaVersion,
+  validateServerPackageRoot
+} from "./chunk-2DA7EFZV.js";
+import "./chunk-BTS4ZTF3.js";
+export {
+  activateServerPackage,
+  assertPackageMigrationCompatible,
+  cleanupServerPackages,
+  collectServerPackageStatus,
+  extractVerifiedPackageArchive,
+  installServerPackage,
+  isVersionDowngrade,
+  packageExtractionLimits,
+  packageProvenanceSchemaVersion,
+  requiredPackageRuntimeFiles,
+  sha256File,
+  standalonePackageId,
+  standalonePackageKind,
+  standalonePackageSchemaVersion,
+  validateServerPackageRoot
+};

package/vendor/chunk-ZUGNCQZE.js

@@ -0,0 +1,247 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+
+// packages/koed-server/dist/local-models-runtime.js
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream, existsSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { basename, dirname, resolve } from "node:path";
+var MODEL_DEFINITIONS = {
+  embedding: {
+    key: "qwen3-0.6b",
+    filename: "Qwen3-Embedding-0.6B-Q8_0.gguf",
+    urlEnv: "KOED_EMBEDDING_MODEL_URL",
+    sha256Env: "KOED_EMBEDDING_MODEL_SHA256",
+    pathEnv: "KOED_EMBEDDING_MODEL_PATH",
+    defaultUrl: "https://huggingface.co/Qwen/Qwen3-Embedding-0.6B-GGUF/resolve/main/Qwen3-Embedding-0.6B-Q8_0.gguf",
+    defaultSha256: "06507c7b42688469c4e7298b0a1e16deff06caf291cf0a5b278c308249c3e439"
+  }
+};
+var localModelKinds = ["embedding"];
+var trimEnv = (environment, name) => {
+  const value = environment[name]?.trim();
+  return value ? value : void 0;
+};
+var dependencyMode = (environment) => {
+  const value = trimEnv(environment, "KOED_DEPENDENCY_MODE");
+  if (value === "bundled-local" || value === "external") {
+    return value;
+  }
+  return void 0;
+};
+var modelDownloadBlockedAction = (manifest) => `External dependency mode does not download model assets. Switch to bundled-local mode or set ${manifest.pathEnv} to an existing model file.`;
+var normalizeSha256 = (value) => {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  if (!/^[a-f0-9]{64}$/.test(normalized)) {
+    throw new Error("Model SHA-256 must be 64 lowercase or uppercase hex characters.");
+  }
+  return normalized;
+};
+var resolveLocalModelManifest = (paths, kind = "embedding", environment = process.env) => {
+  const definition = MODEL_DEFINITIONS[kind];
+  const explicitPath = trimEnv(environment, definition.pathEnv);
+  return {
+    kind,
+    key: definition.key,
+    filename: definition.filename,
+    modelPath: explicitPath ? resolve(explicitPath) : resolve(paths.modelsDir, definition.filename),
+    urlEnv: definition.urlEnv,
+    sha256Env: definition.sha256Env,
+    pathEnv: definition.pathEnv,
+    url: trimEnv(environment, definition.urlEnv) ?? definition.defaultUrl,
+    sha256: normalizeSha256(trimEnv(environment, definition.sha256Env) ?? definition.defaultSha256),
+    defaultUrl: definition.defaultUrl,
+    defaultSha256: definition.defaultSha256
+  };
+};
+var sha256File = async (path) => {
+  const hash = createHash("sha256");
+  await pipeline(createReadStream(path), hash);
+  return hash.digest("hex");
+};
+var collectLocalModelStatus = async (paths, kind = "embedding", environment = process.env) => {
+  const manifest = resolveLocalModelManifest(paths, kind, environment);
+  const mode = dependencyMode(environment);
+  if (!existsSync(manifest.modelPath)) {
+    return {
+      state: "missing",
+      message: `${manifest.key} model is not installed at ${manifest.modelPath}.`,
+      action: mode === "external" ? modelDownloadBlockedAction(manifest) : `Run koed models install --kind ${kind}. Override ${manifest.urlEnv} and ${manifest.sha256Env} only when using a custom model artifact.`,
+      modelPath: manifest.modelPath,
+      manifest
+    };
+  }
+  const sizeBytes = statSync(manifest.modelPath).size;
+  if (!manifest.sha256) {
+    return {
+      state: "not_configured",
+      message: `${manifest.key} model exists, but ${manifest.sha256Env} is not configured for verification.`,
+      action: `Set ${manifest.sha256Env} to verify installed model checksum.`,
+      modelPath: manifest.modelPath,
+      sizeBytes,
+      manifest
+    };
+  }
+  const actual = await sha256File(manifest.modelPath);
+  if (actual !== manifest.sha256) {
+    return {
+      state: "checksum_mismatch",
+      message: `${manifest.key} model checksum mismatch.`,
+      action: `Remove ${manifest.modelPath}, verify ${manifest.sha256Env}, then run koed models install --kind ${kind}.`,
+      modelPath: manifest.modelPath,
+      sizeBytes,
+      sha256: actual,
+      manifest
+    };
+  }
+  return {
+    state: "installed",
+    message: `${manifest.key} model is installed and checksum verified.`,
+    modelPath: manifest.modelPath,
+    sizeBytes,
+    sha256: actual,
+    manifest
+  };
+};
+var installLocalModel = async (paths, kind = "embedding", environment = process.env, { fetch: fetcher = globalThis.fetch.bind(globalThis), onProgress } = {}) => {
+  const manifest = resolveLocalModelManifest(paths, kind, environment);
+  const mode = dependencyMode(environment);
+  if (mode === "external") {
+    return {
+      ok: false,
+      state: "not_configured",
+      message: `${manifest.key} model downloads are disabled in external dependency mode.`,
+      action: modelDownloadBlockedAction(manifest),
+      modelPath: manifest.modelPath,
+      manifest
+    };
+  }
+  if (!manifest.url) {
+    return {
+      ok: false,
+      state: "not_configured",
+      message: `${manifest.urlEnv} is required to install ${manifest.key}.`,
+      action: `Set ${manifest.urlEnv} to HTTPS model artifact URL.`,
+      modelPath: manifest.modelPath,
+      manifest
+    };
+  }
+  if (!manifest.sha256) {
+    return {
+      ok: false,
+      state: "not_configured",
+      message: `${manifest.sha256Env} is required before installing ${manifest.key}.`,
+      action: `Set ${manifest.sha256Env} to expected SHA-256 checksum.`,
+      modelPath: manifest.modelPath,
+      manifest
+    };
+  }
+  try {
+    if (new URL(manifest.url).protocol !== "https:") {
+      return {
+        ok: false,
+        state: "not_configured",
+        message: `${manifest.urlEnv} must be an HTTPS URL.`,
+        action: `Set ${manifest.urlEnv} to a trusted HTTPS model artifact URL.`,
+        modelPath: manifest.modelPath,
+        manifest
+      };
+    }
+  } catch {
+    return {
+      ok: false,
+      state: "not_configured",
+      message: `${manifest.urlEnv} must be a valid HTTPS URL.`,
+      action: `Set ${manifest.urlEnv} to a trusted HTTPS model artifact URL.`,
+      modelPath: manifest.modelPath,
+      manifest
+    };
+  }
+  mkdirSync(dirname(manifest.modelPath), { recursive: true, mode: 448 });
+  const tempPath = resolve(paths.cacheDir, `${basename(manifest.modelPath)}.${process.pid}.download`);
+  mkdirSync(paths.cacheDir, { recursive: true, mode: 448 });
+  rmSync(tempPath, { force: true });
+  const response = await fetcher(manifest.url);
+  if (!response.ok || !response.body) {
+    return {
+      ok: false,
+      state: "missing",
+      message: `Could not download ${manifest.key}: HTTP ${response.status}.`,
+      action: `Check ${manifest.urlEnv}, network access, and artifact permissions.`,
+      modelPath: manifest.modelPath,
+      manifest
+    };
+  }
+  const contentLength = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+  const totalBytes = Number.isSafeInteger(contentLength) && contentLength >= 0 ? contentLength : null;
+  let completedBytes = 0;
+  let lastReportedBytes = 0;
+  let lastReportedAt = 0;
+  onProgress?.({
+    completedBytes: 0,
+    phase: "downloading",
+    totalBytes
+  });
+  const progress = new Transform({
+    transform(chunk, _encoding, callback) {
+      completedBytes += chunk.byteLength;
+      const now = Date.now();
+      if (completedBytes === totalBytes || completedBytes - lastReportedBytes >= 1048576 || now - lastReportedAt >= 250) {
+        lastReportedBytes = completedBytes;
+        lastReportedAt = now;
+        onProgress?.({
+          completedBytes,
+          phase: "downloading",
+          totalBytes
+        });
+      }
+      callback(null, chunk);
+    }
+  });
+  await pipeline(Readable.fromWeb(response.body), progress, createWriteStream(tempPath, { mode: 384 }));
+  onProgress?.({
+    completedBytes,
+    phase: "verifying",
+    totalBytes
+  });
+  const actual = await sha256File(tempPath);
+  if (actual !== manifest.sha256) {
+    rmSync(tempPath, { force: true });
+    return {
+      ok: false,
+      state: "checksum_mismatch",
+      message: `${manifest.key} downloaded checksum mismatch.`,
+      action: `Verify ${manifest.sha256Env} and ${manifest.urlEnv}.`,
+      modelPath: manifest.modelPath,
+      sha256: actual,
+      manifest
+    };
+  }
+  renameSync(tempPath, manifest.modelPath);
+  const sizeBytes = statSync(manifest.modelPath).size;
+  const status = {
+    state: "installed",
+    message: `${manifest.key} model is installed and checksum verified.`,
+    modelPath: manifest.modelPath,
+    sizeBytes,
+    sha256: actual,
+    manifest
+  };
+  onProgress?.({
+    completedBytes: sizeBytes,
+    phase: "complete",
+    totalBytes: sizeBytes
+  });
+  return { ok: true, ...status };
+};
+
+export {
+  localModelKinds,
+  resolveLocalModelManifest,
+  sha256File,
+  collectLocalModelStatus,
+  installLocalModel
+};

package/vendor/chunk-ZXX4ZNJY.js

@@ -0,0 +1,21 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  PRIVACY_MODEL_FILES,
+  PRIVACY_MODEL_ID,
+  PRIVACY_MODEL_REVISION,
+  collectPrivacyModelStatus,
+  installPrivacyModel,
+  materializePrivacyModelCacheEntry,
+  resolvePrivacyModelPaths
+} from "./chunk-VPC5NLZG.js";
+import "./chunk-473OA62O.js";
+import "./chunk-BTS4ZTF3.js";
+export {
+  PRIVACY_MODEL_FILES,
+  PRIVACY_MODEL_ID,
+  PRIVACY_MODEL_REVISION,
+  collectPrivacyModelStatus,
+  installPrivacyModel,
+  materializePrivacyModelCacheEntry,
+  resolvePrivacyModelPaths
+};

package/vendor/cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+if (Number(process.versions.node.split(".")[0]) !== 24) { console.error(`@koed-labs/server requires Node.js >=24 <25; found ${process.versions.node}.`); process.exit(1); }
+const { runKoedServerCli, shouldExitPackagedSupervisor } = await import("./control-plane.js");
+const args = process.argv.slice(2);
+const exitCode = await runKoedServerCli(args);
+if (shouldExitPackagedSupervisor(args)) process.exit(exitCode);
+process.exitCode = exitCode;

package/vendor/component-manifest-catalog.js

@@ -0,0 +1,8 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  productionComponentManifestCatalog
+} from "./chunk-QIIKMG3M.js";
+import "./chunk-BTS4ZTF3.js";
+export {
+  productionComponentManifestCatalog
+};

package/vendor/control-plane.js

@@ -0,0 +1,23 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  isKoedServerCliEntrypoint,
+  runKoedServerCli,
+  shouldExitPackagedSupervisor
+} from "./chunk-GELDEJJ2.js";
+import {
+  startKoedServerDaemon
+} from "./chunk-JKOG52PE.js";
+import "./chunk-A4NKL2PK.js";
+import {
+  productionComponentManifestCatalog
+} from "./chunk-QIIKMG3M.js";
+import "./chunk-K2EIFEQF.js";
+import "./chunk-UI5RLBKQ.js";
+import "./chunk-BTS4ZTF3.js";
+export {
+  isKoedServerCliEntrypoint,
+  productionComponentManifestCatalog,
+  runKoedServerCli,
+  shouldExitPackagedSupervisor,
+  startKoedServerDaemon
+};

package/vendor/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/vendor/privacy-service-bootstrap.js

@@ -0,0 +1,6 @@
+import { pathToFileURL } from "node:url";
+const [entry, cacheDir] = process.argv.slice(2);
+if (!entry || !cacheDir)
+    throw new Error("Privacy Service bootstrap requires entry and cache directory");
+process.env.KOED_PRIVACY_TRANSFORMERS_CACHE = cacheDir;
+await import(pathToFileURL(entry).href);