squad-openclaw 2026.2.2203 → 2026.2.2206

package/README.md

@@ -135,6 +135,13 @@ echo '{"claimToken":"<token>"}' > ~/.openclaw/squad-ceo-data/relay/squad-relay.j
 
 The claim token is a short-lived, single-use code generated by the relay server for the authenticated user. It links this gateway to the user's Squad account. Once consumed, the relay returns a `roomId` for future reconnections, and the claim token is no longer needed.
 
+For local testing, the relay endpoint can be overridden with environment variables:
+
+- `OPENCLAW_SQUAD_RELAY_URL` (preferred)
+- `SQUAD_RELAY_URL` (fallback)
+
+If neither is set, the plugin uses the production default `wss://relay.squad.ceo`.
+
 ### How the Relay Connection Works
 
 ```

package/dist/index.js

@@ -2638,7 +2638,7 @@ function normalizeEnvelope(raw) {
     blocking: true
   };
 }
-function validateHumanQuestionEnvelope(text) {
+function validateHumanQuestionEnvelope(text, options) {
   const markerIndex = text.indexOf(MARKER);
   if (markerIndex < 0) return { valid: false, markerFound: false };
   const tail = text.slice(markerIndex + MARKER.length).trimStart();
@@ -2656,23 +2656,146 @@ function validateHumanQuestionEnvelope(text) {
   if (!normalized) {
     return { valid: false, markerFound: true, errorCode: "schema_invalid" };
   }
-  return { valid: true, markerFound: true, normalizedEnvelope: normalized };
+  const expectedSessionKey = options?.expectedSessionKey?.trim();
+  const sessionKeyMismatch = !!(expectedSessionKey && normalized.sessionKey !== expectedSessionKey);
+  return {
+    valid: true,
+    markerFound: true,
+    normalizedEnvelope: normalized,
+    sessionKeyMismatch
+  };
 }
 function registerQuestionMethods(api) {
   api.registerGatewayMethod(
     "squad.questions.validate-envelope",
     async ({ params, respond }) => {
       const text = typeof params?.text === "string" ? params.text : "";
+      const expectedSessionKey = typeof params?.expectedSessionKey === "string" ? params.expectedSessionKey : void 0;
       if (!text) {
         respond(false, { error: "Missing 'text' parameter" });
         return;
       }
-      const result = validateHumanQuestionEnvelope(text);
+      const result = validateHumanQuestionEnvelope(text, { expectedSessionKey });
       respond(true, result);
     }
   );
 }
 
+// src/sessions.ts
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function extractSessionKey(value) {
+  const record = asRecord(value);
+  if (!record) return null;
+  if (typeof record.key === "string" && record.key.trim()) {
+    return record.key.trim();
+  }
+  const nestedKey = asRecord(record.key);
+  if (nestedKey && typeof nestedKey.key === "string" && nestedKey.key.trim()) {
+    return nestedKey.key.trim();
+  }
+  if (typeof record.sessionKey === "string" && record.sessionKey.trim()) {
+    return record.sessionKey.trim();
+  }
+  const nestedSession = asRecord(record.session);
+  if (nestedSession && typeof nestedSession.key === "string" && nestedSession.key.trim()) {
+    return nestedSession.key.trim();
+  }
+  return null;
+}
+function isInvoker(fn) {
+  return typeof fn === "function";
+}
+async function callGatewayAny(ctx, api, method, params) {
+  const ctxGateway = asRecord(ctx.gateway);
+  const apiGateway = asRecord(api?.gateway);
+  const candidates = [
+    ctx.request,
+    ctx.callGatewayMethod,
+    ctx.gatewayRequest,
+    ctx.invokeGatewayMethod,
+    ctxGateway?.request,
+    ctxGateway?.callGatewayMethod,
+    api?.request,
+    api?.callGatewayMethod,
+    api?.gatewayRequest,
+    api?.invokeGatewayMethod,
+    apiGateway?.request,
+    apiGateway?.callGatewayMethod
+  ];
+  let lastErr = null;
+  for (const candidate of candidates) {
+    if (!isInvoker(candidate)) continue;
+    try {
+      return await candidate(method, params);
+    } catch (err2) {
+      lastErr = err2;
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      if (/unknown method|method .* unavailable|not found|invalid[_ ]request|does not exist/i.test(
+        msg
+      )) {
+        continue;
+      }
+      throw err2;
+    }
+  }
+  if (lastErr) throw lastErr;
+  throw new Error("Gateway method invocation API unavailable in plugin context");
+}
+function registerSessionMethods(api) {
+  api.registerGatewayMethod(
+    "squad.sessions.create",
+    async (ctx) => {
+      const { params, respond } = ctx;
+      const sessionKey = params?.sessionKey;
+      const agentId = params?.agentId;
+      if (sessionKey !== void 0) {
+        if (typeof sessionKey !== "string" || !sessionKey.trim()) {
+          respond(false, { error: "Invalid 'sessionKey' parameter (must be a non-empty string when provided)" });
+          return;
+        }
+      }
+      if (agentId !== void 0) {
+        if (typeof agentId !== "string" || !agentId.trim()) {
+          respond(false, { error: "Invalid 'agentId' parameter (must be a non-empty string when provided)" });
+          return;
+        }
+      }
+      const createParams = {
+        ...typeof sessionKey === "string" ? { sessionKey: sessionKey.trim() } : {},
+        ...typeof agentId === "string" ? { agentId: agentId.trim() } : {}
+      };
+      try {
+        const nativeResult = await callGatewayAny(
+          ctx,
+          api,
+          "sessions.create",
+          createParams
+        );
+        const normalizedKey = extractSessionKey(nativeResult) ?? (typeof sessionKey === "string" ? sessionKey.trim() : null);
+        if (!normalizedKey) {
+          respond(false, {
+            error: "Session creation succeeded but no session key was returned",
+            nativeResult
+          });
+          return;
+        }
+        const nativeRecord = asRecord(nativeResult);
+        respond(true, {
+          ...nativeRecord ?? {},
+          key: normalizedKey
+        });
+      } catch (err2) {
+        const msg = err2 instanceof Error ? err2.message : String(err2);
+        respond(false, {
+          error: `Failed to create session: ${msg}`.slice(0, 500)
+        });
+      }
+    }
+  );
+}
+
 // src/shared-api.ts
 var CORE_TOOLS = [
   "exec",
@@ -2725,6 +2848,7 @@ function registerSquadSharedApi(api, onFsChange) {
   registerVersionMethods(api);
   registerAgentMethods(api);
   registerQuestionMethods(api);
+  registerSessionMethods(api);
   const invokeTool = async (tool, args) => {
     const executeFn = toolExecutors.get(tool);
     if (!executeFn) {
@@ -2786,7 +2910,7 @@ function squadAppPlugin(api) {
   const relayState = readRelayState();
   const relayEnabled = !!(relayState.claimToken || relayState.roomId);
   if (relayEnabled) {
-    const relayUrl = "wss://relay.squad.ceo";
+    const relayUrl = process.env.OPENCLAW_SQUAD_RELAY_URL || process.env.SQUAD_RELAY_URL || "wss://relay.squad.ceo";
     startRelayClient(api, relayUrl);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squad-openclaw",
-  "version": "2026.2.2203",
+  "version": "2026.2.2206",
   "description": "Entity registry, filesystem tools, and version management plugin for OpenClaw gateway",
   "type": "module",
   "main": "./dist/index.js",