@pennyclaw/idle-prune 0.1.1 → 0.1.3

package/dist/index.js

@@ -1,6 +1,23 @@
 // index.ts
 import fs from "fs";
 import path from "path";
+const inMemoryLocks = new Map();
+async function withFileLock(key, fn) {
+  if (inMemoryLocks.get(key)) return;
+  inMemoryLocks.set(key, true);
+  try {
+    await fn();
+  } finally {
+    inMemoryLocks.delete(key);
+  }
+}
+function isValidSessionFile(sessionFile, sessionsDir) {
+  if (!sessionFile || !sessionsDir) return false;
+  if (!sessionFile.endsWith(".jsonl")) return false;
+  const resolved = path.resolve(sessionFile);
+  const base = path.resolve(sessionsDir) + path.sep;
+  return resolved.startsWith(base);
+}
 function looksLikeGroupId(from) {
   const lower = from.toLowerCase();
   if (lower.includes(":group:")) return "group";
@@ -59,11 +76,59 @@ async function pruneTranscript(params) {
     }
   }
   if (!changed) return;
-  const tmp = `${params.sessionFile}.idle-prune.tmp`;
+  const tmp = `${params.sessionFile}.idle-prune.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
   await fs.promises.writeFile(tmp, out.join("\n"), "utf-8");
   await fs.promises.rename(tmp, params.sessionFile);
   params.logger.info(`idle-prune: pruned tool_result content in ${params.sessionFile}`);
 }
+function parseEntryTimestamp(entry) {
+  const ts = entry?.timestamp;
+  if (typeof ts === "number" && Number.isFinite(ts)) return ts < 1e12 ? ts * 1e3 : ts;
+  if (typeof ts === "string") {
+    const parsed = Date.parse(ts);
+    if (!Number.isNaN(parsed)) return parsed;
+  }
+  return void 0;
+}
+async function getLastMessageTimestampBefore(sessionFile, cutoffMs) {
+  if (!fs.existsSync(sessionFile)) return void 0;
+  const stat = await fs.promises.stat(sessionFile);
+  const fileSize = stat.size;
+  const maxBytes = 512 * 1024;
+  const chunkSize = 64 * 1024;
+  let bytesRead = 0;
+  let position = fileSize;
+  let buffer = "";
+  const handle = await fs.promises.open(sessionFile, "r");
+  try {
+    while (position > 0 && bytesRead < maxBytes) {
+      const readSize = Math.min(chunkSize, position);
+      position -= readSize;
+      const buf = Buffer.alloc(readSize);
+      await handle.read(buf, 0, readSize, position);
+      bytesRead += readSize;
+      buffer = buf.toString("utf-8") + buffer;
+      const lines = buffer.split("\n");
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line || !line.trim()) continue;
+        try {
+          const entry = JSON.parse(line);
+          if (entry?.type !== "message") continue;
+          const ts = parseEntryTimestamp(entry);
+          if (typeof ts !== "number") continue;
+          if (ts < cutoffMs) return ts;
+        } catch {
+          continue;
+        }
+      }
+      buffer = lines[0] || "";
+    }
+  } finally {
+    await handle.close();
+  }
+  return void 0;
+}
 function register(api) {
   const pluginCfg = api.pluginConfig ?? {};
   const idleMinutes = Number.isFinite(pluginCfg.idleMinutes) ? Number(pluginCfg.idleMinutes) : 15;
@@ -110,14 +175,23 @@ function register(api) {
       if (match) sessionKey = match;
     }
     const entry = store[sessionKey];
-    if (!entry || typeof entry.updatedAt !== "number") return;
+    if (!entry) return;
+    const sessionsDir = path.dirname(storePath);
+    const sessionFile = typeof entry.sessionFile === "string" && entry.sessionFile.trim() || path.join(sessionsDir, `${entry.sessionId}.jsonl`);
+    if (!isValidSessionFile(sessionFile, sessionsDir)) return;
     const now = Date.now();
-    if (now - entry.updatedAt < idleMinutes * 60 * 1e3) return;
-    const sessionFile = typeof entry.sessionFile === "string" && entry.sessionFile.trim() || path.join(path.dirname(storePath), `${entry.sessionId}.jsonl`);
-    await pruneTranscript({
-      sessionFile,
-      placeholder,
-      logger: api.logger
+    let cutoff = typeof event?.timestamp === "number" ? event.timestamp : typeof event?.timestamp === "string" ? Date.parse(event.timestamp) : now;
+    if (!Number.isFinite(cutoff)) cutoff = now;
+    if (cutoff < 1e12) cutoff *= 1e3;
+    const lastTs = await getLastMessageTimestampBefore(sessionFile, cutoff);
+    if (!lastTs) return;
+    if (now - lastTs < idleMinutes * 60 * 1e3) return;
+    await withFileLock(sessionFile, async () => {
+      await pruneTranscript({
+        sessionFile,
+        placeholder,
+        logger: api.logger
+      });
     });
   });
 }

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "idle-prune",
   "name": "Idle Prune",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Prune tool_result content after idle periods without LLM summarization.",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pennyclaw/idle-prune",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "OpenClaw plugin to prune tool_result content after idle",
   "type": "module",
   "main": "dist/index.js",