@unblocklabs/unblock-memory 0.2.2 → 0.2.3

package/dist/src/plugin.js

@@ -96,7 +96,7 @@ function createSyncSessionsTool(runtime, ctx) {
         parameters: syncSessionsParameters,
         async execute(_toolCallId, params) {
             const { force } = Value.Parse(syncSessionsParameters, params);
-            return jsonResult(runtime.startSessionSync(active, force));
+            return jsonResult(await runtime.startSessionSync(active, force));
         },
     };
 }
@@ -111,7 +111,7 @@ function createSyncStatusTool(runtime, ctx) {
         parameters: syncStatusParameters,
         async execute(_toolCallId, params) {
             Value.Parse(syncStatusParameters, params);
-            return jsonResult(runtime.sessionSyncStatus(active.agentId));
+            return jsonResult(await runtime.sessionSyncStatus(active.agentId));
         },
     };
 }

package/dist/src/runtime.d.ts

@@ -29,9 +29,18 @@ export type SessionSyncStartResult = {
     status: "unavailable";
     error: string;
 };
+type StoredSessionSyncStatus = Exclude<SessionSyncStatus, {
+    status: "idle";
+}>;
+type StoredRunningSessionSync = Extract<StoredSessionSyncStatus, {
+    status: "running";
+}> & {
+    pid: number;
+};
+export declare function recoverInterruptedSessionSync(directory: string, statusPath: string, stale: StoredRunningSessionSync): Promise<SessionSyncStatus>;
 export declare class QmdMemoryRuntime implements MemoryPluginRuntimeContract {
     #private;
-    constructor(corpora: readonly CorpusConfig[], analysisExecutable?: string);
+    constructor(corpora: readonly CorpusConfig[], analysisExecutable?: string, stateRoot?: string);
     getMemorySearchManager(params: {
         cfg: OpenClawConfig;
         agentId: string;
@@ -49,10 +58,11 @@ export declare class QmdMemoryRuntime implements MemoryPluginRuntimeContract {
     startSessionSync(params: {
         cfg: OpenClawConfig;
         agentId: string;
-    }, force?: boolean): SessionSyncStartResult;
-    sessionSyncStatus(agentId: string): SessionSyncStatus;
+    }, force?: boolean): Promise<SessionSyncStartResult>;
+    sessionSyncStatus(agentId: string): Promise<SessionSyncStatus>;
     closeMemorySearchManager(params: {
         agentId: string;
     }): Promise<void>;
     closeAllMemorySearchManagers(): Promise<void>;
 }
+export {};

package/dist/src/runtime.js

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { resolveAgentDir, resolveAgentWorkspaceDir, resolveStateDir, } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";
 import { resolveAgentIdentity } from "openclaw/plugin-sdk/agent-runtime";
@@ -5,14 +7,70 @@ import { QmdMemoryManager } from "./manager.js";
 import { resolveTimezone } from "./session-projector.js";
 import { resolveSessionSource, resolveSources } from "./sources.js";
 import { classifyWorkspaceMemoryPaths } from "./workspace-path-classifier.js";
+const activeSessionSyncs = new Map();
+async function readJson(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function removeIfPresent(path) {
+    try {
+        await unlink(path);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function atomicWriteJson(path, value) {
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+        await rename(temporary, path);
+    }
+    finally {
+        await removeIfPresent(temporary);
+    }
+}
+export async function recoverInterruptedSessionSync(directory, statusPath, stale) {
+    activeSessionSyncs.set(directory, stale.startedAt);
+    try {
+        const current = await readJson(statusPath);
+        if (!current)
+            return { status: "idle" };
+        if (current.status !== "running")
+            return current;
+        if (current.startedAt !== stale.startedAt) {
+            return { status: "running", phase: current.phase, startedAt: current.startedAt };
+        }
+        const failed = {
+            status: "failed",
+            startedAt: stale.startedAt,
+            completedAt: new Date().toISOString(),
+            error: "session sync interrupted by Gateway restart",
+        };
+        await atomicWriteJson(statusPath, failed);
+        return failed;
+    }
+    finally {
+        if (activeSessionSyncs.get(directory) === stale.startedAt)
+            activeSessionSyncs.delete(directory);
+    }
+}
 export class QmdMemoryRuntime {
     #corpora;
     #analysisExecutable;
+    #stateRoot;
     #managers = new Map();
-    #sessionSyncStatuses = new Map();
-    constructor(corpora, analysisExecutable) {
+    constructor(corpora, analysisExecutable, stateRoot = resolveStateDir()) {
         this.#corpora = corpora;
         this.#analysisExecutable = analysisExecutable;
+        this.#stateRoot = stateRoot;
     }
     async getMemorySearchManager(params) {
         let pending = this.#managers.get(params.agentId);
@@ -32,46 +90,93 @@ export class QmdMemoryRuntime {
         return { backend: "builtin" };
     }
     classifyWorkspaceMemoryPaths = classifyWorkspaceMemoryPaths;
-    startSessionSync(params, force = false) {
+    async startSessionSync(params, force = false) {
         if (!this.#corpora.some((corpus) => corpus.kind === "sessions")) {
             return {
                 status: "unavailable",
                 error: 'memory session sync requires a configured "sessions" corpus',
             };
         }
-        const current = this.sessionSyncStatus(params.agentId);
-        if (current.status === "running") {
-            return { status: "already_running", startedAt: current.startedAt };
-        }
+        const directory = this.#sessionSyncDirectory(params.agentId);
+        const statusPath = join(directory, "session-sync-status.json");
+        const running = activeSessionSyncs.get(directory);
+        if (running)
+            return { status: "already_running", startedAt: running };
         const startedAt = new Date().toISOString();
-        this.#sessionSyncStatuses.set(params.agentId, { status: "running", phase: "queued", startedAt });
-        const run = async () => {
-            const { manager, error } = await this.getMemorySearchManager(params);
-            if (!manager)
-                throw new Error(error ?? "memory unavailable");
-            return await manager.syncSessions(force, (phase) => {
-                this.#sessionSyncStatuses.set(params.agentId, { status: "running", phase, startedAt });
-            });
-        };
-        void run().then((result) => {
-            this.#sessionSyncStatuses.set(params.agentId, {
-                status: "completed",
-                startedAt,
-                completedAt: new Date().toISOString(),
-                ...result,
-            });
-        }, (error) => {
-            this.#sessionSyncStatuses.set(params.agentId, {
-                status: "failed",
+        activeSessionSyncs.set(directory, startedAt);
+        try {
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            await atomicWriteJson(statusPath, {
+                status: "running",
+                phase: "queued",
+                pid: process.pid,
                 startedAt,
-                completedAt: new Date().toISOString(),
-                error: error instanceof Error ? error.message : String(error),
             });
-        });
+        }
+        catch (error) {
+            if (activeSessionSyncs.get(directory) === startedAt)
+                activeSessionSyncs.delete(directory);
+            throw error;
+        }
+        void (async () => {
+            let statusWrites = Promise.resolve();
+            const writePhase = (phase) => {
+                statusWrites = statusWrites.then(() => atomicWriteJson(statusPath, {
+                    status: "running",
+                    phase,
+                    pid: process.pid,
+                    startedAt,
+                }));
+            };
+            try {
+                const { manager, error } = await this.getMemorySearchManager(params);
+                if (!manager)
+                    throw new Error(error ?? "memory unavailable");
+                const result = await manager.syncSessions(force, writePhase);
+                await statusWrites;
+                await atomicWriteJson(statusPath, {
+                    status: "completed",
+                    startedAt,
+                    completedAt: new Date().toISOString(),
+                    ...result,
+                });
+            }
+            catch (error) {
+                await statusWrites.catch(() => { });
+                try {
+                    await atomicWriteJson(statusPath, {
+                        status: "failed",
+                        startedAt,
+                        completedAt: new Date().toISOString(),
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                catch {
+                    // The next status read converts the persisted running state to interrupted.
+                }
+            }
+            finally {
+                if (activeSessionSyncs.get(directory) === startedAt)
+                    activeSessionSyncs.delete(directory);
+            }
+        })().catch(() => { });
         return { status: "started", startedAt };
     }
-    sessionSyncStatus(agentId) {
-        return this.#sessionSyncStatuses.get(agentId) ?? { status: "idle" };
+    async sessionSyncStatus(agentId) {
+        const directory = this.#sessionSyncDirectory(agentId);
+        const statusPath = join(directory, "session-sync-status.json");
+        const status = await readJson(statusPath);
+        const running = activeSessionSyncs.get(directory);
+        if (running) {
+            return status?.status === "running" && status.startedAt === running
+                ? { status: "running", phase: status.phase, startedAt: running }
+                : { status: "running", phase: "queued", startedAt: running };
+        }
+        if (!status)
+            return { status: "idle" };
+        if (status.status !== "running")
+            return status;
+        return await recoverInterruptedSessionSync(directory, statusPath, status);
     }
     async closeMemorySearchManager(params) {
         const pending = this.#managers.get(params.agentId);
@@ -85,7 +190,7 @@ export class QmdMemoryRuntime {
     }
     async #createManager(cfg, agentId) {
         const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
-        const stateDir = join(resolveStateDir(), "agents", agentId, "unblock-memory");
+        const stateDir = join(this.#stateRoot, "agents", agentId, "unblock-memory");
         const fileCorpora = this.#corpora.filter((corpus) => corpus.kind === "files");
         const sessionCorpus = this.#corpora.find((corpus) => corpus.kind === "sessions");
         const sources = resolveSources(workspaceDir, fileCorpora);
@@ -115,4 +220,7 @@ export class QmdMemoryRuntime {
         await manager.start();
         return manager;
     }
+    #sessionSyncDirectory(agentId) {
+        return join(this.#stateRoot, "agents", agentId, "unblock-memory");
+    }
 }

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
   "activation": { "onStartup": false },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unblocklabs/unblock-memory",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Workspace-native memory for OpenClaw, powered by QMD",
   "type": "module",
   "license": "MIT",