@kwonye/mcpx 0.1.105 → 0.1.107

package/dist/chunk-r1aebtwm.js

@@ -0,0 +1,36 @@
+import {
+  buildDaemonChildEnv,
+  getDaemonStatus,
+  readDaemonLogs,
+  resolveGatewayPort,
+  restartDaemon,
+  runDaemonForeground,
+  startDaemon,
+  stopDaemon
+} from "./chunk-5r4vs8ct.js";
+import"./chunk-mztnw25b.js";
+import"./chunk-naeqpnmf.js";
+import"./chunk-2qbt2pxv.js";
+import"./chunk-f7w0a9nn.js";
+import"./chunk-qg1rbk0d.js";
+import"./chunk-z4j5q2x0.js";
+import"./chunk-131c6axh.js";
+import"./chunk-jncje8g1.js";
+import"./chunk-9bjabsqb.js";
+import"./chunk-rbra8ws6.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-vnka4jbe.js";
+import"./chunk-bjw71y54.js";
+import"./chunk-wj4tjacg.js";
+export {
+  buildDaemonChildEnv,
+  getDaemonStatus,
+  readDaemonLogs,
+  resolveGatewayPort,
+  restartDaemon,
+  runDaemonForeground,
+  startDaemon,
+  stopDaemon
+};
+
+//# debugId=7E85224A0D63747064756E2164756E21

package/dist/{chunk-01s7rhx3.js → chunk-rbra8ws6.js}

@@ -1,15 +1,17 @@
+import {
+  exports_external
+} from "./chunk-p7yzyt87.js";
 import {
   findProjectConfigPath,
   getConfigPath,
   readJsonFile,
   writeJsonAtomic
-} from "./chunk-4y0t0tfj.js";
+} from "./chunk-vnka4jbe.js";
 import {
   normalizeServerSpecEnabled
 } from "./chunk-bjw71y54.js";
 
 // src/core/config.ts
-import { z } from "zod";
 import path from "node:path";
 import fs from "node:fs";
 
