@kwonye/mcpx 0.1.105 → 0.1.106

package/dist/chunk-a2gen8bn.js

@@ -0,0 +1,730 @@
+import {
+  adoptionPlanSchema,
+  applyAdoption,
+  clearOAuthCredentials,
+  listHarnesses,
+  listOperations,
+  markInterruptedOperations,
+  mcpV2Headers,
+  mcpV2Meta,
+  operationEvents,
+  planAdoption,
+  probeOAuthSupport,
+  protectServerSecrets,
+  rollbackOperation,
+  saveOperation,
+  synchronizeClients
+} from "./chunk-wztmp5b4.js";
+import {
+  SecretsManager,
+  addServer,
+  registerProject,
+  removeServer,
+  setProjectServerEnabled,
+  setServerEnabled,
+  unregisterProject,
+  updateServer
+} from "./chunk-8v13hqrp.js";
+import {
+  mutateConfig
+} from "./chunk-hahs24dv.js";
+import {
+  processAlive
+} from "./chunk-chaj8a8b.js";
+import {
+  listSkills
+} from "./chunk-7rq88hb3.js";
+import {
+  loadConfig,
+  loadMergedConfig,
+  parseCliAddCommand
+} from "./chunk-brxwa30j.js";
+import {
+  exports_external
+} from "./chunk-p7yzyt87.js";
+import {
+  getConfigPath,
+  getRuntimeDir,
+  sha256
+} from "./chunk-grkz21sq.js";
+import {
+  __require
+} from "./chunk-wj4tjacg.js";
+
+// src/core/control.ts
+import fs from "node:fs";
+
+// src/core/runtime-snapshot.ts
+var committed;
+function freeze(value) {
+  if (value && typeof value === "object") {
+    for (const child of Object.values(value))
+      freeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+function compileRuntimeSnapshot() {
+  committed = freeze(structuredClone(loadMergedConfig()));
+}
+function clearRuntimeSnapshot() {
+  committed = undefined;
+}
+function runtimeConfig() {
+  return committed ?? loadMergedConfig();
+}
+
+// src/core/control.ts
+import path from "node:path";
+import os from "node:os";
+import http from "node:http";
+import crypto from "node:crypto";
+
+// src/core/auth-probe.ts
+var JSON_RPC_VERSION = "2.0";
+var DEFAULT_AUTH_PROBE_TIMEOUT_MS = 8000;
+var AUTH_KEYWORDS = [
+  "unauthorized",
+  "unauthenticated",
+  "forbidden",
+  "authentication",
+  "authorization",
+  "api key",
+  "api_key",
+  "apikey",
+  "credentials",
+  "access denied",
+  "auth required",
+  "x-api-key",
+  "invalid key",
+  "missing header",
+  "not authenticated",
+  "auth token"
+];
+function isAuthRelatedMessage(message) {
+  const lower = message.toLowerCase();
+  return AUTH_KEYWORDS.some((kw) => lower.includes(kw));
+}
+function resolveHeaders(spec, secrets) {
+  const headers = {
+    "content-type": "application/json",
+    accept: "application/json"
+  };
+  for (const [key, value] of Object.entries(spec.headers ?? {})) {
+    headers[key] = secrets.resolveMaybeSecret(value);
+  }
+  return headers;
+}
+function isOAuthLikelyChallenge(wwwAuthenticate) {
+  if (!wwwAuthenticate) {
+    return false;
+  }
+  const lower = wwwAuthenticate.toLowerCase();
+  return lower.includes("bearer") || lower.includes("authorization_uri") || lower.includes("resource_metadata");
+}
+async function probeHttpAuthRequirement(spec, secrets, timeoutMs = DEFAULT_AUTH_PROBE_TIMEOUT_MS, options = {}) {
+  const timeoutController = new AbortController;
+  const timeoutHandle = setTimeout(() => timeoutController.abort(), timeoutMs);
+  const discoverOAuth = options.discoverOAuth ?? true;
+  async function withOAuthSupport(result) {
+    if (!discoverOAuth) {
+      return result;
+    }
+    const support = await probeOAuthSupport(spec.url).catch(() => {
+      return;
+    });
+    return {
+      ...result,
+      oauthSupport: support?.support,
+      oauthLikely: result.oauthLikely || support?.support === "supported"
+    };
+  }
+  try {
+    const headers = mcpV2Headers("tools/list", resolveHeaders(spec, secrets));
+    const response = await fetch(spec.url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        jsonrpc: JSON_RPC_VERSION,
+        id: "mcpx-auth-probe",
+        method: "tools/list",
+        params: {
+          _meta: {
+            ...mcpV2Meta({ name: "mcpx-auth-probe", version: "2.0.0" })
+          }
+        }
+      }),
+      signal: timeoutController.signal
+    });
+    if (response.status === 401 || response.status === 403) {
+      const wwwAuthenticate = response.headers.get("www-authenticate");
+      return await withOAuthSupport({
+        authRequired: true,
+        oauthLikely: isOAuthLikelyChallenge(wwwAuthenticate),
+        status: response.status,
+        wwwAuthenticate: wwwAuthenticate ?? undefined
+      });
+    }
+    if (response.status === 200) {
+      try {
+        const body = await response.json();
+        const err = body?.error;
+        if (err && typeof err === "object" && !("result" in body)) {
+          const message = typeof err.message === "string" ? err.message : "";
+          if (message && isAuthRelatedMessage(message)) {
+            return await withOAuthSupport({
+              authRequired: true,
+              status: response.status,
+              error: `JSON-RPC error: ${message}`
+            });
+          }
+        }
+      } catch {}
+    }
+    return {
+      authRequired: false,
+      status: response.status
+    };
+  } catch (error) {
+    const isAbort = error.name === "AbortError";
+    return {
+      authRequired: false,
+      error: isAbort ? `Auth probe timed out after ${timeoutMs}ms.` : error.message
+    };
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+// src/core/management.ts
+var string = exports_external.string().min(1);
+var serverSchema = exports_external.discriminatedUnion("transport", [exports_external.object({ transport: exports_external.literal("http"), url: exports_external.url(), headers: exports_external.record(exports_external.string(), exports_external.string()).optional(), enabled: exports_external.boolean().optional(), scope: exports_external.string().optional() }), exports_external.object({ transport: exports_external.literal("stdio"), command: string, args: exports_external.array(exports_external.string()).optional(), env: exports_external.record(exports_external.string(), exports_external.string()).optional(), cwd: string.optional(), enabled: exports_external.boolean().optional(), scope: exports_external.string().optional() })]);
+async function syncManaged(targets) {
+  return synchronizeClients({ targetClients: targets });
+}
+async function managementCommand(method, raw) {
+  if (method === "status") {
+    const { buildStatusReport } = await import("./chunk-e96643mj.js");
+    const { loadManagedIndex } = await import("./chunk-xvqr1q9b.js");
+    return buildStatusReport(loadMergedConfig(), loadManagedIndex());
+  }
+  if (method === "auth.configure") {
+    const [input] = exports_external.tuple([exports_external.object({ serverName: string, headerName: string.optional(), envName: string.optional(), authValue: string, secretName: string.optional(), raw: exports_external.boolean().optional() })]).parse(raw);
+    const { resolveAuthTarget, defaultAuthSecretName, maybePrefixBearer, applyAuthReference } = await import("./chunk-ezk8txcy.js");
+    await mutateConfig((config) => {
+      const spec = config.servers[input.serverName];
+      if (!spec)
+        throw new Error("Unknown server");
+      const target = resolveAuthTarget(spec, input.headerName, input.envName);
+      const key = input.secretName ?? defaultAuthSecretName(input.serverName, target);
+      new SecretsManager().setSecret(key, maybePrefixBearer(target, input.authValue, input.raw ?? false));
+      applyAuthReference(spec, target, `secret://${key}`);
+    });
+    return { configured: true, sync: await syncManaged() };
+  }
+  if (method === "snapshot") {
+    const config = loadConfig();
+    return { revision: config.revision ?? 0, capturedAt: new Date().toISOString(), harnesses: listHarnesses(config), operations: listOperations(), servers: Object.entries(config.servers).map(([name, spec]) => ({ name, transport: spec.transport, enabled: spec.enabled !== false, scope: spec.scope })), skills: listSkills().map((skill) => ({ id: skill.id, source: skill.source, readOnly: skill.readOnly })), packages: Object.values(config.packages ?? {}), plugins: Object.values(config.plugins ?? {}).map((plugin) => ({ id: plugin.id, name: plugin.name, version: plugin.version, status: plugin.status, enabled: plugin.enabled })) };
+  }
+  if (method === "adoption.plan")
+    return planAdoption(exports_external.tuple([exports_external.array(string).optional()]).parse(raw)[0]);
+  if (method === "adoption.apply") {
+    const [plan, selected] = exports_external.tuple([adoptionPlanSchema, exports_external.array(string).optional()]).parse(raw);
+    return applyAdoption(plan, selected);
+  }
+  if (method === "operation.rollback")
+    return rollbackOperation(exports_external.tuple([exports_external.uuid()]).parse(raw)[0]);
+  if (method === "package.pin") {
+    const [id, pinned] = exports_external.tuple([string, exports_external.boolean()]).parse(raw);
+    await mutateConfig((config) => {
+      if (!config.packages?.[id])
+        throw new Error("Unknown native package");
+      config.packages[id].pinned = pinned;
+    });
+    return { id, pinned };
+  }
+  if (method === "harness.mode") {
+    const [id, mode] = exports_external.tuple([string, exports_external.enum(["observe", "selected", "automatic"])]).parse(raw);
+    if (!listHarnesses(loadConfig()).some((h) => h.id === id))
+      throw new Error("Unknown harness installation");
+    await mutateConfig((config) => {
+      config.harnesses ??= {};
+      config.harnesses[id] = { mode };
+    });
+    return { id, mode };
+  }
+  if (method === "sync")
+    return syncManaged(exports_external.tuple([exports_external.array(string).optional()]).parse(raw)[0]);
+  if (method === "server.add" || method === "server.update" || method === "server.command") {
+    const [name, spec, resolvedSecrets] = method === "server.command" ? (() => {
+      const [command] = exports_external.tuple([string]).parse(raw);
+      const parsed = parseCliAddCommand(command);
+      return [parsed.name, parsed.spec, undefined];
+    })() : exports_external.tuple([string, serverSchema, exports_external.record(exports_external.string(), exports_external.string()).optional()]).parse(raw);
+    const secrets = new SecretsManager;
+    for (const [key, value] of Object.entries(resolvedSecrets ?? {}))
+      secrets.setSecret(key, value);
+    const safe = protectServerSecrets(name, spec, secrets);
+    await mutateConfig((config) => {
+      if (method === "server.update")
+        updateServer(config, name, safe);
+      else
+        addServer(config, name, safe, true);
+    });
+    const summary = await syncManaged();
+    const probe = safe.transport === "http" ? await probeHttpAuthRequirement(safe, secrets) : undefined;
+    return { [method === "server.update" ? "updated" : "added"]: name, sync: summary, ...probe?.authRequired ? { authRequired: true, authStatus: probe.status, oauthLikely: probe.oauthLikely, oauthSupport: probe.oauthSupport } : {} };
+  }
+  if (method === "server.remove") {
+    const [name] = exports_external.tuple([string]).parse(raw);
+    await mutateConfig((config) => removeServer(config, name));
+    clearOAuthCredentials(name, new SecretsManager);
+    return { removed: name, sync: await syncManaged() };
+  }
+  if (method === "server.enabled") {
+    const [name, enabled] = exports_external.tuple([string, exports_external.boolean()]).parse(raw);
+    await mutateConfig((config) => setServerEnabled(config, name, enabled));
+    return { updated: name, enabled, sync: await syncManaged() };
+  }
+  if (method === "project.enabled") {
+    const [projectPath, name, enabled] = exports_external.tuple([string, string, exports_external.boolean()]).parse(raw);
+    const result = await mutateConfig((config) => setProjectServerEnabled(config, projectPath, name, enabled));
+    return { updated: name, enabled, ...result, sync: await syncManaged() };
+  }
+  if (method === "project.add" || method === "project.remove") {
+    const [projectPath, name] = exports_external.tuple([string, string.optional()]).parse(raw);
+    await mutateConfig((config) => method === "project.add" ? registerProject(config, projectPath, name) : unregisterProject(config, projectPath));
+    return { success: true, sync: await syncManaged() };
+  }
+  if (method.startsWith("skill.")) {
+    const skills = await import("./chunk-27mq4agf.js");
+    const action = method.slice(6);
+    const [id, value] = exports_external.tuple([string, string.optional()]).parse(raw);
+    let result;
+    switch (action) {
+      case "save":
+        skills.saveSkill(id, string.parse(value));
+        result = { id, success: true };
+        break;
+      case "delete":
+        skills.deleteSkill(id);
+        result = { id, success: true };
+        break;
+      case "install":
+        result = await skills.installSkillFromSource(id, value);
+        break;
+      case "customize":
+        result = skills.customizeSkill(id, value);
+        break;
+      case "pin":
+        skills.pinSkill(id);
+        result = { id, success: true };
+        break;
+      case "unpin":
+        skills.unpinSkill(id);
+        result = { id, success: true };
+        break;
+      case "update":
+        result = await skills.updateSkill(id);
+        break;
+      case "rollback":
+        result = skills.rollbackSkill(id);
+        break;
+      default:
+        throw new Error("Unknown skill operation");
+    }
+    const sync = await syncManaged();
+    return { ...result, sync };
+  }
+  if (method.startsWith("plugin.")) {
+    const plugins = await import("./chunk-v041118a.js");
+    const [name, extra, value, project] = exports_external.tuple([string.optional(), exports_external.unknown().optional(), exports_external.unknown().optional(), exports_external.unknown().optional()]).parse(raw);
+    const action = method.slice(7);
+    const options = exports_external.object({ name: string.optional(), enabled: exports_external.boolean().optional(), components: exports_external.record(exports_external.string(), exports_external.boolean()).optional(), approvals: exports_external.record(exports_external.string(), exports_external.boolean()).optional() });
+    switch (action) {
+      case "install":
+        return plugins.installPlugin(string.parse(name), options.optional().parse(extra));
+      case "prepare":
+        await plugins.preparePlugin(string.parse(name));
+        break;
+      case "update":
+        return plugins.updatePlugin(string.parse(name));
+      case "pin":
+        await plugins.pinPlugin(string.parse(name));
+        break;
+      case "unpin":
+        await plugins.unpinPlugin(string.parse(name));
+        break;
+      case "rollback":
+        return plugins.rollbackPlugin(string.parse(name));
+      case "uninstall":
+        await plugins.uninstallPlugin(string.parse(name), exports_external.object({ keepData: exports_external.boolean().optional() }).optional().parse(extra)?.keepData);
+        break;
+      case "enable":
+        await plugins.enablePlugin(string.parse(name));
+        break;
+      case "disable":
+        await plugins.disablePlugin(string.parse(name));
+        break;
+      case "approve":
+        await plugins.approvePluginComponent(string.parse(name), string.parse(extra));
+        break;
+      case "project":
+        await plugins.setPluginProjectOverride(string.parse(name), string.parse(extra), exports_external.object({ enabled: exports_external.boolean().optional(), components: exports_external.record(exports_external.string(), exports_external.boolean()).optional() }).parse(value));
+        break;
+      case "resetProject":
+        await plugins.resetPluginProjectOverride(string.parse(name), string.parse(extra));
+        break;
+      case "config":
+        await plugins.pluginConfigSet(string.parse(name), string.parse(extra), string.parse(value), string.optional().parse(project));
+        break;
+      case "sync":
+        await plugins.pluginSync();
+        break;
+      default:
+        throw new Error("Unknown plugin operation");
+    }
+    return { name, success: true };
+  }
+  if (method.startsWith("marketplace.")) {
+    const marketplaces = await import("./chunk-ew06e41w.js");
+    const [name, extra] = exports_external.tuple([string, exports_external.unknown().optional()]).parse(raw);
+    switch (method.slice(12)) {
+      case "add":
+        return marketplaces.addMarketplace(name, string.optional().parse(extra));
+      case "refresh":
+        return marketplaces.refreshMarketplaceWithPlugins(name);
+      case "remove":
+        await marketplaces.removeMarketplace(name);
+        return { name, success: true };
+      case "automatic":
+        return marketplaces.setMarketplaceAutoUpdate(name, exports_external.boolean().parse(extra));
+      case "install":
+        return marketplaces.installMarketplacePlugin(name);
+    }
+  }
+  if (method === "share.import") {
+    const [directory, options] = exports_external.tuple([string, exports_external.object({ locked: exports_external.boolean().optional(), dryRun: exports_external.boolean().optional(), inputs: exports_external.record(exports_external.string(), exports_external.string()).optional() }).optional()]).parse(raw);
+    const { importEnvironment } = await import("./chunk-h9kp47rp.js");
+    const result = await importEnvironment(directory, options);
+    if (!options?.dryRun)
+      await syncManaged();
+    return result;
+  }
+  throw new Error(`Unknown management method: ${method}`);
+}
+async function getManagementSnapshot() {
+  return managementCommand("snapshot", []);
+}
+
+// src/core/control.ts
+var CONTROL_VERSION = 1;
+function controlSocketPath() {
+  if (process.platform === "win32")
+    return `\\\\.\\pipe\\mcpx-${sha256(`${os.userInfo().username}:${getConfigPath()}`).slice(0, 20)}`;
+  const normal = path.join(getRuntimeDir(), "control.sock");
+  return Buffer.byteLength(normal) < 96 ? normal : path.join(os.tmpdir(), `mcpx-${process.getuid?.() ?? "user"}-${sha256(getConfigPath()).slice(0, 12)}.sock`);
+}
+function controlKey() {
+  const file = path.join(getRuntimeDir(), "control.key");
+  fs.mkdirSync(getRuntimeDir(), { recursive: true, mode: 448 });
+  if (!fs.existsSync(file)) {
+    try {
+      fs.writeFileSync(file, crypto.randomBytes(32).toString("base64url"), { mode: 384, flag: "wx" });
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+  }
+  return fs.readFileSync(file, "utf8").trim();
+}
+function authorized(value) {
+  const a = Buffer.from(value ?? ""), b = Buffer.from(`Bearer ${controlKey()}`);
+  return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+var requestSchema = exports_external.object({ version: exports_external.literal(1), method: exports_external.string(), args: exports_external.array(exports_external.unknown()).default([]) });
+var queue = Promise.resolve();
+var activeWriters = 0;
+function coordinate(work) {
+  const execute = async () => {
+    activeWriters++;
+    try {
+      return await work();
+    } finally {
+      try {
+        compileRuntimeSnapshot();
+      } finally {
+        activeWriters--;
+      }
+    }
+  };
+  const next = queue.then(execute, execute);
+  queue = next.catch(() => {
+    return;
+  });
+  return next;
+}
+async function startControlServer() {
+  const socketPath = controlSocketPath();
+  controlKey();
+  if (process.platform !== "win32" && fs.existsSync(socketPath)) {
+    if (!fs.lstatSync(socketPath).isSocket())
+      throw new Error("Control socket path is occupied by a non-socket file.");
+    try {
+      await controlRequest("snapshot");
+      throw new Error("Another mcpx control service is already running");
+    } catch (error) {
+      if (!["ENOENT", "ECONNREFUSED", "FailedToOpenSocket"].includes(error.code ?? ""))
+        throw error;
+    }
+    fs.unlinkSync(socketPath);
+  }
+  const clients = new Set;
+  const leases = new Map;
+  const server = http.createServer(async (request, response) => {
+    if (request.headers.origin || !authorized(request.headers.authorization)) {
+      response.writeHead(403);
+      response.end();
+      return;
+    }
+    if (request.url === "/v1/events" && request.method === "GET") {
+      response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache" });
+      response.write(`data: ${JSON.stringify({ type: "connected", version: CONTROL_VERSION })}
+
+`);
+      clients.add(response);
+      request.on("close", () => clients.delete(response));
+      return;
+    }
+    if (request.url !== "/v1/command" || request.method !== "POST") {
+      response.writeHead(404);
+      response.end();
+      return;
+    }
+    try {
+      let body = "";
+      for await (const chunk of request) {
+        body += chunk;
+        if (Buffer.byteLength(body) > 4 * 1024 * 1024)
+          throw new Error("Control request is too large");
+      }
+      const input = requestSchema.parse(JSON.parse(body));
+      if (input.method === "service.health") {
+        response.writeHead(200, { "content-type": "application/json" });
+        response.end(JSON.stringify({ result: { pid: process.pid, activeWriters } }));
+        return;
+      }
+      if (input.method === "lease.release") {
+        const [id, success] = exports_external.tuple([exports_external.uuid(), exports_external.boolean().optional()]).parse(input.args);
+        leases.get(id)?.(success);
+        leases.delete(id);
+        response.writeHead(200, { "content-type": "application/json" });
+        response.end(JSON.stringify({ result: true }));
+        return;
+      }
+      if (input.method === "lease.acquire") {
+        const [pid, label] = exports_external.tuple([exports_external.number().int().positive(), exports_external.string()]).parse(input.args);
+        const id = crypto.randomUUID();
+        let ready;
+        const started = new Promise((resolve) => {
+          ready = resolve;
+        });
+        coordinate(async () => {
+          const operation = { id, label: `CLI ${label}`, phase: "applying", progress: 0, startedAt: new Date().toISOString(), updatedAt: new Date().toISOString() };
+          saveOperation(operation);
+          let succeeded = true;
+          await new Promise((resolve) => {
+            const timer = setInterval(() => {
+              if (!processAlive(pid))
+                finish(false);
+            }, 1000);
+            const finish = (success = true) => {
+              succeeded = success;
+              clearInterval(timer);
+              leases.delete(id);
+              resolve();
+            };
+            leases.set(id, finish);
+            ready();
+          });
+          operation.phase = succeeded ? "complete" : "failed";
+          operation.progress = 1;
+          saveOperation(operation);
+        });
+        await started;
+        response.writeHead(200, { "content-type": "application/json" });
+        response.end(JSON.stringify({ result: id }));
+        return;
+      }
+      const work = async () => {
+        return managementCommand(input.method, input.args);
+      };
+      const result = input.method === "snapshot" ? await work() : await coordinate(async () => {
+        if (input.method === "adoption.plan")
+          return work();
+        const operation = { id: crypto.randomUUID(), label: input.method, phase: "applying", progress: 0, startedAt: new Date().toISOString(), updatedAt: new Date().toISOString() };
+        saveOperation(operation);
+        try {
+          const result2 = await work();
+          const outcome = exports_external.object({ hasErrors: exports_external.boolean().optional(), sync: exports_external.object({ hasErrors: exports_external.boolean() }).optional() }).safeParse(result2);
+          const failed = outcome.success && (outcome.data.hasErrors || outcome.data.sync?.hasErrors);
+          operation.phase = failed ? "failed" : "complete";
+          operation.progress = 1;
+          if (failed)
+            operation.message = "The integration was saved, but synchronization needs attention. Review the affected harness diagnostics and retry sync.";
+          saveOperation(operation);
+          return result2;
+        } catch (error) {
+          operation.phase = "failed";
+          operation.message = "Operation failed. Review the affected integration and retry.";
+          saveOperation(operation);
+          throw error;
+        }
+      });
+      response.writeHead(200, { "content-type": "application/json" });
+      response.end(JSON.stringify({ version: CONTROL_VERSION, result }));
+    } catch (error) {
+      response.writeHead(400, { "content-type": "application/json" });
+      response.end(JSON.stringify({ error: error instanceof exports_external.ZodError || error instanceof SyntaxError ? "Invalid management input" : error.message }));
+    }
+  });
+  const notify = (operation) => {
+    for (const client of clients)
+      client.write(`data: ${JSON.stringify({ type: "operation", operation })}
+
+`);
+  };
+  operationEvents.on("change", notify);
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => {
+      server.removeListener("error", reject);
+      if (process.platform !== "win32")
+        fs.chmodSync(socketPath, 384);
+      resolve();
+    });
+  });
+  markInterruptedOperations();
+  compileRuntimeSnapshot();
+  let reconciling = false;
+  let observedPlan = "";
+  const reconcile = setInterval(() => {
+    if (reconciling)
+      return;
+    reconciling = true;
+    coordinate(async () => {
+      if (listOperations().some((operation) => operation.phase === "recovery-required"))
+        return;
+      const config = loadConfig();
+      const targets = Object.entries(config.harnesses ?? {}).filter(([, settings]) => settings.mode === "automatic").map(([id]) => id);
+      if (!targets.length)
+        return;
+      const plan = planAdoption(targets);
+      const fingerprint = sha256(JSON.stringify(plan.items));
+      if (fingerprint === observedPlan)
+        return;
+      observedPlan = fingerprint;
+      const safe = plan.items.filter((item) => item.action === "import" || item.action === "reuse");
+      if (safe.length)
+        await applyAdoption(plan, safe.map((item) => item.id));
+    }).catch(() => {
+      const time = new Date().toISOString();
+      saveOperation({ id: crypto.randomUUID(), label: "Automatic adoption", phase: "failed", startedAt: time, updatedAt: time, progress: 0, message: "An installation could not be adopted. Scan existing installs to review its configuration." });
+    }).finally(() => {
+      reconciling = false;
+    });
+  }, 3000);
+  reconcile.unref();
+  return async () => {
+    clearInterval(reconcile);
+    clearRuntimeSnapshot();
+    operationEvents.off("change", notify);
+    for (const client of clients)
+      client.end();
+    await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  };
+}
+function controlRequest(method, args = []) {
+  return new Promise((resolve, reject) => {
+    const supplied = [...args];
+    while (supplied.length && supplied.at(-1) === undefined)
+      supplied.pop();
+    const body = JSON.stringify({ version: CONTROL_VERSION, method, args: supplied });
+    const request = http.request({ socketPath: controlSocketPath(), path: "/v1/command", method: "POST", headers: { authorization: `Bearer ${controlKey()}`, "content-type": "application/json", "content-length": Buffer.byteLength(body) } }, (response) => {
+      let data = "";
+      response.on("data", (chunk) => {
+        data += chunk;
+      });
+      response.on("end", () => {
+        try {
+          const parsed = JSON.parse(data);
+          if (response.statusCode !== 200)
+            reject(new Error(parsed.error ?? "Management request failed"));
+          else
+            resolve(parsed.result);
+        } catch {
+          reject(new Error("Invalid management response"));
+        }
+      });
+    });
+    request.on("error", reject);
+    request.end(body);
+  });
+}
+async function ensureControlService(cliPath) {
+  try {
+    await controlRequest("snapshot");
+    return;
+  } catch (error) {
+    if (!["ENOENT", "ECONNREFUSED", "FailedToOpenSocket"].includes(error.code ?? ""))
+      throw error;
+  }
+  const { startDaemon } = await import("./chunk-4xym942z.js");
+  await startDaemon(loadConfig(), cliPath, new SecretsManager);
+  for (let attempt = 0;attempt < 50; attempt++) {
+    try {
+      await controlRequest("snapshot");
+      return;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  throw new Error("mcpx control service did not become ready");
+}
+function subscribeControlEvents(listener, onError) {
+  let closed = false;
+  const request = http.get({ socketPath: controlSocketPath(), path: "/v1/events", headers: { authorization: `Bearer ${controlKey()}` } }, (response) => {
+    response.on("end", () => {
+      if (!closed)
+        onError?.(new Error("Local service disconnected"));
+    });
+    let pending = "";
+    response.on("data", (chunk) => {
+      pending += chunk;
+      let boundary;
+      while ((boundary = pending.indexOf(`
+
+`)) >= 0) {
+        const event = pending.slice(0, boundary);
+        pending = pending.slice(boundary + 2);
+        if (event.startsWith("data: ")) {
+          try {
+            listener(JSON.parse(event.slice(6)));
+          } catch {}
+        }
+      }
+    });
+  });
+  request.on("error", (error) => {
+    if (!closed)
+      onError?.(error);
+  });
+  return () => {
+    closed = true;
+    request.destroy();
+  };
+}
+
+export { runtimeConfig, probeHttpAuthRequirement, getManagementSnapshot, CONTROL_VERSION, controlSocketPath, coordinate, startControlServer, controlRequest, ensureControlService, subscribeControlEvents };
+
+//# debugId=32A461FC6536AB7664756E2164756E21