@aipermission/mcp 0.2.56 → 0.2.58

package/README.md

@@ -41,6 +41,11 @@ configuration, and installs the native operator skill for the selected client.
 Generated runtime configs pin the exact package version that wrote them; re-run
 setup when you intentionally upgrade a client. Use `init` when you only want the
 MCP config, or `install-skill` when you only want the skill.
+VS Code `.vscode/mcp.json` may contain JSONC comments and trailing commas;
+setup updates only the selected server entry while keeping unrelated entries
+and comments. Setup validates the skill before writing the config, then installs
+it. If skill installation fails after the config is written, the error names
+that partial state so you can run `install-skill` separately.
 
 Check both paths without printing the bearer token:
 
@@ -91,6 +96,8 @@ integer; invalid configuration stops the bridge instead of silently changing
 the deadline. It covers both response headers and the complete response body,
 including streamed bodies. A timeout does not prove that a submitted
 operation failed; do not retry mutations with a new idempotency key blindly.
+Gateway response bodies are capped at 8 MiB. An oversized POST response is
+also treated as an unknown outcome, not proof that the operation failed.
 If a POST response is lost or incomplete, the bridge returns
 `status: outcome_unknown` and `code: gateway_transport_outcome_unknown`.
 Action calls also return the original `idempotency_key`; no request ID is

package/dist/init.js

@@ -11,6 +11,7 @@ import { parseCommandFlags } from "./cli-flags.js";
 import { DEFAULT_API_URL, normalizeLocalAPIURL } from "./local-url.js";
 import { adaptMCPServerConfig, getClient, MCP_PROVIDERS, resolveMCPConfigTarget, resolveMCPPrintTarget } from "./client-registry.js";
 import { commitSkillInstallation, prepareSkillInstallation } from "./install-skill.js";
