poe-code 3.0.273 → 3.0.275

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.273",
+  "version": "3.0.275",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

package/packages/agent-mcp-config/dist/apply.js

@@ -15,6 +15,32 @@ export class UnsupportedAgentError extends Error {
 function isConfigObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function assertNonEmptyString(value, message) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(message);
+    }
+}
+function assertHttpUrl(value) {
+    assertNonEmptyString(value, "MCP HTTP URL must be a valid http or https URL.");
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new Error("MCP HTTP URL must be a valid http or https URL.");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("MCP HTTP URL must be a valid http or https URL.");
+    }
+}
+function validateServerEntry(server) {
+    assertNonEmptyString(server.name, "MCP server name must be a non-empty string.");
+    if (server.config.transport === "stdio") {
+        assertNonEmptyString(server.config.command, "MCP stdio command must be a non-empty string.");
+        return;
+    }
+    assertHttpUrl(server.config.url);
+}
 function resolveServerMap(document, configKey) {
     const value = document[configKey];
     if (value === undefined) {
@@ -32,12 +58,15 @@ export async function configure(agentId, server, options) {
     if (!isSupported(agentId)) {
         throw new UnsupportedAgentError(agentId);
     }
+    validateServerEntry(server);
     const config = getAgentConfig(agentId);
     const configPath = resolveConfigPath(config, options.platform);
     const shapeTransformer = getShapeTransformer(config.shape);
     const shaped = shapeTransformer(server);
+    const enabledServer = { ...server, enabled: true };
+    const enabledShaped = shapeTransformer(enabledServer);
     if (shaped === undefined) {
-        await unconfigure(agentId, server.name, options);
+        await unconfigure(agentId, enabledServer, options);
         return;
     }
     const configDir = getConfigDirectory(configPath);
@@ -57,10 +86,13 @@ export async function configure(agentId, server, options) {
                     ? servers[server.name]
                     : undefined;
                 const shapedServer = shaped;
+                const enabledShapedServer = enabledShaped;
                 if (existingServer !== undefined && isDeepStrictEqual(existingServer, shapedServer)) {
                     return { changed: false, content: document };
                 }
-                if (existingServer !== undefined && server.enabled !== false) {
+                if (existingServer !== undefined &&
+                    (enabledShapedServer === undefined ||
+                        !isDeepStrictEqual(existingServer, enabledShapedServer))) {
                     throw new Error(`MCP server "${server.name}" already exists with different configuration in ${configPath}.`);
                 }
                 const newServers = {
@@ -98,7 +130,8 @@ export async function unconfigure(agentId, server, options) {
                 if (!Object.hasOwn(servers, serverName)) {
                     return { changed: false, content: document };
                 }
-                if (expectedServer !== undefined && !isDeepStrictEqual(servers[serverName], expectedServer)) {
+                if (expectedServer !== undefined &&
+                    !isDeepStrictEqual(servers[serverName], expectedServer)) {
                     return { changed: false, content: document };
                 }
                 const newServers = { ...servers };

package/packages/memory/dist/index.js

@@ -14185,12 +14185,28 @@ var DEFAULT_ENCODING = "cl100k_base";
 function createTokenizer(options = {}) {
   const encoding = options.encoding ?? DEFAULT_ENCODING;
   const tokenizer = get_encoding(encoding);
-  const utf8Decoder = new TextDecoder();
   const strictUtf8Decoder = new TextDecoder("utf-8", { fatal: true });
   const encode = (text4) => tokenizer.encode(text4);
+  const normalizeDecodeTokens = (tokens) => {
+    if (tokens instanceof Uint32Array) {
+      return tokens;
+    }
+    const tokenArray = new Uint32Array(tokens.length);
+    tokens.forEach((token, index) => {
+      if (!Number.isFinite(token) || !Number.isInteger(token) || token < 0 || token > 4294967295) {
+        throw new TypeError(`token id at index ${index} must be a finite non-negative integer.`);
+      }
+      tokenArray[index] = token;
+    });
+    return tokenArray;
+  };
   const decode = (tokens) => {
-    const tokenArray = tokens instanceof Uint32Array ? tokens : Uint32Array.from(tokens);
-    return utf8Decoder.decode(tokenizer.decode(tokenArray));
+    const tokenArray = normalizeDecodeTokens(tokens);
+    try {
+      return strictUtf8Decoder.decode(tokenizer.decode(tokenArray));
+    } catch {
+      throw new Error("Cannot decode tokens without corrupting UTF-8 text.");
+    }
   };
   const count = (text4) => encode(text4).length;
   const truncate2 = (text4, tokenCount) => {
@@ -16121,6 +16137,31 @@ var UnsupportedAgentError2 = class extends Error {
 function isConfigObject6(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function assertNonEmptyString(value, message2) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(message2);
+  }
+}
+function assertHttpUrl(value) {
+  assertNonEmptyString(value, "MCP HTTP URL must be a valid http or https URL.");
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new Error("MCP HTTP URL must be a valid http or https URL.");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("MCP HTTP URL must be a valid http or https URL.");
+  }
+}
+function validateServerEntry(server) {
+  assertNonEmptyString(server.name, "MCP server name must be a non-empty string.");
+  if (server.config.transport === "stdio") {
+    assertNonEmptyString(server.config.command, "MCP stdio command must be a non-empty string.");
+    return;
+  }
+  assertHttpUrl(server.config.url);
+}
 function resolveServerMap(document, configKey) {
   const value = document[configKey];
   if (value === void 0) {
@@ -16138,12 +16179,15 @@ async function configure2(agentId, server, options) {
   if (!isSupported(agentId)) {
     throw new UnsupportedAgentError2(agentId);
   }
+  validateServerEntry(server);
   const config2 = getAgentConfig3(agentId);
   const configPath = resolveConfigPath2(config2, options.platform);
   const shapeTransformer = getShapeTransformer(config2.shape);
   const shaped = shapeTransformer(server);
+  const enabledServer = { ...server, enabled: true };
+  const enabledShaped = shapeTransformer(enabledServer);
   if (shaped === void 0) {
-    await unconfigure2(agentId, server.name, options);
+    await unconfigure2(agentId, enabledServer, options);
     return;
   }
   const configDir = getConfigDirectory(configPath);
@@ -16162,10 +16206,11 @@ async function configure2(agentId, server, options) {
           const servers = resolveServerMap(document, config2.configKey);
           const existingServer = Object.hasOwn(servers, server.name) ? servers[server.name] : void 0;
           const shapedServer = shaped;
+          const enabledShapedServer = enabledShaped;
           if (existingServer !== void 0 && isDeepStrictEqual(existingServer, shapedServer)) {
             return { changed: false, content: document };
           }
-          if (existingServer !== void 0 && server.enabled !== false) {
+          if (existingServer !== void 0 && (enabledShapedServer === void 0 || !isDeepStrictEqual(existingServer, enabledShapedServer))) {
             throw new Error(
               `MCP server "${server.name}" already exists with different configuration in ${configPath}.`
             );