@remixhq/mcp 0.1.18 → 0.1.20

package/dist/index.js

@@ -251,6 +251,15 @@ function normalizeByMessage(err) {
       category: "remote_state"
     });
   }
+  if (statusCode === 409) {
+    return makeNormalized({
+      code: ERROR_CODES.REMOTE_ERROR,
+      message,
+      hint,
+      retryable: true,
+      category: "remote_state"
+    });
+  }
   if (message.includes("Timed out") || message.includes("failed") || message.includes("error state")) {
     return makeNormalized({
       code: ERROR_CODES.REMOTE_ERROR,
@@ -427,7 +436,6 @@ function makeSuccessResult(envelope) {
 function makeErrorResult(envelope) {
   return {
     content: [{ type: "text", text: toJsonText(envelope) }],
-    structuredContent: envelope,
     isError: true
   };
 }
@@ -1711,13 +1719,34 @@ async function accessDebug(params) {
 
 // src/tools/collab/autoSpawnHistoryImport.ts
 import { spawn } from "child_process";
-import { existsSync, mkdirSync, openSync } from "fs";
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import os from "os";
 import path2 from "path";
-var MARKER_REL_PATH = path2.join(".remix", ".history-imported");
-var LOG_REL_PATH = path2.join(".remix", "history-import.log");
-function shouldAutoSpawnHistoryImport(repoRoot) {
+var LEGACY_MARKER_REL_PATH = path2.join(".remix", ".history-imported");
+function collabStateRoot() {
+  const configured = process.env.REMIX_COLLAB_STATE_ROOT?.trim();
+  return configured || path2.join(os.homedir(), ".remix", "collab-state");
+}
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function autoSpawnMarkerPath(repoRoot, repoFingerprint) {
+  const identityKey = typeof repoFingerprint === "string" && repoFingerprint.trim() ? `repoFingerprint:${repoFingerprint.trim()}` : `repoRoot:${repoRoot}`;
+  return path2.join(collabStateRoot(), "history-import", sha256Hex(identityKey), "history-imported.json");
+}
+function fallbackRepoRootMarkerPath(repoRoot) {
+  return autoSpawnMarkerPath(repoRoot, null);
+}
+function legacyLocalRepoRootMarkerPath(repoRoot) {
+  return path2.join(collabStateRoot(), "history-import", sha256Hex(repoRoot), "history-imported.json");
+}
+function legacyAutoSpawnMarkerPath(repoRoot) {
+  return path2.join(repoRoot, LEGACY_MARKER_REL_PATH);
+}
+function shouldAutoSpawnHistoryImport(repoRoot, repoFingerprint) {
   try {
-    return !existsSync(path2.join(repoRoot, MARKER_REL_PATH));
+    return !existsSync(autoSpawnMarkerPath(repoRoot, repoFingerprint)) && !existsSync(fallbackRepoRootMarkerPath(repoRoot)) && !existsSync(legacyLocalRepoRootMarkerPath(repoRoot)) && !existsSync(legacyAutoSpawnMarkerPath(repoRoot));
   } catch {
     return false;
   }
@@ -1726,14 +1755,6 @@ function isAutoSpawnEligibleBindingMode(bindingMode) {
   return bindingMode === "explicit_root";
 }
 function spawnHistoryImportDetached(repoRoot, options) {
-  const remixDir = path2.join(repoRoot, ".remix");
-  try {
-    mkdirSync(remixDir, { recursive: true });
-  } catch {
-  }
-  const logPath = path2.join(repoRoot, LOG_REL_PATH);
-  const out = openSync(logPath, "a");
-  const err = openSync(logPath, "a");
   const child = spawn(
     "remix",
     [
@@ -1750,12 +1771,12 @@ function spawnHistoryImportDetached(repoRoot, options) {
     ],
     {
       detached: true,
-      stdio: ["ignore", out, err],
+      stdio: "ignore",
       env: { ...process.env, REMIX_HISTORY_AUTO_SPAWN: "1" }
     }
   );
   child.unref();
-  return { pid: child.pid, logPath };
+  return { pid: child.pid };
 }
 
 // src/tools/collab/register.ts
@@ -1812,6 +1833,24 @@ function buildErrorEnvelope(tool, requestId, error) {
     recommendedNextActions
   };
 }
+function buildOutputValidationErrorEnvelope(tool, requestId, error) {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    ok: false,
+    tool,
+    requestId: requestId ?? null,
+    error: {
+      code: ERROR_CODES.INTERNAL_ERROR,
+      message: "Tool output failed validation against its declared MCP schema.",
+      hint: error.issues.map((issue) => `${issue.path.join(".") || "output"}: ${issue.message}`).join("; "),
+      retryable: false,
+      category: "internal"
+    },
+    warnings: [],
+    risks: ["The MCP server returned an output shape that did not match the tool descriptor."],
+    recommendedNextActions: ["Report this MCP schema mismatch with the tool name and error hint."]
+  };
+}
 function registerTool(server, context, params) {
   const errorSchema = makeErrorSchema();
   server.registerTool(
@@ -1830,7 +1869,20 @@ function registerTool(server, context, params) {
         assertToolAccess(context.policy, params.access);
         const result = await params.run(rawArgs);
         const envelope = buildSuccessEnvelope(params.name, requestId, result);
-        params.outputSchema.parse(envelope);
+        const parsedEnvelope = params.outputSchema.safeParse(envelope);
+        if (!parsedEnvelope.success) {
+          const errorEnvelope = buildOutputValidationErrorEnvelope(params.name, requestId, parsedEnvelope.error);
+          context.logger.log({
+            level: "error",
+            message: "tool_output_validation_failed",
+            tool: params.name,
+            requestId: errorEnvelope.requestId,
+            durationMs: Date.now() - startedAt,
+            result: "error",
+            errorCode: errorEnvelope.error.code
+          });
+          return makeErrorResult(errorEnvelope);
+        }
         context.logger.log({
           level: "info",
           message: "tool_completed",
@@ -1894,12 +1946,14 @@ function registerCollabTools(server, context) {
       try {
         const repoRoot = result && typeof result === "object" && "data" in result && result.data && typeof result.data.repoRoot === "string" ? result.data.repoRoot : null;
         const bindingMode = result && typeof result === "object" && "data" in result && result.data && typeof result.data.bindingMode === "string" ? result.data.bindingMode : null;
-        if (repoRoot && isAutoSpawnEligibleBindingMode(bindingMode) && shouldAutoSpawnHistoryImport(repoRoot)) {
+        const resultData = result && typeof result === "object" && "data" in result && result.data && typeof result.data === "object" ? result.data : null;
+        const repoFingerprint = typeof resultData?.repoFingerprint === "string" ? resultData.repoFingerprint : null;
+        if (repoRoot && isAutoSpawnEligibleBindingMode(bindingMode) && shouldAutoSpawnHistoryImport(repoRoot, repoFingerprint)) {
           const cutoffAt = (/* @__PURE__ */ new Date()).toISOString();
           const spawned = spawnHistoryImportDetached(repoRoot, { cutoffAt });
           context.logger.log({
             level: "info",
-            message: `history_import_auto_spawned pid=${spawned.pid ?? "?"} log=${spawned.logPath} cutoffAt=${cutoffAt}`,
+            message: `history_import_auto_spawned pid=${spawned.pid ?? "?"} cutoffAt=${cutoffAt}`,
             tool: "remix_collab_init",
             repoRoot
           });