agentschat-mcp 0.33.3 → 0.33.7

package/src/server.ts

@@ -42,6 +42,16 @@ import { normalizeTimestampForCursor } from "./timestamps.ts";
 import { validateToolArgs } from "./argcheck.ts";
 import { decideIdentity, shouldMigrateDevToken } from "./identity.ts";
 import type { ProfileSource } from "./identity.ts";
+import {
+  decideGrokBind,
+  parseGrokBindsText,
+  resolveGrokBindsPath,
+  DEFAULT_GROK_BINDS_FILENAME,
+  boundProfileForConversation,
+  gateSwitchProfile,
+  profileNameFromPath,
+  shouldHealBoundIdentity,
+} from "./grok-bind.ts";
 import { decideTermsConsent, TERMS_URL } from "./terms.ts";
 import { fireWake, fireGrokWake, resolveGrokAgentId, resolveGrokGatewayPath, grokBearerFromGatewayConfig, grokPortFromGatewayConfig } from "./wake.ts";
 import pkg from "../package.json";
@@ -107,6 +117,13 @@ Wake a host that has no channel-notification surface (Grok Bot, generic MCP clie
                            ~/.grok/gateway.json, /home/box/sand-data/gateway.json)
   AGENTCHAT_GROK_AGENT_ID  the Grok gateway agent uuid to wake (1:1 binding)
 
+Grok multi-bot identity bind (Cursor / Grok Bot, no --profile):
+  ~/.agentschat/grok-binds.json maps CURSOR_CONVERSATION_ID (Grok uuid) → profile name.
+  AGENTCHAT_GROK_BINDS overrides that path. Profile names resolve like --profile.
+  Auto-bind does NOT set AGENTCHAT_WAKE_MODE — a Cursor-tool MCP should unset it
+  (per-identity wake daemons already POST sendPrompt). If the operator set
+  WAKE_MODE, it is left as-is.
+
 Hermes relay connector (no Hermes patch): run with --connector. See --connector --help.
 
 Identity is never created implicitly: with no --name/--profile/AGENTSCHAT_PROFILE and
@@ -124,7 +141,9 @@ const cliArgs = parseArgs();
 //   2. AGENTCHAT_PROFILE env var (legacy singular)
 //   3. --profile <name> CLI arg
 //   4. --name <name> CLI arg (also used as profile name)
-//   5. default ~/.agentschat/profile.json, falling back to ~/.agentchat/profile.json
+//   5. Grok bind: CURSOR_CONVERSATION_ID → ~/.agentschat/grok-binds.json
+//      (skipped if an explicit token is set; does NOT imply AGENTCHAT_WAKE_MODE)
+//   6. default ~/.agentschat/profile.json, falling back to ~/.agentchat/profile.json
 const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
 const configDir = join(homeDir, ".agentschat");
 const legacyConfigDir = join(homeDir, ".agentchat");
