@xiaou66/vite-plugin-vue-mcp-next 1.3.0 → 1.3.2

package/README.md

@@ -528,7 +528,7 @@ interface ConsoleRecord {
   source: 'cdp' | 'hook'
   level: 'log' | 'info' | 'warn' | 'error' | 'debug'
   message: string
-  args?: unknown[]
+  args?: string[]
   stack?: string
   timestamp: number
 }

package/dist/index.cjs

@@ -2699,25 +2699,141 @@ function createServerVueRuntimeRpc(ctx) {
 var import_nanoid4 = require("nanoid");
 
 // src/shared/serialization.ts
+var RPC_CIRCULAR_VALUE = "[Circular]";
+var RPC_UNREADABLE_VALUE = "[Unreadable]";
+function toRpcSafeValue(value) {
+  return toRpcSafeChildValue(value, /* @__PURE__ */ new WeakSet(), false);
+}
 function safeStringify(value) {
   if (typeof value === "string") {
     return value;
   }
-  const seen = /* @__PURE__ */ new WeakSet();
-  const serialized = JSON.stringify(
-    value,
-    (_key, current) => {
-      if (typeof current !== "object" || current === null) {
-        return current;
-      }
-      if (seen.has(current)) {
-        return "[Circular]";
-      }
-      seen.add(current);
-      return current;
+  const safeValue = toRpcSafeValue(value);
+  return safeValue === void 0 ? "undefined" : JSON.stringify(safeValue);
+}
+function toRpcSafeChildValue(value, seen, arrayItem) {
+  if (value === null) {
+    return null;
+  }
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return value;
+    case "number":
+      return Number.isFinite(value) ? value : String(value);
+    case "bigint":
+      return value.toString();
+    case "symbol":
+      return toSymbolPlaceholder(value);
+    case "undefined":
+    case "function":
+      return arrayItem ? null : void 0;
+    case "object":
+      return toRpcSafeObject(value, seen);
+    default:
+      return arrayItem ? null : void 0;
+  }
+}
+function toRpcSafeObject(value, seen) {
+  if (seen.has(value)) {
+    return RPC_CIRCULAR_VALUE;
+  }
+  seen.add(value);
+  try {
+    if (value instanceof Date) {
+      return toSafeDate(value);
     }
-  );
-  return serialized;
+    if (value instanceof Error) {
+      return toSafeError(value, seen);
+    }
+    if (Array.isArray(value)) {
+      return toSafeArray(value, seen);
+    }
+    return toSafeRecord(value, seen);
+  } finally {
+    seen.delete(value);
+  }
+}
+function toSafeArray(values, seen) {
+  return values.map((item) => toRpcSafeChildValue(item, seen, true) ?? null);
+}
+function toSafeRecord(value, seen) {
+  const keys = getEnumerableKeys(value);
+  if (!keys) {
+    return RPC_UNREADABLE_VALUE;
+  }
+  if (keys.length === 0 && !isPlainRecord3(value)) {
+    return toObjectSummary(value);
+  }
+  const result = {};
+  keys.forEach((key) => {
+    if (key === "toJSON") {
+      return;
+    }
+    const field = readObjectField(value, key);
+    if (!field.ok) {
+      result[key] = RPC_UNREADABLE_VALUE;
+      return;
+    }
+    const safeValue = toRpcSafeChildValue(field.value, seen, false);
+    if (safeValue !== void 0) {
+      result[key] = safeValue;
+    }
+  });
+  return result;
+}
+function toSafeError(error, seen) {
+  const result = {
+    name: error.name,
+    message: error.message
+  };
+  const stack = readObjectField(error, "stack");
+  if (stack.ok && typeof stack.value === "string") {
+    result.stack = stack.value;
+  }
+  if ("cause" in error) {
+    const cause = readObjectField(error, "cause");
+    result.cause = cause.ok ? toRpcSafeChildValue(cause.value, seen, false) ?? null : RPC_UNREADABLE_VALUE;
+  }
+  return result;
+}
+function toSafeDate(value) {
+  return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+}
+function getEnumerableKeys(value) {
+  try {
+    return Object.keys(value);
+  } catch {
+    return void 0;
+  }
+}
+function readObjectField(value, key) {
+  try {
+    return {
+      ok: true,
+      value: value[key]
+    };
+  } catch {
+    return { ok: false };
+  }
+}
+function isPlainRecord3(value) {
+  try {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  } catch {
+    return false;
+  }
+}
+function toObjectSummary(value) {
+  try {
+    return Object.prototype.toString.call(value);
+  } catch {
+    return "[Object]";
+  }
+}
+function toSymbolPlaceholder(value) {
+  return value.description ? `[Symbol(${value.description})]` : "[Symbol]";
 }
 
 // src/cdp/cdpConsole.ts
@@ -3272,11 +3388,11 @@ var import_node_path7 = __toESM(require("path"), 1);
 async function updateJsonMcpClientConfig(options) {
   try {
     const config = await readJsonConfig(options.configPath);
-    if (!isPlainRecord3(config)) {
+    if (!isPlainRecord4(config)) {
       warnConfigFailure(options, "config root must be a JSON object");
       return;
     }
-    const mcpServers = isPlainRecord3(config.mcpServers) ? config.mcpServers : {};
+    const mcpServers = isPlainRecord4(config.mcpServers) ? config.mcpServers : {};
     if (Object.hasOwn(mcpServers, options.serverName)) {
       return;
     }
@@ -3329,7 +3445,7 @@ async function readOptionalTextFile2(filePath) {
     throw error;
   }
 }
-function isPlainRecord3(value) {
+function isPlainRecord4(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function warnConfigFailure(options, reason) {