squad-openclaw 2026.2.2205 → 2026.2.2207

package/dist/index.js

@@ -2682,6 +2682,9 @@ function registerQuestionMethods(api) {
 }
 
 // src/sessions.ts
+import fs10 from "fs";
+import path11 from "path";
+import crypto4 from "crypto";
 function asRecord(value) {
   return value && typeof value === "object" ? value : null;
 }
@@ -2704,16 +2707,104 @@ function extractSessionKey(value) {
   }
   return null;
 }
-function registerSessionMethods(api) {
-  const callGateway = async (ctx, method, params = {}) => {
-    const ctxRequest = ctx.request;
-    if (typeof ctxRequest === "function") return ctxRequest(method, params);
-    const apiRequest = api?.request;
-    if (typeof apiRequest === "function") return apiRequest(method, params);
-    const apiCallGatewayMethod = api?.callGatewayMethod;
-    if (typeof apiCallGatewayMethod === "function") return apiCallGatewayMethod(method, params);
-    throw new Error("Gateway method invocation API unavailable in plugin context");
+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 parseAgentIdFromSessionKey(sessionKey) {
+  const m = sessionKey.match(/^agent:([^:]+):/);
+  return m?.[1] ?? null;
+}
+function ensureDir(dirPath) {
+  fs10.mkdirSync(dirPath, { recursive: true });
+}
+function readSessionsMap(sessionsJsonPath) {
+  try {
+    const raw = fs10.readFileSync(sessionsJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function writeSessionsMap(sessionsJsonPath, sessionsMap) {
+  fs10.writeFileSync(sessionsJsonPath, JSON.stringify(sessionsMap, null, 2), "utf-8");
+}
+function createSessionOnDisk(input) {
+  const requestedSessionKey = input.requestedSessionKey?.trim();
+  const requestedAgentId = input.requestedAgentId?.trim();
+  const derivedAgentId = requestedAgentId || (requestedSessionKey ? parseAgentIdFromSessionKey(requestedSessionKey) : null) || "main";
+  const sessionKey = requestedSessionKey || `agent:${derivedAgentId}:${crypto4.randomUUID()}`;
+  const stateDir = getOpenclawStateDir();
+  const sessionsDir = path11.join(stateDir, "agents", derivedAgentId, "sessions");
+  const sessionsJsonPath = path11.join(sessionsDir, "sessions.json");
+  ensureDir(sessionsDir);
+  const now = Date.now();
+  const sessionsMap = readSessionsMap(sessionsJsonPath);
+  const existing = sessionsMap[sessionKey];
+  const sessionId = typeof existing?.sessionId === "string" && existing.sessionId.trim() ? existing.sessionId : crypto4.randomUUID();
+  const jsonlPath = path11.join(sessionsDir, `${sessionId}.jsonl`);
+  sessionsMap[sessionKey] = {
+    ...existing ?? {},
+    sessionId,
+    updatedAt: now,
+    label: typeof existing?.label === "string" && existing.label.trim() ? existing.label : "New Session",
+    totalTokens: typeof existing?.totalTokens === "number" ? existing.totalTokens : 0,
+    lastMessageRole: existing?.lastMessageRole ?? "assistant",
+    lastAssistantHasText: typeof existing?.lastAssistantHasText === "boolean" ? existing.lastAssistantHasText : true
   };
+  writeSessionsMap(sessionsJsonPath, sessionsMap);
+  if (!fs10.existsSync(jsonlPath)) {
+    fs10.writeFileSync(jsonlPath, "", "utf-8");
+  }
+  return {
+    key: sessionKey,
+    sessionKey,
+    sessionId,
+    agentId: derivedAgentId,
+    displayName: sessionKey,
+    status: "active",
+    createdAt: now
+  };
+}
+function registerSessionMethods(api) {
   api.registerGatewayMethod(
     "squad.sessions.create",
     async (ctx) => {
@@ -2737,7 +2828,12 @@ function registerSessionMethods(api) {
         ...typeof agentId === "string" ? { agentId: agentId.trim() } : {}
       };
       try {
-        const nativeResult = await callGateway(ctx, "sessions.create", createParams);
+        const nativeResult = await callGatewayAny(
+          ctx,
+          api,
+          "sessions.create",
+          createParams
+        );
         const normalizedKey = extractSessionKey(nativeResult) ?? (typeof sessionKey === "string" ? sessionKey.trim() : null);
         if (!normalizedKey) {
           respond(false, {
@@ -2753,6 +2849,22 @@ function registerSessionMethods(api) {
         });
       } catch (err2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
+        if (/gateway method invocation api unavailable in plugin context/i.test(msg)) {
+          try {
+            const local = createSessionOnDisk({
+              requestedSessionKey: typeof sessionKey === "string" ? sessionKey : void 0,
+              requestedAgentId: typeof agentId === "string" ? agentId : void 0
+            });
+            respond(true, local);
+            return;
+          } catch (fallbackErr) {
+            const fallbackMsg = fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
+            respond(false, {
+              error: `Failed to create session (local fallback): ${fallbackMsg}`.slice(0, 500)
+            });
+            return;
+          }
+        }
         respond(false, {
           error: `Failed to create session: ${msg}`.slice(0, 500)
         });

package/package.json

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