+import { updateJSONCServer } from "./jsonc-config.js";
 import {
   atomicWritePrivateFile,
   privateLockPath,
@@ -50,12 +51,18 @@ async function runConfiguration(command, argv) {
   const flags = parseCommandFlags(command, argv);
   const interactive = Boolean(input.isTTY && output.isTTY);
   assertProviderSelectionAvailable(flags.provider, interactive);
-  const rl = readline.createInterface({ input, output });
+  let rl;
+  const getReadline = () => {
+    rl ||= readline.createInterface({ input, output });
+    return rl;
+  };
   try {
     const provider = flags.provider
       ? findProvider(flags.provider)
       : await selectProvider("Which AI client should use this token?", MCP_PROVIDERS);
-    const name = sanitizeName(flags.name || (interactive ? await ask(rl, "MCP server name", "aipermission") : "aipermission"));
+    const needsToken = provider.id !== "custom" && !flags.print;
+    const stdinToken = needsToken && flags.tokenStdin ? (await readStdin()).trim() : "";
+    const name = sanitizeName(flags.name || (interactive ? await ask(getReadline(), "MCP server name", "aipermission") : "aipermission"));
     const apiUrl = normalizeURL(flags.apiUrl || DEFAULT_API_URL);
     const outputTarget =
       provider.id === "custom"
@@ -75,19 +82,30 @@ async function runConfiguration(command, argv) {
       return { provider: provider.id, name, printed: true, skill: skillResult };
     }
 
-    const stdinToken = flags.tokenStdin ? (await readStdin()).trim() : "";
-    const token = await resolveToken({ ...flags, stdinToken }, rl);
+    const token = flags.tokenStdin ? stdinToken : await resolveToken(flags, getReadline());
     if (!token) {
       throw new Error("API token is required.");
     }
     const config = adaptMCPServerConfig(provider.id, buildMCPServerConfig({ apiUrl, token }));
-    const skillResult = preparedSkill ? await reportInstalledSkill(preparedSkill) : undefined;
     const result = await writeProviderConfig(provider.id, name, config, {
       force: Boolean(flags.force),
       scope: flags.scope,
       homeDir: flags.home,
       projectDir: flags.projectDir,
     });
+    let skillResult;
+    if (preparedSkill) {
+      try {
+        skillResult = await reportInstalledSkill(preparedSkill);
+      } catch (error) {
+        throw new Error(
+          `MCP config was written at ${result.path}, but operator skill installation failed. Complete the skill installation separately.`,
+          {
+            cause: error,
+          },
+        );
+      }
+    }
     console.log("");
     console.log(`${color.green}Configured ${provider.label}${color.reset}`);
     console.log(`${color.dim}Name:${color.reset} ${name}`);
@@ -103,7 +121,7 @@ async function runConfiguration(command, argv) {
     console.log(`${color.yellow}Restart the AI client so it reloads MCP servers.${color.reset}`);
     return { provider: provider.id, name, config: result, skill: skillResult };
   } finally {
-    rl.close();
+    rl?.close();
   }
 }
 
@@ -311,6 +329,7 @@ export async function writeProviderConfig(providerID, name, config, options = {}
   const trustedRoot = target.trustedRoot;
   const writeOptions = {
     trustedRoot,
+    jsonc: providerID === "vscode",
     beforeWrite: target.projectConfig
       ? async () => {
           await assertProjectConfigWritable(target.path, options);
@@ -332,27 +351,39 @@ export async function writeJSONMCPConfig(filePath, name, config, rootKey, option
     filePath,
     async () => {
       await options.beforeWrite?.();
-      let root = {};
+      let content = "";
       try {
-        root = JSON.parse(await fs.readFile(filePath, "utf8"));
+        content = await fs.readFile(filePath, "utf8");
       } catch (error) {
         if (error.code !== "ENOENT") {
-          redactParseError(error);
-          throw new Error(`Could not parse JSON config at ${filePath}; the existing file was left unchanged`, {
+          throw new Error(`Could not read JSON config at ${filePath}; the existing file was left unchanged`, {
             cause: error,
           });
         }
       }
-      if (!root || typeof root !== "object" || Array.isArray(root)) root = {};
-      const currentServers = root[rootKey];
-      const servers =
-        currentServers && typeof currentServers === "object" && !Array.isArray(currentServers)
-          ? { ...currentServers }
-          : Object.create(null);
-      Object.defineProperty(servers, name, { value: config, enumerable: true, configurable: true, writable: true });
-      root[rootKey] = servers;
+      let outputContent;
+      if (options.jsonc) {
+        outputContent = updateJSONCServer(content, rootKey, name, config);
+      } else {
+        let root;
+        try {
+          root = content ? JSON.parse(content) : {};
+        } catch (error) {
+          redactParseError(error);
+          throw new Error(`Could not parse JSON config at ${filePath}; the existing file was left unchanged`, { cause: error });
+        }
+        if (!root || typeof root !== "object" || Array.isArray(root)) root = {};
+        const currentServers = root[rootKey];
+        const servers =
+          currentServers && typeof currentServers === "object" && !Array.isArray(currentServers)
+            ? { ...currentServers }
+            : Object.create(null);
+        Object.defineProperty(servers, name, { value: config, enumerable: true, configurable: true, writable: true });
+        root[rootKey] = servers;
+        outputContent = `${JSON.stringify(root, null, 2)}\n`;
+      }
       await options.beforeWrite?.();
-      await writePrivateFile(filePath, `${JSON.stringify(root, null, 2)}\n`, options);
+      await writePrivateFile(filePath, outputContent, options);
     },
     options,
   );

package/dist/jsonc-config.js

@@ -0,0 +1,33 @@
+import { applyEdits, modify, parse } from "jsonc-parser";
+
+export function updateJSONCServer(content, rootKey, name, config) {
+  const source = content.trim() ? content : "{}\n";
+  const errors = [];
+  const root = parse(source, errors, { allowTrailingComma: true });
+  if (errors.length || !root || typeof root !== "object" || Array.isArray(root)) {
+    throw new Error("Could not parse VS Code JSONC config; the existing file was left unchanged.");
+  }
+  const servers = root[rootKey];
+  if (servers !== undefined && (!servers || typeof servers !== "object" || Array.isArray(servers))) {
+    throw new Error("VS Code MCP servers must be an object; the existing file was left unchanged.");
+  }
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  let next;
+  try {
+    next = applyEdits(
+      source,
+      modify(source, [rootKey, name], config, {
+        getInsertionIndex: () => 0,
+        formattingOptions: { insertSpaces: true, tabSize: 2, eol },
+      }),
+    );
+  } catch {
+    throw new Error("Could not safely update VS Code JSONC config; the existing file was left unchanged.");
+  }
+  const nextErrors = [];
+  const updated = parse(next, nextErrors, { allowTrailingComma: true });
+  if (nextErrors.length || JSON.stringify(updated?.[rootKey]?.[name]) !== JSON.stringify(config)) {
+    throw new Error("Could not safely update VS Code JSONC config; the existing file was left unchanged.");
+  }
+  return next;
+}

package/dist/response-body.js

@@ -0,0 +1,23 @@
+export const MAX_GATEWAY_RESPONSE_BYTES = 8 * 1024 * 1024;
+
+export async function readGatewayResponseText(response) {
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let received = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      received += value.byteLength;
+      if (received > MAX_GATEWAY_RESPONSE_BYTES) {
+        await reader.cancel();
+        throw new Error(`Gateway response exceeds ${MAX_GATEWAY_RESPONSE_BYTES} bytes.`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return new TextDecoder().decode(Buffer.concat(chunks, received));
+}

package/dist/server.js

@@ -18,6 +18,7 @@ import { idempotencyKeySchema } from "./idempotency-key.js";
 import { normalizeLocalAPIURL } from "./local-url.js";
 import { projectGatewaySuccess, responseContracts } from "./response-contracts.js";
 import { jsonActionToolResult, jsonToolResult } from "./results.js";
+import { readGatewayResponseText } from "./response-body.js";
 import { externalActionAnnotations, localMutationAnnotations, localReadAnnotations } from "./tool-annotations.js";
 
 const packageMetadata = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
@@ -266,7 +267,7 @@ async function apiRequest(path, options, idempotencyKey, context = {}) {
     }
     dispatchStarted = true;
     const response = await fetch(request, { signal: controller.signal });
-    const text = await response.text();
+    const text = await readGatewayResponseText(response);
     const data = response.status === 204 ? null : parseResponseBody(text);
     bodyReceived = true;
     if (!response.ok) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aipermission/mcp",
-  "version": "0.2.56",
+  "version": "0.2.58",
   "mcpName": "io.github.aipermission/aipermission-mcp",
   "description": "Local-only MCP bridge for the aipermission gateway.",
   "license": "AGPL-3.0-only",
@@ -50,6 +50,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
+    "jsonc-parser": "3.3.1",
     "smol-toml": "1.8.0",
     "yaml": "2.9.1",
     "zod": "3.25.76"

package/server.json

@@ -3,12 +3,12 @@
   "name": "io.github.aipermission/aipermission-mcp",
   "title": "AIPermission",
   "description": "Local-only MCP bridge for the AIPermission gateway.",
-  "version": "0.2.56",
+  "version": "0.2.58",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@aipermission/mcp",
-      "version": "0.2.56",
+      "version": "0.2.58",
       "transport": {
         "type": "stdio"
       }