@@ -148,6 +167,7 @@ function listProfileFiles(): Array<{ name: string; path: string }> {
     let files: string[] = [];
     try { files = readdirSync(dir).filter((f: string) => f.endsWith(".json")); } catch {}
     for (const file of files) {
+      if (file === DEFAULT_GROK_BINDS_FILENAME) continue; // bind map, not a profile
       const name = file.replace(/\.json$/, "");
       if (seen.has(name)) continue;
       seen.add(name);
@@ -168,7 +188,45 @@ function resolveProfile(): { path: string; source: ProfileSource; declaredName?:
   if (cliArgs.profile) return { path: nameToPath(cliArgs.profile), source: "flag-profile", declaredName: cliArgs.profile };
   // 4. --name <name>
   if (cliArgs.name) return { path: nameToPath(cliArgs.name), source: "flag-name", declaredName: cliArgs.name };
-  // 5. default — nothing was declared. NOT a licence to invent an identity.
+
+  // 5. Grok outbound bind. Explicit env/flags already returned above. An
+  // explicit --token/AGENTCHAT_TOKEN also wins: do not steal identity from
+  // operator-supplied creds. CURSOR_CONVERSATION_ID unset → skip entirely
+  // (Claude Code / Hermes: zero change). A hit with a missing profile file
+  // is a declared identity (source grok-bind) so decideIdentity hard-errors
+  // rather than falling through to a sibling bot.
+  const grokToken = !!(cliArgs.token || process.env.AGENTCHAT_TOKEN);
+  const conversationId = process.env.CURSOR_CONVERSATION_ID;
+  let binds: Record<string, string> = {};
+  if (!grokToken && conversationId) {
+    const bindPath = resolveGrokBindsPath(configDir, process.env.AGENTCHAT_GROK_BINDS);
+    if (existsSync(bindPath)) {
+      try {
+        const parsed = parseGrokBindsText(readFileSync(bindPath, "utf-8"));
+        binds = parsed.binds;
+        if (parsed.malformed) {
+          process.stderr.write(`[agentchat] WARNING: grok-binds file is malformed (${bindPath}); ignoring.\n`);
+        }
+      } catch {
+        binds = {};
+      }
+    }
+  }
+  const grok = decideGrokBind({
+    explicitIdentity: false,
+    hasToken: grokToken,
+    conversationId,
+    binds,
+  });
+  if (grok.kind === "hit") {
+    process.stderr.write(`[agentchat] grok-bind: ${grok.conversationId} → profile "${grok.profileName}"\n`);
+    return { path: nameToPath(grok.profileName), source: "grok-bind", declaredName: grok.profileName };
+  }
+  if (grok.kind === "miss") {
+    process.stderr.write(`[agentchat] no grok-bind matched CURSOR_CONVERSATION_ID=${grok.conversationId}\n`);
+  }
+
+  // 6. default — nothing was declared. NOT a licence to invent an identity.
   return { path: nameToPath("profile"), source: "default" };
 }
 
@@ -1938,6 +1996,75 @@ HANDLERS.set("transcribe", async (args) => {
   }
 });
 
+
+/** Reload grok-binds.json (or AGENTCHAT_GROK_BINDS) for runtime lock/heal checks. */
+function loadGrokBinds(): Record<string, string> {
+  const bindPath = resolveGrokBindsPath(configDir, process.env.AGENTCHAT_GROK_BINDS);
+  if (!existsSync(bindPath)) return {};
+  try {
+    return parseGrokBindsText(readFileSync(bindPath, "utf-8")).binds;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Apply a profile file as the live identity and reconnect WS.
+ * Shared by `switch_profile` and grok-bind heal.
+ */
+function applyIdentityFromProfile(newProfile: any, targetFile: string): void {
+  heartbeat.stop();
+  if (backfillTimer) { clearTimeout(backfillTimer); backfillTimer = null; }
+  if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+  if (ws) {
+    ws.onclose = null;
+    try { ws.close(); } catch {}
+    ws = null;
+  }
+  sessionId = null;
+  AGENT_ID = newProfile.agent_id;
+  TOKEN = newProfile.token || "dev-token";
+  CAPABILITIES = newProfile.capabilities || ["claude-code", "coding", "chat"];
+  profile = newProfile;
+  activeProfileFile = targetFile;
+  anonymousMode = false;
+  wsReconnectAttempt = 0;
+  heartbeat.start();
+  connectWS();
+}
+
+/**
+ * If CURSOR_CONVERSATION_ID is bound and live identity drifted (e.g. another
+ * agent called switch_profile on this shared MCP), force-reload the bound
+ * profile before outbound writes. Logs to stderr when healing.
+ */
+function ensureGrokBoundIdentity(): void {
+  const boundName = boundProfileForConversation(process.env.CURSOR_CONVERSATION_ID, loadGrokBinds());
+  if (!boundName) return;
+  const boundPath = nameToPath(boundName);
+  if (!existsSync(boundPath)) return;
+  let boundProfile: any;
+  try {
+    boundProfile = JSON.parse(readFileSync(boundPath, "utf-8"));
+  } catch {
+    return;
+  }
+  const liveName = profileNameFromPath(activeProfileFile);
+  if (!shouldHealBoundIdentity({
+    boundProfileName: boundName,
+    liveProfileName: liveName,
+    liveAgentId: AGENT_ID,
+    boundAgentId: boundProfile?.agent_id,
+  })) {
+    return;
+  }
+  process.stderr.write(
+    `[agentchat] grok-bind heal: live profile=${liveName ?? "?"} agent=${AGENT_ID || "?"} → bound "${boundName}" (${boundProfile.agent_id || "?"})\n`,
+  );
+  applyIdentityFromProfile(boundProfile, boundPath);
+}
+
+
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   let { name, arguments: args } = request.params;
   let viaExtendedCompat = false;
@@ -1954,6 +2081,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       if (argErr) return { content: [{ type: "text", text: `${name}: ${argErr}` }], isError: true };
     }
 
+    // Shared Cursor MCP: heal back to grok-bind identity if another agent
+    // stole the live profile via switch_profile. No-op when unbound.
+    ensureGrokBoundIdentity();
+
   if (name === "list_skills") {
     const { chat_id } = (args || {}) as { chat_id?: string };
     const out: any = {
@@ -3054,6 +3185,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       return { content: [{ type: "text", text: `Current: ${current}\nAvailable profiles:\n${list}` }] };
     }
 
+    // Shared Cursor MCP: grok-binds lock outbound identity — via conversation id
+    // when set, or via current profile when Cursor stdio started with --profile
+    // and no CURSOR_CONVERSATION_ID. Refuse switches that leave the locked
+    // identity (including other Grok bots or Hermes/Spiral). No-op allowed.
+    const switchGate = gateSwitchProfile({
+      conversationId: process.env.CURSOR_CONVERSATION_ID,
+      binds: loadGrokBinds(),
+      requestedProfileName: profile_name,
+      currentProfileName: profileNameFromPath(activeProfileFile),
+    });
+    if (switchGate.kind === "locked") {
+      return { content: [{ type: "text", text: switchGate.message }], isError: true };
+    }
+
     // Find and load the profile
     const targetFile = nameToPath(profile_name);
     if (!existsSync(targetFile)) {
@@ -3061,34 +3206,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 
     const newProfile = JSON.parse(readFileSync(targetFile, "utf-8"));
-
-    // Stop heartbeat first to prevent race with old connection
-    heartbeat.stop();
-    // Cancel any pending backfill / reconnect from the old identity.
-    if (backfillTimer) { clearTimeout(backfillTimer); backfillTimer = null; }
-    if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
-
-    // Close old connection, disable its reconnect handler
-    if (ws) {
-      ws.onclose = null;
-      try { ws.close(); } catch {}
-      ws = null;
-    }
-    sessionId = null;
-
-    // Update identity. activeProfileFile must move too — whoami reports it, and a
-    // stale value there makes the identity probe lie about which profile is live.
-    AGENT_ID = newProfile.agent_id;
-    TOKEN = newProfile.token || "dev-token";
-    CAPABILITIES = newProfile.capabilities || ["claude-code", "coding", "chat"];
-    profile = newProfile;
-    activeProfileFile = targetFile;
-    anonymousMode = false;
-
-    // Restart heartbeat and connect with new identity
-    wsReconnectAttempt = 0;
-    heartbeat.start();
-    connectWS();
+    applyIdentityFromProfile(newProfile, targetFile);
 
     return { content: [{ type: "text", text: `Switched to profile "${profile_name}" (${AGENT_ID}). Reconnecting...` }] };
   }