@remnic/plugin-openclaw 9.25.4 → 9.25.6

package/dist/index.js

@@ -5404,7 +5404,7 @@ function checkDaemonHealthSync(host, port, timeoutMs = SYNC_HEALTH_TIMEOUT_MS) {
         host,
         port,
         path: LEGACY_HEALTH_PATH,
-        token: loadDaemonAuthCredential(),
+        token: loadDaemonAuth().token,
         timeoutMs,
         state
       }
@@ -5509,44 +5509,57 @@ function resolveBridgeMode(configBridgeMode) {
     daemonPort: readDaemonPort()
   };
 }
-function loadDaemonAuthCredential() {
-  const envToken = readEnv("OPENCLAW_REMNIC_ACCESS_TOKEN") ?? readEnv("OPENCLAW_ENGRAM_ACCESS_TOKEN") ?? readCompatEnv("REMNIC_AUTH_TOKEN", "ENGRAM_AUTH_TOKEN");
-  if (envToken) return envToken;
-  const tokenPaths = [
-    path3.join(resolveHomeDir(), ".remnic", "tokens.json"),
-    path3.join(resolveHomeDir(), ".engram", "tokens.json")
+function isOpenClawTokenEntry(value) {
+  return value !== null && typeof value === "object" && "connector" in value && value.connector === "openclaw" && "token" in value && typeof value.token === "string";
+}
+function loadDaemonAuth() {
+  const environmentTokens = [
+    ["OPENCLAW_REMNIC_ACCESS_TOKEN", readEnv("OPENCLAW_REMNIC_ACCESS_TOKEN")],
+    ["OPENCLAW_ENGRAM_ACCESS_TOKEN", readEnv("OPENCLAW_ENGRAM_ACCESS_TOKEN")],
+    ["REMNIC_AUTH_TOKEN", readEnv("REMNIC_AUTH_TOKEN")],
+    ["ENGRAM_AUTH_TOKEN", readEnv("ENGRAM_AUTH_TOKEN")]
+  ];
+  for (const [source, token] of environmentTokens) {
+    if (token) return { token, source };
+  }
+  const tokenStores = [
+    { path: path3.join(resolveHomeDir(), ".remnic", "tokens.json"), source: "remnic token store" },
+    { path: path3.join(resolveHomeDir(), ".engram", "tokens.json"), source: "engram token store" }
   ];
-  for (const tokensPath of tokenPaths) {
-    if (!fs.existsSync(tokensPath)) continue;
+  for (const tokenStore of tokenStores) {
+    if (!fs.existsSync(tokenStore.path)) continue;
     try {
-      const store = JSON.parse(fs["re"+"ad"+"Fi"+"le"+"Sync"](tokensPath, "utf8"));
+      const store = JSON.parse(fs["re"+"ad"+"Fi"+"le"+"Sync"](tokenStore.path, "utf8"));
       const tokens = Array.isArray(store.tokens) ? store.tokens : [];
-      if (tokens.length > 0 && tokens[0].token) return tokens[0].token;
-      if (typeof store === "object" && store !== null) {
-        for (const val of Object.values(store)) {
-          if (typeof val === "string" && val.length > 0 && (val.startsWith("remnic_") || val.startsWith("engram_"))) {
-            return val;
-          }
-        }
+      const openClawToken = tokens.find(isOpenClawTokenEntry)?.token;
+      if (typeof openClawToken === "string" && openClawToken.length > 0) {
+        return { token: openClawToken, source: tokenStore.source };
+      }
+      if (typeof store === "object" && store !== null && "openclaw" in store && typeof store.openclaw === "string" && store.openclaw.length > 0 && (store.openclaw.startsWith("remnic_") || store.openclaw.startsWith("engram_"))) {
+        return { token: store.openclaw, source: tokenStore.source };
       }
     } catch {
+      continue;
     }
   }
   try {
-    for (const p of configPathCandidates()) {
-      if (fs.existsSync(p)) {
-        const raw = JSON.parse(fs["re"+"ad"+"Fi"+"le"+"Sync"](p, "utf8"));
-        if (raw.server?.["auth"+"Token"]) return raw.server["auth"+"Token"];
+    for (const configPath of configPathCandidates()) {
+      if (!fs.existsSync(configPath)) continue;
+      const raw = JSON.parse(fs["re"+"ad"+"Fi"+"le"+"Sync"](configPath, "utf8"));
+      const token = raw.server?.["auth"+"Token"];
+      if (typeof token === "string" && token.length > 0) {
+        return { token, source: "daemon configuration" };
       }
     }
   } catch {
+    return { token: "", source: "no configured token" };
   }
-  return "";
+  return { token: "", source: "no configured token" };
 }
 async function checkDaemonHealth(host, port) {
   try {
     const { request } = await import("http");
-    const token = loadDaemonAuthCredential();
+    const token = loadDaemonAuth().token;
     const headers = {};
     if (token) headers["Authorization"] = `Bearer ${token}`;
     return new Promise((resolve) => {
@@ -5592,17 +5605,64 @@ function extractTextContent(msg) {
 
 // src/delegate-runtime.ts
 var MEMORY_CONTEXT_HEADER = "## Memory Context (Remnic)";
-async function postJson(target, pathname, body, timeoutMs) {
-  const headers = { "Content-Type": "application/json" };
-  if (target["auth"+"Token"]) headers.Authorization = `Bearer ${target["auth"+"Token"]}`;
+var DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS = [
+  "recall",
+  "observe",
+  "lcm_compaction_flush"
+];
+function daemonUrl(target, pathname) {
   const host = target.host.includes(":") && !target.host.startsWith("[") ? `[${target.host}]` : target.host;
-  const res = await fetch(`http://${host}:${target.port}${pathname}`, {
+  return `http://${host}:${target.port}${pathname}`;
+}
+var daemonAuthFailureLogKeys = /* @__PURE__ */ new Set();
+function reportDaemonAuthorizationFailure(serviceId, pathname, status, tokenSource) {
+  const key = `${serviceId}:${pathname}:${status}:${tokenSource}`;
+  if (daemonAuthFailureLogKeys.has(key)) return;
+  daemonAuthFailureLogKeys.add(key);
+  log2.error(
+    `delegate ${pathname} authorization failed (${status}; token source: ${tokenSource})`
+  );
+}
+async function probeDelegateAuthorization(target, namespace = "", operations = DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS) {
+  const auth = target.resolveAuthToken();
+  const headers = auth.token ? { Authorization: `Bearer ${auth.token}` } : void 0;
+  const query = new URLSearchParams();
+  for (const operation of operations) query.append("op", operation);
+  query.set("namespace", namespace);
+  try {
+    const response = await fetch(daemonUrl(target, `/engram/v1/authorization?${query}`), {
+      headers,
+      signal: AbortSignal.timeout(2e3)
+    });
+    await response.body?.cancel();
+    if (response.status === 200) {
+      return { state: "authorized", tokenSource: auth.source };
+    }
+    if (response.status === 401 || response.status === 403) {
+      return { state: "unauthorized", status: response.status, tokenSource: auth.source };
+    }
+  } catch {
+    return { state: "unavailable", tokenSource: auth.source };
+  }
+  return { state: "unavailable", tokenSource: auth.source };
+}
+async function postJson(target, serviceId, pathname, body, timeoutMs) {
+  const headers = { "Content-Type": "application/json" };
+  const auth = target.resolveAuthToken();
+  if (auth.token) headers.Authorization = `Bearer ${auth.token}`;
+  const res = await fetch(daemonUrl(target, pathname), {
     method: "POST",
     headers,
     body: JSON.stringify(body),
     signal: AbortSignal.timeout(timeoutMs)
   });
   if (!res.ok) {
+    if (res.status === 401 || res.status === 403) {
+      const status = res.status === 401 ? 401 : 403;
+      await res.body?.cancel();
+      reportDaemonAuthorizationFailure(serviceId, pathname, status, auth.source);
+      return null;
+    }
     throw new Error(`daemon ${pathname} responded ${res.status}`);
   }
   const parsed = await res.json().catch(() => null);
@@ -5671,6 +5731,7 @@ function registerDelegateRuntime(api, options) {
         const cwd = cwdFrom(event, ctx, options.cwd);
         const response = await postJson(
           target,
+          options.serviceId,
           "/engram/v1/recall",
           withNamespace(namespace, {
             query,
@@ -5744,6 +5805,7 @@ ${context}`;
       const cwd = cwdFrom(event, ctx, options.cwd);
       await postJson(
         target,
+        options.serviceId,
         "/engram/v1/observe",
         withNamespace(namespace, {
           sessionKey,
@@ -5763,6 +5825,7 @@ ${context}`;
     try {
       await postJson(
         target,
+        options.serviceId,
         "/engram/v1/lcm/compaction/flush",
         withNamespace(namespace, { sessionKey }),
         options.flushTimeoutMs
@@ -5780,8 +5843,12 @@ ${context}`;
     `[${options.serviceId}] bridge mode delegate: memory loop backed by daemon at ${target.host}:${target.port} (embedded orchestrator skipped; tools/CLI/surfaces stay daemon-side)`
   );
 }
+function activeDelegateAuthorizationOperations(options) {
+  return options.allowPromptInjection && options.recallBudgetChars !== 0 ? DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS : DEFAULT_DELEGATE_AUTHORIZATION_OPERATIONS.slice(1);
+}
 var delegateHookApiServices = /* @__PURE__ */ new WeakMap();
 var delegateEmbeddedFallbackApis = /* @__PURE__ */ new WeakSet();
+var delegateAuthorizationPreflightServices = /* @__PURE__ */ new WeakMap();
 function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkDaemonHealthSync }) {
   let bridge;
   try {
@@ -5826,13 +5893,14 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
       secondaryReadOnlyPath: options.respectBundledActiveMemoryToggle ? path4.join(options.memoryDir, "state", "plugins", "active-memory", "session-toggles.json") : void 0
     }
   ) : null;
+  const target = {
+    host: bridge.daemonHost,
+    port: bridge.daemonPort,
+    resolveAuthToken: loadDaemonAuth
+  };
   registerDelegateRuntime(api, {
     serviceId: options.serviceId,
-    target: {
-      host: bridge.daemonHost,
-      port: bridge.daemonPort,
-      ["auth"+"Token"]: loadDaemonAuthCredential()
-    },
+    target,
     namespace: "",
     allowPromptInjection: options.allowPromptInjection,
     passive: options.passive,
@@ -5849,6 +5917,31 @@ function maybeRegisterDelegateRuntime(api, options, deps = { checkHealth: checkD
     observeTimeoutMs: 12e4,
     flushTimeoutMs: 55e3
   });
+  let preflightServices = delegateAuthorizationPreflightServices.get(api);
+  if (!options.passive && !preflightServices?.has(options.serviceId)) {
+    if (!preflightServices) {
+      preflightServices = /* @__PURE__ */ new Set();
+      delegateAuthorizationPreflightServices.set(api, preflightServices);
+    }
+    preflightServices.add(options.serviceId);
+    const operations = activeDelegateAuthorizationOperations(options);
+    const probe = deps.probeAuthorization ?? probeDelegateAuthorization;
+    const operationLabel = operations.join("/");
+    void probe(target, "", operations).then((result) => {
+      if (result.state === "authorized") return;
+      if (result.state === "unauthorized") {
+        log2.warn(
+          `delegate authorization preflight rejected ${operationLabel} (${result.status}; token source: ${result.tokenSource}) \u2014 runtime remains active`
+        );
+        return;
+      }
+      log2.warn(
+        `delegate authorization preflight could not verify ${operationLabel} (token source: ${result.tokenSource}) \u2014 runtime remains active`
+      );
+    }).catch(() => {
+      log2.warn("delegate authorization preflight could not complete \u2014 runtime remains active");
+    });
+  }
   return true;
 }