@mobcode/openclaw-plugin 0.1.3 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mobcode/openclaw-plugin",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "MobCode integration plugin for OpenClaw",
   "type": "module",
   "license": "MIT",

package/src/openclaw-session-reader.js

@@ -46,6 +46,9 @@ async function readSessionMessagesThroughChatHistory(config, sessionKey, logger)
   if (!normalizedSessionKey) {
     return [];
   }
+  logger?.info?.(
+    `[mobcode-history] chat.history request session=${normalizedSessionKey} limit=1000`,
+  );
   const payload = await requestThroughOperatorApprovalsGateway({
     config,
     method: "chat.history",
@@ -57,7 +60,7 @@ async function readSessionMessagesThroughChatHistory(config, sessionKey, logger)
   });
   const messages = payload?.messages;
   logger?.info?.(
-    `[mobcode-history] chat.history session=${normalizedSessionKey} messages=${Array.isArray(messages) ? messages.length : 0}`,
+    `[mobcode-history] chat.history response session=${normalizedSessionKey} sessionId=${String(payload?.sessionId ?? "").trim() || "-"} messages=${Array.isArray(messages) ? messages.length : 0}`,
   );
   return Array.isArray(messages) ? messages : [];
 }
@@ -78,6 +81,9 @@ export async function readSessionTranscriptMessages(config, sessionKey, logger)
     );
     // Fall back to adjacent-source runtime imports for development checkouts.
   }
