fix(memory-wiki): route bridge CLI through gateway

vincentkoc · vincentkoc · commit 705b50b34cdd · 2026-04-28T02:54:58.000-07:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -443,6 +443,7 @@ Docs: https://docs.openclaw.ai
 - TTS/SecretRef: resolve `messages.tts.providers.*.apiKey` from the active runtime snapshot so SecretRef-backed MiniMax and other TTS provider keys work in runtime reply/audio paths. Fixes #68690. Thanks @joshavant.
 - Gateway/install: surface systemd user-bus recovery hints during Linux service activation and retry via the target user scope when `systemctl --user` reports no-medium bus failures, without letting stale `SUDO_USER` override `sudo -u` installs. Fixes #39673; refs #44417 and #63561. Thanks @Arbor4, @myrsu, @mssteuer, and @boyuaner.
 - CLI/nodes: make unfiltered `openclaw nodes list` prefer the effective paired-node view used by `nodes status` while preserving pending rows, pairing-scope fallback, terminal-safe table rendering, and paired JSON metadata. Fixes #46871; carries forward #65772 through the ProjectClownfish #72619 repair. Thanks @skainguyen1412.
+- Memory Wiki/CLI: route active bridge-mode status, doctor, and bridge imports through Gateway RPC so CLI checks use the runtime memory plugin context while disabled bridge imports stay local/offline. Carries forward #67208 and #71479; related #70185. Thanks @moorsecopers99, @vincentkoc, and @prasad-yashdeep.
 - CLI/startup: read generated startup metadata from the bundled `dist` layout before falling back to live help rendering, so root/browser help and channel-option bootstrap stay on the fast path. Thanks @vincentkoc.
 - Feishu/Lark: stop treating broadcast-only `@all`/`@_all` messages as bot mentions while preserving direct bot mentions, including messages that also include `@all`. Fixes #37706. Thanks @JosepLee.
 - CLI/help: treat positional `help` invocations like `openclaw channels help` as help paths for startup gating, avoiding model/auth warmup while preserving positional arguments such as `openclaw docs help`. Thanks @gumadeiras.
diff --git a/docs/cli/wiki.md b/docs/cli/wiki.md
@@ -68,10 +68,18 @@ Inspect current vault mode, health, and Obsidian CLI availability.
 Use this first when you are unsure whether the vault is initialized, bridge mode
 is healthy, or Obsidian integration is available.
 
+When bridge mode is active and configured to read memory artifacts, this command
+queries the running Gateway so it sees the same active memory plugin context as
+agent/runtime memory.
+
 ### `wiki doctor`
 
 Run wiki health checks and surface configuration or vault problems.
 
+When bridge mode is active and configured to read memory artifacts, this command
+queries the running Gateway before building the report. Disabled bridge imports
+and bridge configs that do not read memory artifacts remain local/offline.
+
 Typical issues include:
 
 - bridge mode enabled without public memory artifacts
@@ -168,6 +176,11 @@ source pages.
 Use this in `bridge` mode when you want the latest exported memory artifacts
 pulled into the wiki vault.
 
+For active bridge artifact reads, the CLI routes the import through Gateway RPC
+so the import uses the runtime memory plugin context. If bridge imports are
+disabled or artifact reads are turned off, the command keeps the local/offline
+zero-import behavior.
+
 ### `wiki unsafe-local import`
 
 Import from explicitly configured local paths in `unsafe-local` mode.
diff --git a/docs/plugins/memory-wiki.md b/docs/plugins/memory-wiki.md
@@ -65,6 +65,12 @@ If bridge mode reports zero exported artifacts, the active memory plugin is not
 currently exposing public bridge inputs yet. Run `openclaw wiki doctor` first,
 then confirm the active memory plugin supports public artifacts.
 
+When bridge mode is active and `bridge.readMemoryArtifacts` is enabled,
+`openclaw wiki status`, `openclaw wiki doctor`, and `openclaw wiki bridge
+import` read through the running Gateway. That keeps CLI bridge checks aligned
+with the runtime memory plugin context. If bridge is disabled or artifact reads
+are turned off, those commands keep their local/offline behavior.
+
 ## Vault modes
 
 `memory-wiki` supports three vault modes:
diff --git a/extensions/memory-wiki/src/cli.test.ts b/extensions/memory-wiki/src/cli.test.ts
@@ -3,11 +3,25 @@ import os from "node:os";
 import path from "node:path";
 import { Command } from "commander";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { registerWikiCli, runWikiChatGptImport, runWikiChatGptRollback } from "./cli.js";
