@echomem/echo-memory-cloud-openclaw-plugin 0.2.1 → 0.2.3

package/clawdbot.plugin.json

@@ -2,7 +2,7 @@
   "id": "echo-memory-cloud-openclaw-plugin",
   "name": "Echo Memory Cloud OpenClaw Plugin",
   "description": "Sync OpenClaw local markdown memory files to Echo cloud",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "kind": "lifecycle",
   "main": "./index.js",
   "configSchema": {

package/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import path from "node:path";
-import { buildConfig, getEnvFileStatus } from "./lib/config.js";
+import { buildConfig, getEnvFileStatus, getOpenClawHome } from "./lib/config.js";
 import { createApiClient } from "./lib/api-client.js";
 import { formatSearchResultsText } from "./lib/echo-memory-search.js";
 import {
@@ -16,13 +16,34 @@ import { buildOnboardingText } from "./lib/onboarding.js";
 import { createSyncRunner, formatStatusText } from "./lib/sync.js";
 import { readLastSyncState } from "./lib/state.js";
 import {
+  hasRecentLocalUiPresence,
   openUrlInDefaultBrowser,
   startLocalServer,
   stopLocalServer,
   waitForLocalUiClient,
 } from "./lib/local-server.js";
 
-const LOCAL_UI_RECONNECT_GRACE_MS = 1500;
+const LOCAL_UI_RECONNECT_GRACE_MS = 4000;
+const LOCAL_UI_PRESENCE_GRACE_MS = 75000;
+const COMPAT_STARTUP_DELAY_MS = 1500;
+const PROCESS_STATE_KEY = Symbol.for("echo-memory-cloud-openclaw-plugin.process-state");
+
+function getProcessState() {
+  const globalState = globalThis;
+  if (!globalState[PROCESS_STATE_KEY]) {
+    globalState[PROCESS_STATE_KEY] = {
+      backgroundActive: false,
+      backgroundOwnerId: null,
+      backgroundStartPromise: null,
+      browserOpenAttempted: false,
+      browserOpenPromise: null,
+      compatFallbackScheduled: false,
+      serviceStartObserved: false,
+      stopBackground: null,
+    };
+  }
+  return globalState[PROCESS_STATE_KEY];
+}
 
 function resolveCommandLabel(channel) {
   return channel === "discord" ? "/echomemory" : "/echo-memory";
@@ -51,25 +72,67 @@ export default {
   kind: "lifecycle",
 
   register(api) {
+    const processState = getProcessState();
+    const registrationId = Symbol("echo-memory-cloud-openclaw-plugin.register");
     const cfg = buildConfig(api.pluginConfig);
     const client = createApiClient(cfg);
     const workspaceDir = path.resolve(path.dirname(cfg.memoryDir), "..");
-    const openclawHome = path.resolve(workspaceDir, "..");
-    const fallbackStateDir = path.join(openclawHome, "state", "plugins", "echo-memory-cloud-openclaw-plugin");
+    const openclawHome = getOpenClawHome();
+    const legacyPluginStateDir = path.join(openclawHome, "state", "plugins", "echo-memory-cloud-openclaw-plugin");
+    const stableStateDir = path.join(openclawHome, "state", "echo-memory-cloud-openclaw-plugin");
     const syncRunner = createSyncRunner({
       api,
       cfg,
       client,
-      fallbackStateDir,
+      fallbackStateDir: legacyPluginStateDir,
+      stableStateDir,
     });
-    let startupBrowserOpenAttempted = false;
-    let backgroundStarted = false;
-    let serviceStartObserved = false;
 
     if (!workspaceDir || workspaceDir === "." || workspaceDir === path.sep) {
       api.logger?.warn?.("[echo-memory] workspace resolution looks unusual; compatibility fallback may be limited");
     }
 
+    async function maybeAutoOpenLocalUi(url, { trigger = "manual" } = {}) {
+      const existingPageDetected = trigger === "gateway-start"
+        ? await hasRecentLocalUiPresence(syncRunner, { maxAgeMs: LOCAL_UI_PRESENCE_GRACE_MS })
+        : false;
+      const existingClientDetected = existingPageDetected || (
+        trigger === "gateway-start"
+          ? await waitForLocalUiClient({ timeoutMs: LOCAL_UI_RECONNECT_GRACE_MS })
+          : false
+      );
+      return existingClientDetected
+        ? { opened: false, reason: existingPageDetected ? "existing_page_detected" : "existing_client_reconnected" }
+        : openUrlInDefaultBrowser(url, {
+            logger: api.logger,
+            force: trigger !== "gateway-start",
+          });
+    }
+
+    async function maybeAutoOpenStartupBrowser(url) {
+      if (!cfg.localUiAutoOpenOnGatewayStart || processState.browserOpenAttempted) {
+        return { attempted: false, opened: false, reason: "disabled_or_already_attempted" };
+      }
+      if (processState.browserOpenPromise) {
+        const result = await processState.browserOpenPromise;
+        return { attempted: false, ...result };
+      }
+
+      const openPromise = maybeAutoOpenLocalUi(url, { trigger: "gateway-start" })
+        .then((result) => {
+          processState.browserOpenAttempted = true;
+          return result;
+        })
+        .finally(() => {
+          if (processState.browserOpenPromise === openPromise) {
+            processState.browserOpenPromise = null;
+          }
+        });
+      processState.browserOpenPromise = openPromise;
+      const result = await openPromise;
+      return { attempted: true, ...result };
+    }
+
     async function ensureLocalUi({ openInBrowser = false, trigger = "manual" } = {}) {
       const url = await startLocalServer(workspaceDir, {
         apiClient: client,
@@ -82,15 +145,7 @@ export default {
       let openedInBrowser = false;
       let openReason = "not_requested";
       if (openInBrowser) {
-        const existingClientDetected = trigger === "gateway-start"
-          ? await waitForLocalUiClient({ timeoutMs: LOCAL_UI_RECONNECT_GRACE_MS })
-          : false;
-        const openResult = existingClientDetected
-          ? { opened: false, reason: "existing_client_reconnected" }
-          : await openUrlInDefaultBrowser(url, {
-              logger: api.logger,
-              force: trigger !== "gateway-start",
-            });
+        const openResult = await maybeAutoOpenLocalUi(url, { trigger });
         openedInBrowser = openResult.opened;
         openReason = openResult.reason;
       }
@@ -161,68 +216,150 @@ export default {
     }
 
     async function startBackgroundFeatures({ stateDir = null, trigger = "service" } = {}) {
-      if (backgroundStarted) {
-        return;
-      }
-      backgroundStarted = true;
-      await syncRunner.initialize(stateDir || fallbackStateDir);
-
-      try {
-        const shouldOpenBrowser = cfg.localUiAutoOpenOnGatewayStart && !startupBrowserOpenAttempted;
-        const { url, openedInBrowser, openReason } = await ensureLocalUi({
-          openInBrowser: shouldOpenBrowser,
-          trigger: trigger === "service" ? "gateway-start" : trigger,
-        });
-        api.logger?.info?.(`[echo-memory] Local workspace viewer: ${url}`);
-        if (shouldOpenBrowser) {
-          startupBrowserOpenAttempted = true;
-          if (openedInBrowser) {
-            api.logger?.info?.("[echo-memory] Opened local workspace viewer in the default browser");
-          } else {
-            api.logger?.info?.(`[echo-memory] Skipped browser auto-open (${openReason})`);
+      const effectiveTrigger = trigger === "service" ? "gateway-start" : trigger;
+
+      if (processState.backgroundActive) {
+        if (effectiveTrigger === "gateway-start") {
+          const { attempted, opened, reason } = await maybeAutoOpenStartupBrowser(
+            await startLocalServer(workspaceDir, {
+              apiClient: client,
+              syncRunner,
+              cfg,
+              logger: api.logger,
+              pluginConfig: api.pluginConfig,
+            }),
+          );
+          if (attempted) {
+            if (opened) {
+              api.logger?.info?.("[echo-memory] Opened local workspace viewer in the default browser");
+            } else {
+              api.logger?.info?.(`[echo-memory] Skipped browser auto-open (${reason})`);
+            }
           }
         }
-      } catch (error) {
-        api.logger?.warn?.(`[echo-memory] local server failed: ${String(error?.message ?? error)}`);
+        return;
       }
 
-      if (!cfg.autoSync) {
-        api.logger?.info?.("[echo-memory] autoSync disabled");
+      if (processState.backgroundStartPromise) {
+        await processState.backgroundStartPromise;
+        if (effectiveTrigger === "gateway-start") {
+          const { attempted, opened, reason } = await maybeAutoOpenStartupBrowser(
+            await startLocalServer(workspaceDir, {
+              apiClient: client,
+              syncRunner,
+              cfg,
+              logger: api.logger,
+              pluginConfig: api.pluginConfig,
+            }),
+          );
+          if (attempted) {
+            if (opened) {
+              api.logger?.info?.("[echo-memory] Opened local workspace viewer in the default browser");
+            } else {
+              api.logger?.info?.(`[echo-memory] Skipped browser auto-open (${reason})`);
+            }
+          }
+        }
         return;
       }
 
-      await syncRunner.runSync(trigger === "service" ? "startup" : trigger).catch((error) => {
-        api.logger?.warn?.(`[echo-memory] startup sync failed: ${String(error?.message ?? error)}`);
-      });
+      const startPromise = (async () => {
+        processState.backgroundOwnerId = registrationId;
+        processState.stopBackground = () => {
+          syncRunner.stopInterval();
+          stopLocalServer();
+        };
+        await syncRunner.initialize(stateDir || legacyPluginStateDir);
+
+        let url = null;
+        try {
+          const localUi = await ensureLocalUi({
+            openInBrowser: false,
+            trigger: effectiveTrigger,
+          });
+          url = localUi.url;
+          api.logger?.info?.(`[echo-memory] Local workspace viewer: ${url}`);
+        } catch (error) {
+          api.logger?.warn?.(`[echo-memory] local server failed: ${String(error?.message ?? error)}`);
+        }
+
+        processState.backgroundActive = true;
+
+        if (effectiveTrigger === "gateway-start" && url) {
+          const { attempted, opened, reason } = await maybeAutoOpenStartupBrowser(url);
+          if (attempted) {
+            if (opened) {
+              api.logger?.info?.("[echo-memory] Opened local workspace viewer in the default browser");
+            } else {
+              api.logger?.info?.(`[echo-memory] Skipped browser auto-open (${reason})`);
+            }
+          }
+        }
+
+        if (!cfg.autoSync) {
+          api.logger?.info?.("[echo-memory] autoSync disabled");
+          return;
+        }
+
+        await syncRunner.runSync(trigger === "service" ? "startup" : trigger).catch((error) => {
+          api.logger?.warn?.(`[echo-memory] startup sync failed: ${String(error?.message ?? error)}`);
+        });
 
-      syncRunner.startInterval();
+        syncRunner.startInterval();
+      })()
+        .catch((error) => {
+          if (processState.backgroundOwnerId === registrationId) {
+            processState.backgroundActive = false;
+            processState.backgroundOwnerId = null;
+            processState.stopBackground = null;
+          }
+          throw error;
+        })
+        .finally(() => {
+          if (processState.backgroundStartPromise === startPromise) {
+            processState.backgroundStartPromise = null;
+          }
+        });
+
+      processState.backgroundStartPromise = startPromise;
+      await startPromise;
     }
 
     if (typeof api.registerService === "function") {
       api.registerService({
         id: "echo-memory-cloud-openclaw-sync",
         start: async (ctx) => {
-          serviceStartObserved = true;
+          processState.serviceStartObserved = true;
           await startBackgroundFeatures({ stateDir: ctx?.stateDir || null, trigger: "service" });
         },
         stop: async () => {
-          syncRunner.stopInterval();
-          stopLocalServer();
-          backgroundStarted = false;
+          processState.stopBackground?.();
+          processState.backgroundActive = false;
+          processState.backgroundOwnerId = null;
+          processState.backgroundStartPromise = null;
+          processState.browserOpenAttempted = false;
+          processState.browserOpenPromise = null;
+          processState.compatFallbackScheduled = false;
+          processState.serviceStartObserved = false;
+          processState.stopBackground = null;
         },
       });
     }
 
     // Compatibility fallback for older hosts that discover the plugin but do not
     // reliably auto-start registered background services.
-    queueMicrotask(() => {
-      if (serviceStartObserved) {
-        return;
-      }
-      startBackgroundFeatures({ stateDir: fallbackStateDir, trigger: "compat-startup" }).catch((error) => {
-        api.logger?.warn?.(`[echo-memory] compatibility startup failed: ${String(error?.message ?? error)}`);
-      });
-    });
+    if (!processState.compatFallbackScheduled) {
+      processState.compatFallbackScheduled = true;
+      setTimeout(() => {
+        processState.compatFallbackScheduled = false;
+        if (processState.serviceStartObserved || processState.backgroundActive || processState.backgroundStartPromise) {
+          return;
+        }
+        startBackgroundFeatures({ stateDir: legacyPluginStateDir, trigger: "compat-startup" }).catch((error) => {
+          api.logger?.warn?.(`[echo-memory] compatibility startup failed: ${String(error?.message ?? error)}`);
+        });
+      }, COMPAT_STARTUP_DELAY_MS);
+    }
 
     if (typeof api.registerCommand === "function") {
       api.registerCommand({

package/lib/config.js

@@ -122,6 +122,10 @@ export function getEnvFileStatus() {
   };
 }
 
+export function getOpenClawHome() {
+  return OPENCLAW_HOME;
+}
+
 function resolveConfigValue(pluginConfig, configKey, envKey, fallback) {
   if (pluginConfig?.[configKey] !== undefined && pluginConfig?.[configKey] !== null && pluginConfig?.[configKey] !== "") {
     return {