@@ -321,7 +323,7 @@ function isHttpUrl2(value) {
   }
 }
 function isClientInternalCommand(command) {
-  return /\.app\/Contents\//.test(command);
+  return /\.app\/Contents\//.test(command) && !/mcpx(?:-dev)?\.app\/Contents\//.test(command);
 }
 function repairServerSpec(spec) {
   if (spec.transport !== "stdio") {
@@ -428,130 +430,140 @@ class ConfigLoadError extends Error {
     this.issues = issues;
   }
 }
-var clientStateSchema = z.object({
-  status: z.enum(["SYNCED", "UNSUPPORTED_HTTP", "ERROR", "SKIPPED"]),
-  lastSyncAt: z.string().optional(),
-  message: z.string().optional(),
-  configPath: z.string().optional()
+var clientStateSchema = exports_external.object({
+  status: exports_external.enum(["SYNCED", "UNSUPPORTED_HTTP", "ERROR", "SKIPPED"]),
+  lastSyncAt: exports_external.string().optional(),
+  message: exports_external.string().optional(),
+  configPath: exports_external.string().optional()
 });
-var httpServerSchema = z.object({
-  transport: z.literal("http"),
-  url: z.url(),
-  headers: z.record(z.string(), z.string()).optional(),
-  enabled: z.boolean().default(true)
+var httpServerSchema = exports_external.object({
+  scope: exports_external.string().optional(),
+  transport: exports_external.literal("http"),
+  url: exports_external.url(),
+  headers: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+  enabled: exports_external.boolean().default(true)
 });
-var stdioServerSchema = z.object({
-  transport: z.literal("stdio"),
-  command: z.string().min(1),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  cwd: z.string().min(1).optional(),
-  enabled: z.boolean().default(true)
+var stdioServerSchema = exports_external.object({
+  scope: exports_external.string().optional(),
+  transport: exports_external.literal("stdio"),
+  command: exports_external.string().min(1),
+  args: exports_external.array(exports_external.string()).optional(),
+  env: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+  cwd: exports_external.string().min(1).optional(),
+  enabled: exports_external.boolean().default(true)
 });
-var serverSchema = z.discriminatedUnion("transport", [httpServerSchema, stdioServerSchema]);
-var projectEntrySchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  disabledServers: z.array(z.string()).default([])
+var serverSchema = exports_external.discriminatedUnion("transport", [httpServerSchema, stdioServerSchema]);
+var projectEntrySchema = exports_external.object({
+  name: exports_external.string(),
+  path: exports_external.string(),
+  disabledServers: exports_external.array(exports_external.string()).default([])
 });
-var pluginComponentSchema = z.enum(["mcpServers", "skills", "hooks", "agents", "commands"]);
-var discoveredComponentSchema = z.object({
-  id: z.string(),
+var pluginComponentSchema = exports_external.enum(["mcpServers", "skills", "hooks", "agents", "commands"]);
+var discoveredComponentSchema = exports_external.object({
+  id: exports_external.string(),
   type: pluginComponentSchema,
-  path: z.string(),
-  description: z.string().optional()
+  path: exports_external.string(),
+  description: exports_external.string().optional()
 });
-var discoveredMcpServerSchema = z.object({
-  id: z.string(),
-  transport: z.enum(["stdio", "http"]).optional(),
-  command: z.string(),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).optional(),
-  cwd: z.string().optional(),
-  url: z.string().optional(),
-  oauthResource: z.string().optional()
+var discoveredMcpServerSchema = exports_external.object({
+  id: exports_external.string(),
+  transport: exports_external.enum(["stdio", "http"]).optional(),
+  command: exports_external.string(),
+  args: exports_external.array(exports_external.string()).optional(),
+  env: exports_external.record(exports_external.string(), exports_external.string()).optional(),
+  cwd: exports_external.string().optional(),
+  url: exports_external.string().optional(),
+  oauthResource: exports_external.string().optional()
 });
-var discoveredComponentsSchema = z.object({
-  skills: z.array(discoveredComponentSchema).default([]),
-  commands: z.array(discoveredComponentSchema).default([]),
-  agents: z.array(discoveredComponentSchema).default([]),
-  hooks: z.array(discoveredComponentSchema).default([]),
-  mcpServers: z.array(discoveredMcpServerSchema).default([])
+var discoveredComponentsSchema = exports_external.object({
+  skills: exports_external.array(discoveredComponentSchema).default([]),
+  commands: exports_external.array(discoveredComponentSchema).default([]),
+  agents: exports_external.array(discoveredComponentSchema).default([]),
+  hooks: exports_external.array(discoveredComponentSchema).default([]),
+  mcpServers: exports_external.array(discoveredMcpServerSchema).default([])
 });
-var managedPluginSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  source: z.string(),
-  version: z.string(),
-  ref: z.string(),
-  resolvedSha: z.string(),
-  installedAt: z.string(),
-  root: z.string(),
-  dataDir: z.string(),
-  components: z.record(pluginComponentSchema, z.boolean()).default({}),
+var managedPluginSchema = exports_external.object({
+  id: exports_external.string(),
+  name: exports_external.string(),
+  source: exports_external.string(),
+  version: exports_external.string(),
+  ref: exports_external.string(),
+  resolvedSha: exports_external.string(),
+  installedAt: exports_external.string(),
+  root: exports_external.string(),
+  dataDir: exports_external.string(),
+  components: exports_external.record(pluginComponentSchema, exports_external.boolean()).default({}),
   discovered: discoveredComponentsSchema.default({}),
-  enabled: z.boolean().default(true),
-  status: z.enum(["healthy", "unhealthy", "preparing", "updating", "error"]).default("healthy"),
-  error: z.string().optional(),
-  serverNames: z.array(z.string()).default([]),
-  projectedClients: z.array(z.string()).default([]),
-  approvals: z.object({
-    mcpServers: z.boolean().optional(),
-    skills: z.boolean().optional(),
-    hooks: z.boolean().optional(),
-    agents: z.boolean().optional(),
-    commands: z.boolean().optional()
+  enabled: exports_external.boolean().default(true),
+  status: exports_external.enum(["healthy", "unhealthy", "preparing", "updating", "error"]).default("healthy"),
+  error: exports_external.string().optional(),
+  serverNames: exports_external.array(exports_external.string()).default([]),
+  projectedClients: exports_external.array(exports_external.string()).default([]),
+  approvals: exports_external.object({
+    mcpServers: exports_external.boolean().optional(),
+    skills: exports_external.boolean().optional(),
+    hooks: exports_external.boolean().optional(),
+    agents: exports_external.boolean().optional(),
+    commands: exports_external.boolean().optional()
   }).optional(),
-  marketplace: z.object({
-    name: z.string(),
-    pluginName: z.string(),
-    sourceFingerprint: z.string()
+  marketplace: exports_external.object({
+    name: exports_external.string(),
+    pluginName: exports_external.string(),
+    sourceFingerprint: exports_external.string()
   }).optional(),
-  updateError: z.string().optional(),
-  pinned: z.boolean().default(false),
-  previous: z.object({ version: z.string(), resolvedSha: z.string(), root: z.string() }).optional(),
-  projectOverrides: z.record(z.string(), z.object({
-    enabled: z.boolean().optional(),
-    components: z.record(pluginComponentSchema, z.boolean()).optional(),
-    config: z.record(z.string(), z.unknown()).optional()
+  updateError: exports_external.string().optional(),
+  pinned: exports_external.boolean().default(false),
+  previous: exports_external.object({ version: exports_external.string(), resolvedSha: exports_external.string(), root: exports_external.string() }).optional(),
+  projectOverrides: exports_external.record(exports_external.string(), exports_external.object({
+    enabled: exports_external.boolean().optional(),
+    components: exports_external.partialRecord(pluginComponentSchema, exports_external.boolean()).optional(),
+    config: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
   })).optional()
 });
-var managedMarketplaceSchema = z.object({
-  name: z.string(),
-  displayName: z.string(),
-  source: z.string(),
-  sourceType: z.enum(["github", "git", "local", "hosted-json"]).default("github"),
-  manifestPath: z.string().optional(),
-  format: z.enum(["claude", "codex"]).optional(),
-  builtIn: z.boolean().default(false),
-  autoUpdate: z.boolean().default(false),
-  addedAt: z.string(),
-  lastCheckedAt: z.string().optional(),
-  lastUpdatedAt: z.string().optional(),
-  resolvedRevision: z.string().optional(),
-  status: z.enum(["ready", "stale", "error", "unavailable"]).default("unavailable"),
-  error: z.string().optional()
+var managedMarketplaceSchema = exports_external.object({
+  name: exports_external.string(),
+  displayName: exports_external.string(),
+  source: exports_external.string(),
+  sourceType: exports_external.enum(["github", "git", "local", "hosted-json"]).default("github"),
+  manifestPath: exports_external.string().optional(),
+  format: exports_external.enum(["claude", "codex"]).optional(),
+  builtIn: exports_external.boolean().default(false),
+  autoUpdate: exports_external.boolean().default(false),
+  addedAt: exports_external.string(),
+  lastCheckedAt: exports_external.string().optional(),
+  lastUpdatedAt: exports_external.string().optional(),
+  resolvedRevision: exports_external.string().optional(),
+  status: exports_external.enum(["ready", "stale", "error", "unavailable"]).default("unavailable"),
+  error: exports_external.string().optional()
 });
-var configSchema = z.object({
-  schemaVersion: z.literal(1).default(1),
-  gateway: z.object({
-    port: z.number().int().min(1).max(65535).default(37373),
-    tokenRef: z.string().default("secret://local_gateway_token"),
-    autoStart: z.boolean().default(true)
+var configSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1).default(1),
+  consumers: exports_external.record(exports_external.string(), exports_external.object({ tokenRef: exports_external.string().regex(/^secret:\/\/[A-Za-z0-9._-]+$/), projectPath: exports_external.string().optional() })).default({}),
+  packages: exports_external.record(exports_external.string(), exports_external.object({ id: exports_external.string(), root: exports_external.string(), source: exports_external.string(), harness: exports_external.string(), fingerprint: exports_external.string(), pinned: exports_external.boolean(), name: exports_external.string().optional(), identity: exports_external.string().optional(), servers: exports_external.array(exports_external.string()).optional(), skills: exports_external.array(exports_external.object({ id: exports_external.string(), path: exports_external.string(), projectionPath: exports_external.string() })).optional(), scope: exports_external.string().optional(), previous: exports_external.object({ root: exports_external.string(), fingerprint: exports_external.string() }).optional() })).default({}),
+  revision: exports_external.number().int().nonnegative().default(0),
+  harnesses: exports_external.record(exports_external.string(), exports_external.object({ mode: exports_external.enum(["observe", "selected", "automatic"]) })).default({}),
+  origins: exports_external.record(exports_external.string(), exports_external.object({ id: exports_external.string(), kind: exports_external.string(), harness: exports_external.string(), source: exports_external.string(), nativeKey: exports_external.string(), fingerprint: exports_external.string(), operationId: exports_external.string() })).default({}),
+  gateway: exports_external.object({
+    port: exports_external.number().int().min(1).max(65535).default(37373),
+    tokenRef: exports_external.string().regex(/^secret:\/\/[A-Za-z0-9._-]+$/).default("secret://local_gateway_token"),
+    autoStart: exports_external.boolean().default(true)
   }).default({
     port: 37373,
     tokenRef: "secret://local_gateway_token",
     autoStart: true
   }),
-  servers: z.record(z.string(), serverSchema).default({}),
-  clients: z.record(z.string(), clientStateSchema).default({}),
-  projects: z.record(z.string(), projectEntrySchema).default({}),
-  plugins: z.record(z.string(), managedPluginSchema).default({}),
-  marketplaces: z.record(z.string(), managedMarketplaceSchema).default({})
+  servers: exports_external.record(exports_external.string(), serverSchema).default({}),
+  clients: exports_external.record(exports_external.string(), clientStateSchema).default({}),
+  projects: exports_external.record(exports_external.string(), projectEntrySchema).default({}),
+  plugins: exports_external.record(exports_external.string(), managedPluginSchema).default({}),
+  marketplaces: exports_external.record(exports_external.string(), managedMarketplaceSchema).default({}),
+  secrets: exports_external.object({
+    backend: exports_external.enum(["file", "keychain"]).default("file")
+  }).default({ backend: "file" })
 });
-var projectConfigSchema = z.object({
-  name: z.string().min(1).optional(),
-  servers: z.record(z.string(), serverSchema).default({})
+var projectConfigSchema = exports_external.object({
+  name: exports_external.string().min(1).optional(),
+  servers: exports_external.record(exports_external.string(), serverSchema).default({})
 });
 function defaultConfig() {
   return {
@@ -565,7 +577,8 @@ function defaultConfig() {
     clients: {},
     projects: {},
     plugins: {},
-    marketplaces: ensureDefaultMarketplaces(undefined)
+    marketplaces: ensureDefaultMarketplaces(undefined),
+    secrets: { backend: "file" }
   };
 }
 function loadConfig(configPath = getConfigPath()) {
@@ -596,19 +609,23 @@ function loadConfig(configPath = getConfigPath()) {
   }
   const clientEntries = {};
   for (const [key, value] of Object.entries(parsed.data.clients)) {
-    if (["claude", "claude-desktop", "codex", "cursor", "cline", "opencode", "kiro", "vscode", "qwen", "openclaw", "hermes"].includes(key)) {
-      clientEntries[key] = value;
-    }
+    clientEntries[key] = value;
   }
   const servers = Object.fromEntries(Object.entries(parsed.data.servers).map(([name, spec]) => [name, normalizeServerSpecEnabled(spec)]));
   return repairConfig({
     schemaVersion: 1,
+    consumers: parsed.data.consumers,
+    packages: parsed.data.packages,
+    revision: parsed.data.revision,
+    harnesses: parsed.data.harnesses,
+    origins: parsed.data.origins,
     gateway: parsed.data.gateway,
     servers,
     clients: clientEntries,
     projects: parsed.data.projects,
     plugins: parsed.data.plugins,
-    marketplaces: ensureDefaultMarketplaces(parsed.data.marketplaces)
+    marketplaces: ensureDefaultMarketplaces(parsed.data.marketplaces),
+    secrets: parsed.data.secrets
   });
 }
 function saveConfig(config, configPath = getConfigPath()) {
@@ -737,4 +754,4 @@ function resolveActiveConfig(options = {}) {
 
 export { tokenizeCommandLine, parseCliAddCommand, ConfigLoadError, defaultConfig, loadConfig, saveConfig, loadProjectConfig, saveProjectConfig, loadMergedConfig, migrateProjectServers, resolveActiveConfig };
 
-//# debugId=5F19AEF9E1E9E38564756E2164756E21
+//# debugId=E2636B557C478E8864756E2164756E21

package/dist/{chunk-91vcwk5m.js → chunk-v14bg5yp.js}

@@ -1,6 +1,6 @@
 import {
   require_src
-} from "./chunk-tnhekcpv.js";
+} from "./chunk-56z18csx.js";
 import {
   __commonJS
 } from "./chunk-wj4tjacg.js";

package/dist/{chunk-4y0t0tfj.js → chunk-vnka4jbe.js}

@@ -126,18 +126,54 @@ function readJsonFile(filePath, fallback) {
     return fallback;
   }
 }
+function fsyncBestEffort(descriptor) {
+  try {
+    fs2.fsyncSync(descriptor);
+  } catch (error) {
+    const code = error.code;
+    if (code === "EPERM" || code === "EINVAL" || code === "ENOTSUP")
+      return;
+    throw error;
+  }
+}
 function writeJsonAtomic(filePath, data) {
   fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   const content = `${JSON.stringify(data, null, 2)}
 `;
-  fs2.writeFileSync(tempPath, content, { mode: 384 });
+  const descriptor = fs2.openSync(tempPath, "w", 384);
+  try {
+    fs2.writeFileSync(descriptor, content);
+    fsyncBestEffort(descriptor);
+  } finally {
+    fs2.closeSync(descriptor);
+  }
   fs2.renameSync(tempPath, filePath);
+  if (process.platform !== "win32") {
+    const directory = fs2.openSync(path2.dirname(filePath), "r");
+    try {
+      fsyncBestEffort(directory);
+    } finally {
+      fs2.closeSync(directory);
+    }
+  }
 }
 function sha256(value) {
   return crypto2.createHash("sha256").update(value).digest("hex");
 }
+function readJsonStrict(filePath, fallback) {
+  if (!fs2.existsSync(filePath))
+    return fallback;
+  try {
+    const value = JSON.parse(fs2.readFileSync(filePath, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw new Error("Expected an object");
+    return value;
+  } catch {
+    throw new Error(`Native configuration is invalid JSON: ${filePath}`);
+  }
+}
 
-export { homeDir, getConfigPath, getTelemetryPath, getSkillsDir, getSkillPackagesRoot, getSkillStatePath, getManagedIndexPath, getSecretsStorePath, getSecretsKeyPath, getPidPath, getLogPath, getGatewayTokenPath, getUpdatesDir, getStagedVersionPath, getUpdateLockPath, getOAuthLockPath, getPluginCacheRoot, getPluginDataRoot, getMarketplaceCacheRoot, getMarketplaceUpdateStatePath, getMarketplaceUpdateLockPath, ensureDir, ensureParentDir, findProjectConfigPath, readJsonFile, writeJsonAtomic, sha256 };
+export { homeDir, getConfigRoot, getDataRoot, getStateRoot, getConfigPath, getTelemetryPath, getSkillsDir, getSkillPackagesRoot, getSkillStatePath, getManagedIndexPath, getSecretsStorePath, getSecretsKeyPath, getRuntimeDir, getPidPath, getLogPath, getGatewayTokenPath, getUpdatesDir, getStagedVersionPath, getUpdateLockPath, getOAuthLockPath, getPluginCacheRoot, getPluginDataRoot, getMarketplaceCacheRoot, getMarketplaceUpdateStatePath, getMarketplaceUpdateLockPath, ensureDir, ensureParentDir, findProjectConfigPath, readJsonFile, writeJsonAtomic, sha256, readJsonStrict };
 
-//# debugId=BCB55F79AB94B71A64756E2164756E21
+//# debugId=4649C9BC7E52DA8164756E2164756E21

package/dist/chunk-z4j5q2x0.js

@@ -0,0 +1,30 @@
+import {
+  getManagedIndexPath,
+  readJsonFile,
+  writeJsonAtomic
+} from "./chunk-vnka4jbe.js";
+
+// src/core/managed-index.ts
+function defaultManagedIndex() {
+  return {
+    schemaVersion: 1,
+    managed: {}
+  };
+}
+function loadManagedIndex(filePath = getManagedIndexPath()) {
+  const raw = readJsonFile(filePath, defaultManagedIndex());
+  if (!raw || typeof raw !== "object") {
+    return defaultManagedIndex();
+  }
+  if (raw.schemaVersion !== 1) {
+    return defaultManagedIndex();
+  }
+  return raw;
+}
+function saveManagedIndex(index, filePath = getManagedIndexPath()) {
+  writeJsonAtomic(filePath, index);
+}
+
+export { defaultManagedIndex, loadManagedIndex, saveManagedIndex };
+
+//# debugId=3E2C9A4BFDB1663764756E2164756E21

package/dist/chunk-z7ykm4da.js

@@ -0,0 +1,138 @@
+import {
+  listAuthBindings,
+  secretRefName
+} from "./chunk-0xt563m1.js";
+import {
+  getDaemonStatus
+} from "./chunk-5r4vs8ct.js";
+import {
+  getAdapters,
+  getGatewayInternalUrl,
+  getGatewayUrl,
+  installationAdapters
+} from "./chunk-f7w0a9nn.js";
+import {
+  SecretsManager,
+  ensureGatewayToken
+} from "./chunk-qg1rbk0d.js";
+import {
+  isServerEnabled
+} from "./chunk-bjw71y54.js";
+
+// src/core/status.ts
+var STATUS_CLIENTS = getAdapters().map((adapter) => adapter.id);
+function describeServerTarget(spec) {
+  if (spec.transport === "http") {
+    return spec.url;
+  }
+  const args = (spec.args ?? []).join(" ");
+  const command = `${spec.command}${args ? ` ${args}` : ""}`;
+  return spec.cwd ? `${command} (cwd: ${spec.cwd})` : command;
+}
+function deriveClientStatus(managed, configured) {
+  if (configured) {
+    return configured;
+  }
+  return managed ? "SYNCED" : "SKIPPED";
+}
+function buildClientMappings(config, managedIndex, serverName) {
+  return installationAdapters(config).map(({ adapter }) => {
+    const clientId = adapter.id;
+    const configState = config.clients[clientId];
+    const managedClient = managedIndex.managed[clientId];
+    const managedEntry = managedClient?.entries?.[adapter.managedName?.(serverName) ?? `${serverName} (mcpx)`];
+    const managed = Boolean(managedEntry);
+    return {
+      clientId,
+      managed,
+      status: deriveClientStatus(managed, configState?.status),
+      configPath: managedClient?.configPath ?? configState?.configPath,
+      message: configState?.message,
+      lastSyncAt: managedEntry?.lastSyncedAt ?? configState?.lastSyncAt
+    };
+  });
+}
+function buildAuthBindings(spec) {
+  return listAuthBindings(spec).map((binding) => ({
+    kind: binding.kind,
+    key: binding.key,
+    value: binding.value,
+    secretName: secretRefName(binding.value) ?? undefined
+  }));
+}
+async function fetchTokenCounts(gatewayUrl, token) {
+  try {
+    const res = await fetch(gatewayUrl, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`
+      },
+      signal: AbortSignal.timeout(65000)
+    });
+    if (!res.ok) {
+      return { counts: {}, fetchError: `HTTP ${res.status}` };
+    }
+    const data = await res.json();
+    return { counts: data?.counts ?? {} };
+  } catch (error) {
+    return { counts: {}, fetchError: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function buildStatusReport(config, managedIndex, daemon = getDaemonStatus(config)) {
+  const secrets = new SecretsManager;
+  const token = ensureGatewayToken(config, secrets);
+  const gatewayUrl = getGatewayUrl(config);
+  let tokenCounts = {};
+  let tokenCountFetchError;
+  if (daemon.running) {
+    const result = await fetchTokenCounts(getGatewayInternalUrl(config, "/internal/token-counts"), token);
+    tokenCounts = result.counts;
+    tokenCountFetchError = result.fetchError;
+  }
+  const projectEntries = Object.values(config.projects ?? {});
+  let totalGlobalTokens = 0;
+  const totalProjectTokens = {};
+  const serverNames = Object.keys(config.servers).sort((left, right) => left.localeCompare(right));
+  const servers = serverNames.map((name) => {
+    const spec = config.servers[name];
+    let tokenCount = tokenCounts[name];
+    if (tokenCount?.error && buildAuthBindings(spec).length > 0 && tokenCount.total > 0) {
+      tokenCount = { ...tokenCount, error: undefined };
+    }
+    const health = tokenCount ? tokenCount.error || tokenCount.runtimeError ? "error" : "ok" : "unknown";
+    const serverEntry = {
+      name,
+      enabled: isServerEnabled(spec),
+      transport: spec.transport,
+      target: describeServerTarget(spec),
+      authBindings: buildAuthBindings(spec),
+      clients: buildClientMappings(config, managedIndex, name),
+      tokenCount,
+      health
+    };
+    if (serverEntry.enabled && tokenCount) {
+      totalGlobalTokens += tokenCount.total;
+      for (const projectEntry of projectEntries) {
+        if (!(projectEntry.disabledServers ?? []).includes(name)) {
+          totalProjectTokens[projectEntry.path] = (totalProjectTokens[projectEntry.path] ?? 0) + tokenCount.total;
+        }
+      }
+    }
+    return serverEntry;
+  });
+  return {
+    gatewayUrl,
+    fetchError: tokenCountFetchError,
+    daemon,
+    upstreamCount: servers.length,
+    servers,
+    clients: config.clients,
+    projects: config.projects,
+    totalGlobalTokens,
+    totalProjectTokens
+  };
+}
+
+export { STATUS_CLIENTS, buildStatusReport };
+
+//# debugId=5813D4CDEF97EC7C64756E2164756E21

package/dist/{chunk-d2v9rxy0.js → chunk-zmf014br.js}

@@ -11,11 +11,17 @@ import {
   resolveMarketplacePluginSource,
   setMarketplaceAutoUpdate,
   updateMarketplaceInstalledPlugin
-} from "./chunk-btbww96n.js";
-import"./chunk-56whm3hm.js";
-import"./chunk-01s7rhx3.js";
-import"./chunk-fw8dyt89.js";
-import"./chunk-4y0t0tfj.js";
+} from "./chunk-mztnw25b.js";
+import"./chunk-naeqpnmf.js";
+import"./chunk-f7w0a9nn.js";
+import"./chunk-qg1rbk0d.js";
+import"./chunk-z4j5q2x0.js";
+import"./chunk-131c6axh.js";
+import"./chunk-jncje8g1.js";
+import"./chunk-9bjabsqb.js";
+import"./chunk-rbra8ws6.js";
+import"./chunk-p7yzyt87.js";
+import"./chunk-vnka4jbe.js";
 import"./chunk-bjw71y54.js";
 import"./chunk-wj4tjacg.js";
 export {
@@ -33,4 +39,4 @@ export {
   updateMarketplaceInstalledPlugin
 };
 
-//# debugId=AB01773EEA66F21764756E2164756E21
+//# debugId=76A638EA438F529364756E2164756E21