+  logger?.info?.(
+    `[mobcode-history] falling back to internal transcript reader session=${String(sessionKey ?? "").trim()}`,
+  );
   const internalMessages = await readSessionTranscriptMessagesFromInternals(sessionKey);
   logger?.info?.(
     `[mobcode-history] internal fallback session=${String(sessionKey ?? "").trim()} messages=${internalMessages.length}`,

package/src/runtime-events.js

@@ -1,4 +1,5 @@
 import { tryCreateOperatorApprovalsGatewayClient } from "./openclaw-gateway-runtime.js";
+import { resolveSessionKeyFromTranscriptFile } from "./session-key-resolver.js";
 
 function createPushPayloadFromTranscript(update) {
   return {
@@ -39,11 +40,30 @@ export function registerMobcodeRuntimeObservers({ api, store, pluginConfig }) {
       await store.init();
 
       api.runtime.events.onSessionTranscriptUpdate(async (update) => {
+        let resolvedSessionKey = String(update?.sessionKey ?? "").trim();
+        if (!resolvedSessionKey && update?.sessionFile) {
+          resolvedSessionKey =
+            (await resolveSessionKeyFromTranscriptFile(update.sessionFile, api.logger)) ?? "";
+        }
+        api.logger?.info?.(
+          `[mobcode-runtime] transcript update sessionKey=${resolvedSessionKey || "-"} rawSessionKey=${String(update?.sessionKey ?? "").trim() || "-"} sessionFile=${String(update?.sessionFile ?? "").trim() || "-"} messageId=${String(update?.messageId ?? "").trim() || "-"} hasMessage=${update?.message !== undefined}`,
+        );
         if (retainMessages && update?.message !== undefined) {
-          await store.appendMessage(update);
+          const indexed = await store.appendMessage({
+            ...update,
+            ...(resolvedSessionKey ? { sessionKey: resolvedSessionKey } : {}),
+          });
+          api.logger?.info?.(
+            `[mobcode-runtime] transcript indexed sessionKey=${indexed?.sessionKey ?? "-"} total=${String(indexed?.count ?? 0)} skipped=${indexed?.skipped === true}`,
+          );
         }
         if (pushEnabled) {
-          await store.enqueuePush(createPushPayloadFromTranscript(update));
+          await store.enqueuePush(
+            createPushPayloadFromTranscript({
+              ...update,
+              ...(resolvedSessionKey ? { sessionKey: resolvedSessionKey } : {}),
+            }),
+          );
         }
       });
 

package/src/session-key-resolver.js

@@ -0,0 +1,103 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const RESOLVED_SESSION_KEY_CACHE = new Map();
+
+async function resolvePathForComparison(value) {
+  const trimmed = String(value ?? "").trim();
+  if (!trimmed) {
+    return null;
+  }
+  const resolved = path.resolve(trimmed);
+  try {
+    return await fs.realpath(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+function extractSessionsDir(sessionFile) {
+  const normalized = String(sessionFile ?? "").trim();
+  if (!normalized) {
+    return null;
+  }
+  const sessionsDir = path.dirname(path.resolve(normalized));
+  return path.basename(sessionsDir) === "sessions" ? sessionsDir : null;
+}
+
+async function readSessionStore(storePath) {
+  try {
+    const raw = await fs.readFile(storePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function buildTranscriptCandidates(entry, sessionsDir) {
+  const candidates = [];
+  const rawSessionFile = String(entry?.sessionFile ?? "").trim();
+  if (rawSessionFile) {
+    candidates.push(
+      path.isAbsolute(rawSessionFile)
+        ? rawSessionFile
+        : path.resolve(sessionsDir, rawSessionFile),
+    );
+  }
+  const sessionId = String(entry?.sessionId ?? "").trim();
+  if (sessionId) {
+    candidates.push(path.join(sessionsDir, `${sessionId}.jsonl`));
+  }
+  return candidates;
+}
+
+export async function resolveSessionKeyFromTranscriptFile(sessionFile, logger) {
+  const targetPath = await resolvePathForComparison(sessionFile);
+  if (!targetPath) {
+    return null;
+  }
+
+  const cached = RESOLVED_SESSION_KEY_CACHE.get(targetPath);
+  if (cached) {
+    logger?.info?.(
+      `[mobcode-session-key] cache-hit sessionFile=${targetPath} sessionKey=${cached}`,
+    );
+    return cached;
+  }
+
+  const sessionsDir = extractSessionsDir(targetPath);
+  if (!sessionsDir) {
+    logger?.warn?.(
+      `[mobcode-session-key] unresolved sessionFile=${targetPath} reason=no_sessions_dir`,
+    );
+    return null;
+  }
+
+  const storePath = path.join(sessionsDir, "sessions.json");
+  const store = await readSessionStore(storePath);
+  const entries = Object.entries(store);
+  logger?.info?.(
+    `[mobcode-session-key] lookup sessionFile=${targetPath} storePath=${storePath} entries=${entries.length}`,
+  );
+
+  for (const [sessionKey, entry] of entries) {
+    const candidates = buildTranscriptCandidates(entry, sessionsDir);
+    for (const candidate of candidates) {
+      const candidatePath = await resolvePathForComparison(candidate);
+      if (candidatePath === targetPath) {
+        RESOLVED_SESSION_KEY_CACHE.set(targetPath, sessionKey);
+        logger?.info?.(
+          `[mobcode-session-key] resolved sessionFile=${targetPath} sessionKey=${sessionKey}`,
+        );
+        return sessionKey;
+      }
+    }
+  }
+
+  logger?.warn?.(
+    `[mobcode-session-key] unresolved sessionFile=${targetPath} reason=no_matching_store_entry`,
+  );
+  return null;
+}
+

package/src/state-store.js

@@ -814,10 +814,37 @@ export class MobcodeStateStore {
     const alreadyBackfilled =
       typeof existing?.last_backfill_at === "string" && existing.last_backfill_at.trim().length > 0;
     if (alreadyBackfilled) {
+      this.logger?.info?.(
+        `[mobcode-store] ensureSessionIndexed skip session=${normalizedSessionKey} reason=already_backfilled`,
+      );
       return;
     }
+    this.logger?.info?.(
+      `[mobcode-store] ensureSessionIndexed start session=${normalizedSessionKey}`,
+    );
     const messages = Array.isArray(loader) ? loader : await loader();
+    this.logger?.info?.(
+      `[mobcode-store] ensureSessionIndexed loader_result session=${normalizedSessionKey} messages=${Array.isArray(messages) ? messages.length : 0}`,
+    );
     await this.indexSessionMessages(normalizedSessionKey, messages);
+    const indexedCountRow = this._db()
+      .prepare(`SELECT COUNT(*) AS count FROM messages WHERE session_key=?`)
+      .get(normalizedSessionKey);
+    const indexedCount = Number(indexedCountRow?.count ?? 0);
+    if (indexedCount <= 0) {
+      this.logger?.warn?.(
+        `[mobcode-store] ensureSessionIndexed incomplete session=${normalizedSessionKey} reason=no_messages_indexed`,
+      );
+      const now = new Date().toISOString();
+      this._db()
+        .prepare(
+          `INSERT INTO indexed_sessions(session_key, updated_at)
+           VALUES(?, ?)
+           ON CONFLICT(session_key) DO UPDATE SET updated_at=excluded.updated_at`,
+        )
+        .run(normalizedSessionKey, now);
+      return;
+    }
     const now = new Date().toISOString();
     this._db()
       .prepare(
@@ -828,11 +855,17 @@ export class MobcodeStateStore {
            updated_at=excluded.updated_at`,
       )
       .run(normalizedSessionKey, now, now);
+    this.logger?.info?.(
+      `[mobcode-store] ensureSessionIndexed complete session=${normalizedSessionKey} indexedMessages=${indexedCount}`,
+    );
   }
 
   async indexSessionMessages(sessionKey, messages) {
     const normalizedSessionKey = String(sessionKey ?? "").trim();
     if (!normalizedSessionKey || !Array.isArray(messages) || messages.length == 0) {
+      this.logger?.info?.(
+        `[mobcode-store] indexSessionMessages noop session=${normalizedSessionKey || "-"} messages=${Array.isArray(messages) ? messages.length : 0}`,
+      );
       return;
     }
 
@@ -932,13 +965,22 @@ export class MobcodeStateStore {
   }
 
   async appendMessage(update) {
-    const sessionKey = normalizeSessionKey(update?.sessionKey, update?.sessionFile);
+    const sessionKey = String(update?.sessionKey ?? "").trim();
     const normalizedMessage = normalizeMessageObject(update?.message, update?.messageId);
+    if (!sessionKey) {
+      this.logger?.warn?.(
+        `[mobcode-store] appendMessage skipped rawSessionKey=${String(update?.sessionKey ?? "").trim() || "-"} sessionFile=${String(update?.sessionFile ?? "").trim() || "-"} messageId=${String(update?.messageId ?? normalizedMessage?.id ?? "").trim() || "-"} reason=missing_session_key`,
+      );
+      return { sessionKey: null, count: 0, skipped: true };
+    }
+    this.logger?.info?.(
+      `[mobcode-store] appendMessage sessionKey=${sessionKey} rawSessionKey=${String(update?.sessionKey ?? "").trim() || "-"} sessionFile=${String(update?.sessionFile ?? "").trim() || "-"} messageId=${String(update?.messageId ?? normalizedMessage?.id ?? "").trim() || "-"} role=${String(normalizedMessage?.role ?? "").trim() || "-"}`,
+    );
     await this.indexSessionMessages(sessionKey, [normalizedMessage]);
     const row = this._db()
       .prepare(`SELECT COUNT(*) AS count FROM messages WHERE session_key=?`)
       .get(sessionKey);
-    return { sessionKey, count: Number(row?.count ?? 0) };
+    return { sessionKey, count: Number(row?.count ?? 0), skipped: false };
   }
 
   async pageTranscriptMessages(sessionKey) {