+import {
+  registerWikiCli,
+  runWikiBridgeImport,
+  runWikiChatGptImport,
+  runWikiChatGptRollback,
+  runWikiDoctor,
+  runWikiStatus,
+} from "./cli.js";
 import type { MemoryWikiPluginConfig } from "./config.js";
 import { parseWikiMarkdown, renderWikiMarkdown } from "./markdown.js";
+import type { MemoryWikiDoctorReport, MemoryWikiStatus } from "./status.js";
 import { createMemoryWikiTestHarness } from "./test-helpers.js";
 
+const callGatewayFromCliMock = vi.hoisted(() => vi.fn());
+
+vi.mock("openclaw/plugin-sdk/gateway-runtime", () => ({
+  callGatewayFromCli: callGatewayFromCliMock,
+}));
+
 const { createVault } = createMemoryWikiTestHarness();
 let suiteRoot = "";
 let caseIndex = 0;
@@ -24,6 +38,7 @@ describe("memory-wiki cli", () => {
   });
 
   beforeEach(() => {
+    callGatewayFromCliMock.mockReset();
     vi.spyOn(process.stdout, "write").mockImplementation(
       (() => true) as typeof process.stdout.write,
     );
@@ -88,6 +103,45 @@ describe("memory-wiki cli", () => {
     return exportDir;
   }
 
+  function createGatewayStatus(config: {
+    vault: { path: string };
+    bridge: MemoryWikiStatus["bridge"];
+  }): MemoryWikiStatus {
+    return {
+      vaultMode: "bridge",
+      renderMode: "native",
+      vaultPath: config.vault.path,
+      vaultExists: true,
+      bridge: config.bridge,
+      bridgePublicArtifactCount: 2,
+      obsidianCli: {
+        enabled: false,
+        requested: false,
+        available: false,
+        command: null,
+      },
+      unsafeLocal: {
+        allowPrivateMemoryCoreAccess: false,
+        pathCount: 0,
+      },
+      pageCounts: {
+        source: 0,
+        entity: 0,
+        concept: 0,
+        synthesis: 0,
+        report: 0,
+      },
+      sourceCounts: {
+        native: 0,
+        bridge: 0,
+        bridgeEvents: 0,
+        unsafeLocal: 0,
+        other: 0,
+      },
+      warnings: [],
+    };
+  }
+
   it("registers apply synthesis and writes a synthesis page", async () => {
     const { rootDir, config } = await createCliVault();
     const program = new Command();
@@ -193,6 +247,185 @@ cli note
     await program.parseAsync(["wiki", "doctor", "--json"], { from: "user" });
 
     expect(process.exitCode).toBe(1);
+    expect(callGatewayFromCliMock).not.toHaveBeenCalled();
+  });
+
+  it("routes active bridge status and doctor through the gateway", async () => {
+    const { config } = await createCliVault({
+      config: {
+        vaultMode: "bridge",
+        bridge: { enabled: true, readMemoryArtifacts: true },
+      },
+      initialize: true,
+    });
+    const status = createGatewayStatus(config);
+    const report: MemoryWikiDoctorReport = {
+      healthy: false,
+      warningCount: 1,
+      status: {
+        ...status,
+        warnings: [
+          {
+            code: "bridge-artifacts-missing",
+            message: "No exported artifacts.",
+          },
+        ],
+      },
+      fixes: [
+        {
+          code: "bridge-artifacts-missing",
+          message: "Create memory artifacts.",
+        },
+      ],
+    };
+    callGatewayFromCliMock.mockResolvedValueOnce(status).mockResolvedValueOnce(report);
+
+    await expect(runWikiStatus({ config, json: true })).resolves.toBe(status);
+    await expect(runWikiDoctor({ config, json: true })).resolves.toBe(report);
+
+    expect(process.exitCode).toBe(1);
+    expect(callGatewayFromCliMock).toHaveBeenNthCalledWith(
+      1,
+      "wiki.status",
+      { timeout: "30000" },
+      undefined,
+      { progress: false },
+    );
+    expect(callGatewayFromCliMock).toHaveBeenNthCalledWith(
+      2,
+      "wiki.doctor",
+      { timeout: "30000" },
+      undefined,
+      { progress: false },
+    );
+  });
+
+  it("sanitizes gateway status text output without changing JSON output", async () => {
+    const { config } = await createCliVault({
+      config: {
+        vaultMode: "bridge",
+        bridge: { enabled: true, readMemoryArtifacts: true },
+      },
+      initialize: true,
+    });
+    const unsafeStatus = createGatewayStatus({
+      ...config,
+      vault: { path: "\u001B[2J/tmp/wiki\nforged prompt" },
+    });
+    unsafeStatus.warnings = [
+      {
+        code: "bridge-artifacts-missing",
+        message: "missing artifacts\r\nfake success\u001B[31m",
+      },
+    ];
+    const textOutput: string[] = [];
+    callGatewayFromCliMock.mockResolvedValueOnce(unsafeStatus);
+
+    await runWikiStatus({
+      config,
+      stdout: {
+        write: ((chunk: string) => textOutput.push(chunk) > 0) as NodeJS.WriteStream["write"],
+      },
+    });
+
+    const renderedText = textOutput.join("");
+    expect(renderedText).not.toContain("\u001B");
+    expect(renderedText).toContain("(/tmp/wiki forged prompt)");
+    expect(renderedText).toContain("- missing artifacts fake success");
+
+    const jsonOutput: string[] = [];
+    callGatewayFromCliMock.mockResolvedValueOnce(unsafeStatus);
+
+    await runWikiStatus({
+      config,
+      json: true,
+      stdout: {
+        write: ((chunk: string) => jsonOutput.push(chunk) > 0) as NodeJS.WriteStream["write"],
+      },
+    });
+
+    const renderedJson = jsonOutput.join("");
+    expect(renderedJson).not.toContain("\u001B");
+    expect(renderedJson).not.toContain("\r");
+    expect(renderedJson).toContain("\\u001b[2J/tmp/wiki\\nforged prompt");
+    expect(renderedJson).toContain("missing artifacts\\r\\nfake success\\u001b[31m");
+
+    const parsed = JSON.parse(renderedJson) as MemoryWikiStatus;
+    expect(parsed.vaultPath).toBe("\u001B[2J/tmp/wiki\nforged prompt");
+    expect(parsed.warnings[0]?.message).toBe("missing artifacts\r\nfake success\u001B[31m");
+  });
+
+  it("limits gateway status arrays before terminal rendering", async () => {
+    const { config } = await createCliVault({
+      config: {
+        vaultMode: "bridge",
+        bridge: { enabled: true, readMemoryArtifacts: true },
+      },
+      initialize: true,
+    });
+    const status = createGatewayStatus(config);
+    status.warnings = Array.from({ length: 250 }, (_, index) => ({
+      code: "bridge-artifacts-missing",
+      message: `warning ${index}`,
+    }));
+    const textOutput: string[] = [];
+    callGatewayFromCliMock.mockResolvedValueOnce(status);
+
+    await runWikiStatus({
+      config,
+      stdout: {
+        write: ((chunk: string) => textOutput.push(chunk) > 0) as NodeJS.WriteStream["write"],
+      },
+    });
+
+    const renderedText = textOutput.join("");
+    expect(renderedText).toContain("warning 199");
+    expect(renderedText).not.toContain("warning 200");
+  });
+
+  it("routes active bridge imports through the gateway and keeps disabled bridge imports local", async () => {
+    const active = await createCliVault({
+      config: {
+        vaultMode: "bridge",
+        bridge: { enabled: true, readMemoryArtifacts: true },
+      },
+      initialize: true,
+    });
+    callGatewayFromCliMock.mockResolvedValueOnce({
+      importedCount: 1,
+      updatedCount: 0,
+      skippedCount: 0,
+      removedCount: 0,
+      artifactCount: 1,
+      workspaces: 1,
+      pagePaths: ["sources/bridge-alpha.md"],
+      indexesRefreshed: true,
+      indexUpdatedFiles: ["index.md"],
+      indexRefreshReason: "import-changed",
+    });
+
+    const activeResult = await runWikiBridgeImport({ config: active.config, json: true });
+
+    expect(activeResult.importedCount).toBe(1);
+    expect(callGatewayFromCliMock).toHaveBeenCalledWith(
+      "wiki.bridge.import",
+      { timeout: "30000" },
+      undefined,
+      { progress: false },
+    );
+
+    callGatewayFromCliMock.mockClear();
+    const disabled = await createCliVault({
+      config: {
+        vaultMode: "bridge",
+        bridge: { enabled: false },
+      },
+    });
+
+    const disabledResult = await runWikiBridgeImport({ config: disabled.config, json: true });
+
+    expect(disabledResult.artifactCount).toBe(0);
+    expect(callGatewayFromCliMock).not.toHaveBeenCalled();
   });
 
   it("imports ChatGPT exports with dry-run, apply, and rollback", async () => {
diff --git a/extensions/memory-wiki/src/cli.ts b/extensions/memory-wiki/src/cli.ts
