@remnic/plugin-openclaw 9.54.1 → 9.54.3

package/dist/index.js

@@ -5533,7 +5533,7 @@ function parseEnvironmentFile(body) {
   }
   return parsed;
 }
-function readUnitEnvironment(unit, scope, readFile4, listDir) {
+function readUnitEnvironment(unit, scope, readFile3, listDir) {
   const directives = readEffectiveDirectives(unit);
   const merged = new Map(directives.env);
   for (const candidate of directives.envFiles) {
@@ -5542,7 +5542,7 @@ function readUnitEnvironment(unit, scope, readFile4, listDir) {
     const resolved = settleUnitValue(expandedFile);
     if (!path3.isAbsolute(resolved)) continue;
     for (const match of expandEnvironmentFilePattern(resolved, listDir)) {
-      const body = readFile4(match);
+      const body = readFile3(match);
       if (body === void 0) continue;
       for (const [key, value] of parseEnvironmentFile(body)) merged.set(key, value);
     }
@@ -5582,8 +5582,8 @@ function defaultUnitFileReader(candidate) {
     return void 0;
   }
 }
-function readUnitEnv(unit, name, scope, readFile4 = defaultUnitFileReader, listDir = defaultUnitDirLister) {
-  const systemdValue = readUnitEnvironment(unit, scope, readFile4, listDir).get(name);
+function readUnitEnv(unit, name, scope, readFile3 = defaultUnitFileReader, listDir = defaultUnitDirLister) {
+  const systemdValue = readUnitEnvironment(unit, scope, readFile3, listDir).get(name);
   const systemd = systemdValue === void 0 ? null : [void 0, systemdValue];
   const launchdRaw = new RegExp(`<key>${name}</key>\\s*<string>([^<]*)</string>`).exec(unit);
   const launchd = launchdRaw === null ? null : [void 0, decodePlistString(launchdRaw[1] ?? "")];
@@ -5641,9 +5641,9 @@ function readUnitWorkingDirectory(unit) {
   if (raw === void 0 || raw === "") return void 0;
   return /^(["']).*\1$/.test(raw) ? raw.slice(1, -1) : raw;
 }
-function readUnitCliOverrides(unit, scope, readFile4, listDir) {
+function readUnitCliOverrides(unit, scope, readFile3, listDir) {
   const tokens = [];
-  const environment = readUnitEnvironment(unit, scope, readFile4, listDir);
+  const environment = readUnitEnvironment(unit, scope, readFile3, listDir);
   const substituteBraced = (token) => token.replace(
     /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g,
     (match, name) => environment.get(name) ?? match
@@ -5706,12 +5706,12 @@ function readUnitCliOverrides(unit, scope, readFile4, listDir) {
     ...authToken === void 0 ? {} : { authToken }
   };
 }
-function resolveUnitEndpoint(unit, scope, readFile4 = defaultUnitFileReader, listDir = defaultUnitDirLister) {
-  const cli = readUnitCliOverrides(unit, scope, readFile4, listDir);
+function resolveUnitEndpoint(unit, scope, readFile3 = defaultUnitFileReader, listDir = defaultUnitDirLister) {
+  const cli = readUnitCliOverrides(unit, scope, readFile3, listDir);
   const envOverride = (primary, legacy) => {
-    const value = readUnitEnv(unit, primary, scope, readFile4, listDir);
+    const value = readUnitEnv(unit, primary, scope, readFile3, listDir);
     if (value !== void 0) return value === "" ? void 0 : value;
-    const legacyValue = readUnitEnv(unit, legacy, scope, readFile4, listDir);
+    const legacyValue = readUnitEnv(unit, legacy, scope, readFile3, listDir);
     return legacyValue === "" ? void 0 : legacyValue;
   };
   const host = cli.host ?? envOverride("REMNIC_HOST", "ENGRAM_HOST");
@@ -5719,17 +5719,17 @@ function resolveUnitEndpoint(unit, scope, readFile4 = defaultUnitFileReader, lis
   const authToken = cli.authToken ?? envOverride("REMNIC_AUTH_TOKEN", "ENGRAM_AUTH_TOKEN");
   const configFromCli = cli.configPath === void 0 ? {} : { configPath: cli.configPath };
   return {
-    ...resolveUnitConfigPathInner(unit, scope, readFile4, listDir),
+    ...resolveUnitConfigPathInner(unit, scope, readFile3, listDir),
     ...configFromCli,
     ...host === void 0 ? {} : { host },
     ...port === void 0 ? {} : { port },
     ...authToken === void 0 ? {} : { authToken }
   };
 }
-function resolveUnitConfigPathInner(unit, scope, readFile4, listDir) {
+function resolveUnitConfigPathInner(unit, scope, readFile3, listDir) {
   const workingDirectory = readUnitWorkingDirectory(unit);
   for (const name of ["REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH"]) {
-    const raw = readUnitEnv(unit, name, scope, readFile4, listDir);
+    const raw = readUnitEnv(unit, name, scope, readFile3, listDir);
     if (raw === "") return {};
     if (raw === void 0) continue;
     const resolved = resolveAgainstWorkingDirectory(raw, workingDirectory, scope);
@@ -5739,7 +5739,7 @@ function resolveUnitConfigPathInner(unit, scope, readFile4, listDir) {
   if (workingDirectory !== void 0) {
     for (const name of ["remnic.config.json", "engram.config.json"]) {
       const candidate = resolveAgainstWorkingDirectory(name, workingDirectory, scope);
-      if (candidate !== void 0 && readFile4(candidate) !== void 0) {
+      if (candidate !== void 0 && readFile3(candidate) !== void 0) {
         return { configPath: candidate };
       }
     }
@@ -6783,9 +6783,11 @@ function daemonTargetFor(bridge) {
 }
 
 // src/delegate-flush-plan-ingest.ts
-import { lstat as lstat3, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { constants } from "fs";
+import { lstat as lstat3, open, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 import path7 from "path";
 import { log as log4 } from "@remnic/core/logger";
+import { withHeldFileLock } from "@remnic/core/utils/serialize-mutations";
 
 // src/memory-flush-plan.ts
 var DEFAULT_MAX_TURN_CHARS = 8e3;
@@ -6806,71 +6808,300 @@ function buildMemoryFlushPlan(options) {
   };
 }
 
+// src/delegate-http.ts
+async function readJsonObject(res) {
+  const parsed = await res.json().catch(() => null);
+  return typeof parsed === "object" && parsed !== null ? parsed : null;
+}
+async function noteRefusal(res, serviceId, pathname, source) {
+  await res.body?.cancel();
+  if (res.status === 401 || res.status === 403) {
+    reportDaemonAuthorizationFailure(serviceId, pathname, res.status, source);
+  }
+  return { status: res.status, body: null };
+}
+async function postJsonWithStatus(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) return noteRefusal(res, serviceId, pathname, auth.source);
+  return { status: res.status, body: await readJsonObject(res) };
+}
+async function postJson(target, serviceId, pathname, body, timeoutMs) {
+  const response = await postJsonWithStatus(target, serviceId, pathname, body, timeoutMs);
+  if (response.status === 401 || response.status === 403) return null;
+  if (response.status < 200 || response.status > 299) {
+    throw new Error(`daemon ${pathname} responded ${response.status}`);
+  }
+  return response.body;
+}
+async function getJson(target, serviceId, pathname, timeoutMs) {
+  const headers = {};
+  const auth = target.resolveAuthToken();
+  if (auth.token) headers.Authorization = `Bearer ${auth.token}`;
+  const res = await fetch(daemonUrl(target, pathname), {
+    headers,
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) return noteRefusal(res, serviceId, pathname, auth.source);
+  return { status: res.status, body: await readJsonObject(res) };
+}
+
 // src/delegate-flush-plan-ingest.ts
 var MAX_OBSERVE_CHUNK_BYTES = 96 * 1024;
 var MIN_OBSERVE_CHUNK_BYTES = 4 * 1024;
+var LOCK_MAX_WAIT_MS = 5e3;
+var LOCK_STALE_MS = 6e4;
+var MAX_RECLAIM_PASSES = 4;
 async function ingestFlushPlanNotes(options) {
   if (options.workspaceDir === void 0) return;
+  const workspaceDir = options.workspaceDir;
   const planPath = path7.join(
-    options.workspaceDir,
+    workspaceDir,
     ...buildMemoryFlushPlan({ serviceId: options.serviceId }).relativePath.split("/")
   );
-  if (!await isLinkFreeUnder(options.workspaceDir, planPath)) {
+  const paths = {
+    plan: planPath,
+    inflight: `${planPath}.inflight`,
+    rotating: `${planPath}.rotating`,
+    oversized: `${planPath}.oversized`,
+    lock: `${planPath}.lock`
+  };
+  for (const candidate of [paths.plan, paths.inflight, paths.rotating, paths.oversized]) {
+    if (await isLinkFreeUnder(workspaceDir, candidate)) continue;
     log4.warn(
-      `[${options.serviceId}] flush-plan ingestion skipped: ${planPath}, a parent, or the workspace root is a symlink`
+      `[${options.serviceId}] flush-plan ingestion skipped: ${candidate}, a parent, or the workspace root is a symlink`
     );
     return;
   }
-  let pending = await readPlan(planPath);
-  if (pending === void 0 || pending.trim().length === 0) return;
+  const lockWaitMs = Math.max(1, Math.min(LOCK_MAX_WAIT_MS, Math.floor(options.remainingTimeoutMs() / 2)));
+  await withHeldFileLock(
+    paths.lock,
+    { staleMs: LOCK_STALE_MS, maxWaitMs: lockWaitMs },
+    async (acquired, lock) => {
+      if (!acquired) {
+        log4.warn(
+          `[${options.serviceId}] flush-plan ingestion skipped: another flush holds the lock; the notes drain on the next flush`
+        );
+        return;
+      }
+      for (const candidate of [paths.plan, paths.inflight, paths.rotating, paths.oversized]) {
+        if (await isLinkFreeUnder(workspaceDir, candidate)) continue;
+        log4.warn(
+          `[${options.serviceId}] flush-plan ingestion skipped: ${candidate}, a parent, or the workspace root became a symlink`
+        );
+        return;
+      }
+      await ingestUnderLock(options, paths, lock);
+    }
+  );
+}
+async function ingestUnderLock(options, paths, lock) {
   let chunkBytes = MAX_OBSERVE_CHUNK_BYTES;
-  while (pending.trim().length > 0) {
-    const timeoutMs = options.remainingTimeoutMs();
-    if (timeoutMs <= 0) {
+  for (let pass = 0; pass < MAX_RECLAIM_PASSES; pass++) {
+    if (options.remainingTimeoutMs() <= 0) return;
+    const claimed = await claimPendingNotes(paths, options.serviceId, lock);
+    if (claimed === void 0) {
       log4.warn(
-        `[${options.serviceId}] flush-plan ingestion stopped: the caller's deadline is spent; the remainder drains on the next flush`
+        `[${options.serviceId}] flush-plan lock was lost during recovery; its new owner drains the snapshot`
       );
       return;
     }
-    const [chunk] = chunkOnLineBoundaries(pending, chunkBytes);
-    if (chunk === void 0) return;
-    const accepted = await postJson(
-      options.target,
-      options.serviceId,
-      "/engram/v1/observe",
-      {
-        sessionKey: options.sessionKey,
-        messages: [{ role: "user", content: chunk }],
-        ...options.namespace === void 0 ? {} : { namespace: options.namespace }
-      },
-      timeoutMs
-    );
-    if (accepted === null) {
-      if (chunkBytes > MIN_OBSERVE_CHUNK_BYTES && chunkOnLineBoundaries(pending, chunkBytes).length > 1) {
-        chunkBytes = Math.max(MIN_OBSERVE_CHUNK_BYTES, Math.floor(chunkBytes / 2));
-        continue;
+    if (claimed.trim().length === 0) {
+      if (await lock.refresh()) await discard(paths.inflight);
+      return;
+    }
+    let pending = claimed;
+    let stop = false;
+    let lockLost = false;
+    try {
+      while (pending.trim().length > 0) {
+        const timeoutMs = options.remainingTimeoutMs();
+        if (timeoutMs <= 0) {
+          log4.warn(
+            `[${options.serviceId}] flush-plan ingestion stopped: the caller's deadline is spent; the remainder drains on the next flush`
+          );
+          stop = true;
+          return;
+        }
+        const [chunk] = chunkOnLineBoundaries(pending, chunkBytes);
+        if (chunk === void 0) {
+          stop = true;
+          return;
+        }
+        const response = await postJsonWithStatus(
+          options.target,
+          options.serviceId,
+          "/engram/v1/observe",
+          {
+            sessionKey: options.sessionKey,
+            messages: [{ role: "user", content: chunk }],
+            ...options.namespace === void 0 ? {} : { namespace: options.namespace }
+          },
+          timeoutMs
+        );
+        if (isRefusal(response.status)) {
+          log4.warn(
+            `[${options.serviceId}] flush-plan notes were refused by the daemon (${response.status}); keeping them for the next flush`
+          );
+          stop = true;
+          return;
+        }
+        if (response.status === 413) {
+          if (countLines(chunk) > 1) {
+            chunkBytes = Math.max(1, Math.floor(chunkBytes / 2));
+            continue;
+          }
+          pending = await quarantineOversizedLine(paths, pending, options.serviceId);
+          chunkBytes = MAX_OBSERVE_CHUNK_BYTES;
+          if (!await lock.refresh()) {
+            log4.warn(
+              `[${options.serviceId}] flush-plan lock was lost mid-flush; the snapshot is left to its new owner`
+            );
+            lockLost = true;
+            stop = true;
+            return;
+          }
+          await atomicWrite(paths.inflight, pending);
+          continue;
+        }
+        if (response.status < 200 || response.status > 299) {
+          stop = true;
+          throw new Error(`daemon /engram/v1/observe responded ${response.status}`);
+        }
+        pending = pending.slice(chunk.length);
+        if (!await lock.refresh()) {
+          log4.warn(
+            `[${options.serviceId}] flush-plan lock was lost mid-flush; the snapshot is left to its new owner`
+          );
+          lockLost = true;
+          stop = true;
+          return;
+        }
+        await atomicWrite(paths.inflight, pending);
       }
-      log4.warn(
-        `[${options.serviceId}] flush-plan notes were rejected by the daemon; keeping the remainder for the next flush`
-      );
+    } finally {
+      if (!lockLost && await lock.refresh()) {
+        await releasePendingNotes(paths, pending, options.serviceId);
+      } else if (!lockLost) {
+        log4.warn(
+          `[${options.serviceId}] flush-plan lock was lost before the snapshot could be updated; its new owner drains the remainder`
+        );
+      }
+    }
+    if (stop) return;
+  }
+}
+function countLines(chunk) {
+  const body = chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk;
+  if (body.length === 0) return chunk.length > 0 ? 1 : 0;
+  return body.split("\n").length;
+}
+function isRefusal(status) {
+  return status === 401 || status === 403 || status === 431;
+}
+async function claimPendingNotes(paths, serviceId, lock) {
+  const recovery = await mergeRotatedIntoInflight(paths, lock);
+  if (recovery === "lock-lost") return void 0;
+  if (recovery === "recovered") {
+    log4.warn(`[${serviceId}] recovered flush-plan notes left by an interrupted ingestion`);
+  }
+  if (!await lock.refresh()) return void 0;
+  try {
+    await rename2(paths.plan, paths.rotating);
+  } catch (err) {
+    if (err?.code !== "ENOENT") throw err;
+    return await readIfPresent(paths.inflight) ?? "";
+  }
+  if (await mergeRotatedIntoInflight(paths, lock) === "lock-lost") return void 0;
+  return await readIfPresent(paths.inflight) ?? "";
+}
+async function mergeRotatedIntoInflight(paths, lock) {
+  const rotated = await readIfPresent(paths.rotating);
+  if (rotated === void 0) return "nothing";
+  const existing = await readIfPresent(paths.inflight) ?? "";
+  let merged = `${existing}${rotated}`;
+  if (merged.length > 0) {
+    if (!await lock.refresh()) return "lock-lost";
+    await atomicWrite(paths.inflight, merged);
+  }
+  const late = await readIfPresent(paths.rotating);
+  if (late !== void 0 && late.length > rotated.length) {
+    if (!await lock.refresh()) return "lock-lost";
+    merged = `${existing}${late}`;
+    await atomicWrite(paths.inflight, merged);
+  }
+  if (!await lock.refresh()) return "lock-lost";
+  await discard(paths.rotating);
+  return merged.length > 0 ? "recovered" : "nothing";
+}
+async function releasePendingNotes(paths, pending, serviceId) {
+  try {
+    if (pending.length === 0) {
+      await discard(paths.inflight);
       return;
     }
-    pending = await commitAcceptedPrefix(planPath, chunk) ?? "";
+    await atomicWrite(paths.inflight, pending);
+  } catch (err) {
+    log4.warn(
+      `[${serviceId}] could not persist unsent flush-plan notes; the next ingestion recovers them: ${String(err)}`
+    );
   }
 }
-async function readPlan(planPath) {
+async function quarantineOversizedLine(paths, pending, serviceId) {
+  const breakAt = pending.indexOf("\n");
+  const line = breakAt === -1 ? pending : pending.slice(0, breakAt + 1);
+  const rest = breakAt === -1 ? "" : pending.slice(breakAt + 1);
+  const handle = await open(
+    paths.oversized,
+    constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NOFOLLOW,
+    384
+  );
   try {
-    return await readFile2(planPath, "utf8");
-  } catch {
-    return void 0;
+    await handle.writeFile(line.endsWith("\n") ? line : `${line}
+`, "utf8");
+  } finally {
+    await handle.close();
+  }
+  log4.warn(
+    `[${serviceId}] a flush-plan note exceeds the daemon's body limit; moved it to ${paths.oversized} so the remaining notes can drain`
+  );
+  return rest;
+}
+async function readIfPresent(filePath) {
+  let handle;
+  try {
+    handle = await open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    return await handle.readFile("utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") return void 0;
+    throw err;
+  } finally {
+    await handle?.close();
+  }
+}
+async function atomicWrite(filePath, content) {
+  const tempPath = `${filePath}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
+  try {
+    await writeFile2(tempPath, content, { encoding: "utf8", flag: "wx", mode: 384 });
+    await rename2(tempPath, filePath);
+  } catch (err) {
+    await discard(tempPath);
+    throw err;
   }
 }
-async function commitAcceptedPrefix(planPath, accepted) {
-  const current = await readPlan(planPath);
-  if (current === void 0) return void 0;
-  const remainder = current.startsWith(accepted) ? current.slice(accepted.length) : current;
-  await writeFile2(planPath, remainder, "utf8");
-  return current.startsWith(accepted) ? remainder : void 0;
+async function discard(filePath) {
+  try {
+    await unlink2(filePath);
+  } catch (err) {
+    if (err?.code !== "ENOENT") throw err;
+  }
 }
 function chunkOnLineBoundaries(text, limit) {
   if (Buffer.byteLength(text, "utf8") <= limit) return [text];
@@ -6931,7 +7162,7 @@ function extractTextContent(msg) {
 }
 
 // src/delegate-capability.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { log as log5 } from "@remnic/core/logger";
 var HEALTH_CACHE_TTL_MS = 3e4;
 var SEARCH_CANDIDATE_CAP = 25e3;
@@ -7266,7 +7497,7 @@ function createDelegateMemoryCapability(options) {
     await requireLocalReadAuthorized("readFile", ["memory_get"]);
     const requestedPath = sharedScope().normalizeWorkspacePath(params.relPath);
     const absolutePath = await sharedScope().resolveReadablePath(params.relPath);
-    const allLines = (await readFile3(absolutePath, "utf8")).split(/\r?\n/);
+    const allLines = (await readFile2(absolutePath, "utf8")).split(/\r?\n/);
     if (params.from !== void 0 && (!Number.isInteger(params.from) || params.from < 1)) {
       throw new Error(
         `memory read rejected (from must be a positive integer): ${String(params.from)}`
@@ -7410,52 +7641,6 @@ function registerDelegateMemoryCapability(api, options) {
 
 // src/delegate-runtime.ts
 var DELEGATE_BATCH_FLUSH_CACHE_TTL_MS = 3e4;
-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);
-  return typeof parsed === "object" && parsed !== null ? parsed : null;
-}
-async function getJson(target, serviceId, pathname, timeoutMs) {
-  const headers = {};
-  const auth = target.resolveAuthToken();
-  if (auth.token) headers.Authorization = `Bearer ${auth.token}`;
-  const res = await fetch(daemonUrl(target, pathname), {
-    headers,
-    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 { status: res.status, body: null };
-    }
-    await res.body?.cancel();
-    return { status: res.status, body: null };
-  }
-  const parsed = await res.json().catch(() => null);
-  return {
-    status: res.status,
-    body: typeof parsed === "object" && parsed !== null ? parsed : null
-  };
-}
 function sessionKeyFrom(event, ctx) {
   const fromCtx = ctx?.sessionKey;
   if (typeof fromCtx === "string" && fromCtx.length > 0) return fromCtx;