ainecto 0.12.1 → 0.13.0

package/dist/bin/mcp.js

@@ -58,7 +58,28 @@ function assertEnv(value) {
 
 // src/core/auth/tokenStore.ts
 import { createHash } from "crypto";
-import { mkdir, readFile, rename, rm, stat, writeFile, chmod } from "fs/promises";
+import { mkdir as mkdir2, readFile, rename, rm, stat as stat2, writeFile, chmod as chmod2 } from "fs/promises";
+
+// src/core/fs/privateFiles.ts
+import { chmod, lstat, mkdir, stat } from "fs/promises";
+function isNodeError(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+async function chmodIfPermissive(path, mode) {
+  try {
+    const result = await stat(path);
+    if ((result.mode & 63) !== 0) {
+      await chmod(path, mode);
+    }
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) {
+      return;
+    }
+    throw error;
+  }
+}
+
+// src/core/auth/tokenStore.ts
 import { homedir } from "os";
 import { dirname, join } from "path";
 var FileTokenStore = class {
@@ -97,14 +118,14 @@ var FileTokenStore = class {
     }
   }
   async writeFile(file) {
-    await mkdir(dirname(this.filePath), { recursive: true, mode: 448 });
-    await chmod(dirname(this.filePath), 448);
+    await mkdir2(dirname(this.filePath), { recursive: true, mode: 448 });
+    await chmod2(dirname(this.filePath), 448);
     const tmpPath = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
     await writeFile(tmpPath, `${JSON.stringify(file, null, 2)}
 `, { mode: 384 });
-    await chmod(tmpPath, 384);
+    await chmod2(tmpPath, 384);
     await rename(tmpPath, this.filePath);
-    await chmod(this.filePath, 384);
+    await chmod2(this.filePath, 384);
   }
   async hardenExistingPermissions() {
     const dirPath = dirname(this.filePath);
@@ -115,22 +136,6 @@ var FileTokenStore = class {
 function tokenKey(endpoint) {
   return createHash("sha256").update(endpoint).digest("hex");
 }
-function isNodeError(error, code) {
-  return error instanceof Error && "code" in error && error.code === code;
-}
-async function chmodIfPermissive(path, mode) {
-  try {
-    const result = await stat(path);
-    if ((result.mode & 63) !== 0) {
-      await chmod(path, mode);
-    }
-  } catch (error) {
-    if (isNodeError(error, "ENOENT")) {
-      return;
-    }
-    throw error;
-  }
-}
 
 // src/core/auth/oauth.ts
 import { createHash as createHash2, randomBytes } from "crypto";
@@ -214,7 +219,7 @@ function legacyRoleInput(flag, envVars = process.env) {
 }
 
 // src/core/version.ts
-var CLI_VERSION = true ? "0.12.1" : UNBUNDLED_VERSION;
+var CLI_VERSION = true ? "0.13.0" : UNBUNDLED_VERSION;
 var PACKAGE_NAME = "@ainecto/mcp";
 var CLI_USER_AGENT = `${PACKAGE_NAME} ${CLI_VERSION}`;
 
@@ -288,7 +293,7 @@ var McpRpcClient = class {
         const details = rateLimitDetails(void 0, response.error.data);
         throw new RateLimitedError(rateLimitMessage(`MCP ${method}`, details), details);
       }
-      throw new McpRpcError(response.error.message, "MCP_ERROR", response.error);
+      throw new McpRpcError(describeRpcError(response.error), "MCP_ERROR", response.error);
     }
     return response.result;
   }
@@ -309,6 +314,10 @@ var McpRpcClient = class {
       return rateLimitedResponse(text, response.headers.get("retry-after"));
     }
     if (!response.ok) {
+      const envelope = rpcErrorEnvelope(text);
+      if (envelope) {
+        return envelope;
+      }
       const serverError = parseServerError(text);
       throw new McpRpcError(
         `MCP HTTP request failed with HTTP ${response.status}${serverError ? ` \u2014 ${describeServerError(serverError)}` : "."}`,
@@ -352,23 +361,39 @@ var McpRpcClient = class {
   }
 };
 function rateLimitedResponse(text, retryAfter) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    parsed = void 0;
-  }
-  if (isJsonRpcResponse(parsed) && "error" in parsed) {
-    const data = isRecord3(parsed.error.data) ? parsed.error.data : {};
+  const envelope = rpcErrorEnvelope(text);
+  if (envelope) {
+    const data = isRecord3(envelope.error.data) ? envelope.error.data : {};
     const seconds = parseRetryAfter(retryAfter);
     if (data.retryAfterSeconds === void 0 && seconds !== void 0) {
-      parsed.error.data = { ...data, retryAfterSeconds: seconds };
+      envelope.error.data = { ...data, retryAfterSeconds: seconds };
     }
-    return parsed;
+    return envelope;
   }
-  const details = rateLimitDetails(retryAfter, parsed);
+  const details = rateLimitDetails(retryAfter, parseJsonOrUndefined(text));
   throw new RateLimitedError(rateLimitMessage("MCP HTTP request", details), details);
 }
+function rpcErrorEnvelope(text) {
+  const parsed = parseJsonOrUndefined(text);
+  return isJsonRpcResponse(parsed) && "error" in parsed && isRecord3(parsed.error) ? parsed : void 0;
+}
+function parseJsonOrUndefined(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function describeRpcError(error) {
+  const data = isRecord3(error.data) ? error.data : {};
+  const messages = isRecord3(data.messages) ? data.messages : {};
+  const sentence = [error.message, data.message, messages.en, messages.ko].find((value) => typeof value === "string" && value.trim() !== "");
+  const code = typeof data.code === "string" && data.code.trim() ? data.code.trim() : void 0;
+  if (!code) {
+    return sentence ?? `JSON-RPC error ${error.code}`;
+  }
+  return describeServerError({ error: code, description: sentence });
+}
 function agentHeaderValue(clientName) {
   return printableHeaderValue(clientName);
 }
@@ -898,12 +923,12 @@ signed-in user's AiNecto permissions decide what they may change, and the server
 ${MARKER_END}`;
 
 // src/core/harness/repositoryFiles.ts
-import { lstat, readFile as readFile2, realpath } from "fs/promises";
+import { lstat as lstat2, readFile as readFile2, realpath } from "fs/promises";
 import { dirname as dirname2, join as join2, resolve, sep } from "path";
 async function findGitRoot(cwd) {
   for (let at = resolve(cwd); ; at = dirname2(at)) {
     try {
-      await lstat(join2(at, ".git"));
+      await lstat2(join2(at, ".git"));
       return at;
     } catch {
     }
@@ -944,7 +969,7 @@ async function assertInsideRepository(root, relativePath) {
     );
   }
   try {
-    if ((await lstat(absolutePath)).isSymbolicLink()) {
+    if ((await lstat2(absolutePath)).isSymbolicLink()) {
       throw new Error(`${relativePath} is a symbolic link; refusing to write through it.`);
     }
   } catch (error) {