@zbruceli/openclaw-dchat 0.2.0 → 0.4.0

package/.claude/settings.local.json

@@ -4,7 +4,9 @@
       "WebFetch(domain:docs.openclaw.ai)",
       "Bash(node:*)",
       "Bash(ls:*)",
-      "Bash(npm test:*)"
+      "Bash(npm test:*)",
+      "Bash(npm run:*)",
+      "Bash(openclaw status:*)"
     ]
   }
 }

package/index.ts

@@ -1,5 +1,5 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk/core";
 import { dchatPlugin } from "./src/channel.js";
 import { setDchatRuntime } from "./src/runtime.js";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zbruceli/openclaw-dchat",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "OpenClaw D-Chat/nMobile channel plugin — decentralized E2E encrypted messaging over the NKN relay network",
   "type": "module",
   "main": "index.ts",

package/src/channel.ts

@@ -1,19 +1,21 @@
 import {
   applyAccountNameToChannelSection,
-  buildBaseAccountStatusSnapshot,
-  buildBaseChannelStatusSummary,
   buildChannelConfigSchema,
-  collectStatusIssuesFromLastError,
-  createDefaultChannelRuntimeState,
   DEFAULT_ACCOUNT_ID,
   deleteAccountFromConfigSection,
   normalizeAccountId,
-  resolveOutboundMediaUrls,
-  resolveSenderCommandAuthorization,
   setAccountEnabledInConfigSection,
   type ChannelPlugin,
-} from "openclaw/plugin-sdk";
-import type { PluginRuntime } from "openclaw/plugin-sdk";
+  type PluginRuntime,
+} from "openclaw/plugin-sdk/core";
+import {
+  buildBaseAccountStatusSnapshot,
+  buildBaseChannelStatusSummary,
+  collectStatusIssuesFromLastError,
+  createDefaultChannelRuntimeState,
+} from "openclaw/plugin-sdk/status-helpers";
+import { resolveOutboundMediaUrls } from "openclaw/plugin-sdk/reply-payload";
+import { resolveSenderCommandAuthorization } from "openclaw/plugin-sdk/command-auth";
 
 /* ── Inline helpers that may not exist in older OpenClaw versions ── */
 
@@ -30,7 +32,7 @@ function createScopedPairingAccess(params: {
         channel: params.channel,
         accountId: resolvedAccountId,
       }),
-    upsertPairingRequest: (input: { id: string; meta?: Record<string, unknown> }) =>
+    upsertPairingRequest: (input: { id: string; meta?: Record<string, string | null | undefined> }) =>
       params.core.channel.pairing.upsertPairingRequest({
         channel: params.channel,
         accountId: resolvedAccountId,
@@ -51,7 +53,7 @@ import {
   resolveDefaultDchatAccountId,
 } from "./config-schema.js";
 import { NknBus } from "./nkn-bus.js";
-import { dchatOnboardingAdapter } from "./onboarding.js";
+import { dchatSetupWizard } from "./onboarding.js";
 import { getDchatRuntime } from "./runtime.js";
 import { SeenTracker } from "./seen-tracker.js";
 import type { ResolvedDchatAccount } from "./types.js";
@@ -92,7 +94,7 @@ function getBusForAccount(accountId: string): NknBus | undefined {
 export const dchatPlugin: ChannelPlugin<ResolvedDchatAccount> = {
   id: "dchat",
   meta,
-  onboarding: dchatOnboardingAdapter,
+  setupWizard: dchatSetupWizard,
   capabilities: {
     chatTypes: ["direct", "group"],
     media: true,
@@ -138,7 +140,7 @@ export const dchatPlugin: ChannelPlugin<ResolvedDchatAccount> = {
       name: account.name,
       enabled: account.enabled,
       configured: account.configured,
-      nknAddress: account.nknAddress ?? null,
+      publicKey: account.nknAddress ?? null,
     }),
     resolveAllowFrom: ({ cfg, accountId }) => {
       const dchatConfig = resolveDchatAccountConfig({ cfg: cfg as CoreConfig, accountId });
@@ -407,15 +409,15 @@ export const dchatPlugin: ChannelPlugin<ResolvedDchatAccount> = {
     },
     buildChannelSummary: ({ snapshot }) => ({
       ...buildBaseChannelStatusSummary(snapshot),
-      nknAddress: snapshot.nknAddress ?? null,
+      publicKey: snapshot.publicKey ?? null,
       connected: snapshot.connected ?? false,
       lastConnectedAt: snapshot.lastConnectedAt ?? null,
     }),
     buildAccountSnapshot: ({ account, runtime }) => ({
       ...buildBaseAccountStatusSnapshot({ account, runtime }),
-      nknAddress: account.nknAddress ?? null,
-      connected: (runtime as Record<string, unknown>)?.connected ?? false,
-      lastConnectedAt: (runtime as Record<string, unknown>)?.lastConnectedAt ?? null,
+      publicKey: account.nknAddress ?? null,
+      connected: Boolean(runtime?.connected),
+      lastConnectedAt: runtime?.lastConnectedAt ?? null,
     }),
     collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("dchat", accounts),
   },
@@ -438,6 +440,39 @@ export const dchatPlugin: ChannelPlugin<ResolvedDchatAccount> = {
       const seenTracker = new SeenTracker();
       seenMap.set(account.accountId, seenTracker);
 
+      // Listen for heartbeat events
+      bus.on("heartbeat", ({ success, failures }: { success: boolean; failures: number }) => {
+        if (!success) {
+          logger.warn(`[${account.accountId}] heartbeat echo failed (${failures} consecutive)`);
+        }
+      });
+      bus.on("heartbeatReconnect", ({ failures }: { failures: number }) => {
+        logger.warn(
+          `[${account.accountId}] heartbeat failed ${failures} times, reconnecting...`,
+        );
+        ctx.setStatus({ accountId: account.accountId, connected: false });
+      });
+      let initialConnectDone = false;
+      bus.on("stateChange", (state: string) => {
+        if (state === "connected" && initialConnectDone) {
+          ctx.setStatus({
+            accountId: account.accountId,
+            connected: true,
+            lastConnectedAt: Date.now(),
+          });
+          logger.info(`[${account.accountId}] reconnected as ${bus.getAddress()}`);
+        }
+      });
+      bus.on("reconnectFailed", (err: unknown) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.error(`[${account.accountId}] reconnect failed: ${msg}`);
+        ctx.setStatus({
+          accountId: account.accountId,
+          connected: false,
+          lastError: `reconnect failed: ${msg}`,
+        });
+      });
+
       try {
         const address = await bus.connect(
           { seed: account.seed, numSubClients: account.numSubClients },
@@ -453,6 +488,7 @@ export const dchatPlugin: ChannelPlugin<ResolvedDchatAccount> = {
           lastConnectedAt: Date.now(),
         });
         logger.info(`[${account.accountId}] connected as ${address}`);
+        initialConnectDone = true;
 
         // Register inbound message handler
         bus.onMessage((rawSrc, rawPayload) => {

package/src/config-schema.ts

@@ -1,5 +1,5 @@
 import nkn from "nkn-sdk";
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { z } from "zod";
 import type { DchatAccountConfig, ResolvedDchatAccount } from "./types.js";
 

package/src/nkn-bus.ts

@@ -5,12 +5,20 @@ import { NKN_SEED_RPC_SERVERS, type NknConnectionState } from "./types.js";
 export interface NknBusOptions {
   seed: string;
   numSubClients?: number;
+  /** Heartbeat echo-test interval in ms (default 60 000). Set 0 to disable. */
+  heartbeatIntervalMs?: number;
+  /** Consecutive heartbeat failures before reconnecting (default 3). */
+  heartbeatMaxFailures?: number;
 }
 
+/** Payload used for heartbeat echo-test messages (self → self). */
+const HEARTBEAT_ECHO_PREFIX = "__nkn_heartbeat_echo__:";
+
 /**
  * NKN MultiClient wrapper for D-Chat wire-format messaging.
- * Handles connect, send, receive, subscribe, and reconnection.
+ * Handles connect, send, receive, subscribe, heartbeat, and reconnection.
  */
+
 export class NknBus extends EventEmitter {
   private client: nkn.MultiClient | null = null;
   private state: NknConnectionState = "disconnected";
@@ -20,6 +28,14 @@ export class NknBus extends EventEmitter {
   private numSubClients: number;
   private abortSignal: AbortSignal | undefined;
 
+  private heartbeatIntervalMs: number = 60_000;
+  private heartbeatMaxFailures: number = 3;
+  private heartbeatTimer: ReturnType<typeof setTimeout> | null = null;
+  private heartbeatFailures: number = 0;
+  private pendingEchoId: string | null = null;
+  private pendingEchoResolve: (() => void) | null = null;
+  private isReconnecting: boolean = false;
+
   constructor() {
     super();
     this.numSubClients = 4;
@@ -40,6 +56,8 @@ export class NknBus extends EventEmitter {
 
     this.seed = opts.seed;
     this.numSubClients = opts.numSubClients ?? 4;
+    this.heartbeatIntervalMs = opts.heartbeatIntervalMs ?? 60_000;
+    this.heartbeatMaxFailures = opts.heartbeatMaxFailures ?? 3;
     this.abortSignal = abortSignal;
     this.setState("connecting");
 
@@ -86,9 +104,23 @@ export class NknBus extends EventEmitter {
         } else {
           data = payload;
         }
+
+        // Intercept heartbeat echo responses — don't emit as regular messages
+        if (data.startsWith(HEARTBEAT_ECHO_PREFIX)) {
+          const echoId = data.slice(HEARTBEAT_ECHO_PREFIX.length);
+          if (echoId === this.pendingEchoId && this.pendingEchoResolve) {
+            this.pendingEchoResolve();
+            this.pendingEchoResolve = null;
+            this.pendingEchoId = null;
+          }
+          return;
+        }
+
         this.emit("message", src, data);
       });
 
+      this.startHeartbeat();
+
       return this.address;
     } catch (err) {
       this.setState("disconnected");
@@ -105,6 +137,7 @@ export class NknBus extends EventEmitter {
   }
 
   async disconnect(): Promise<void> {
+    this.stopHeartbeat();
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
@@ -200,6 +233,185 @@ export class NknBus extends EventEmitter {
     this.on("message", handler);
   }
 
+  /** Start periodic heartbeat echo test (self → self). */
+  private startHeartbeat(): void {
+    if (this.heartbeatIntervalMs <= 0) return;
+    this.heartbeatFailures = 0;
+    this.scheduleNextHeartbeat();
+  }
+
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    // Reject any pending echo wait
+    this.pendingEchoResolve = null;
+    this.pendingEchoId = null;
+  }
+
+  private scheduleNextHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setTimeout(() => {
+      void this.runHeartbeat();
+    }, this.heartbeatIntervalMs);
+  }
+
+  private async runHeartbeat(): Promise<void> {
+    if (!this.client || this.state !== "connected" || !this.address) {
+      return;
+    }
+
+    const echoId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const echoPayload = HEARTBEAT_ECHO_PREFIX + echoId;
+
+    try {
+      const echoReceived = await new Promise<boolean>((resolve) => {
+        this.pendingEchoId = echoId;
+        // Timeout: half the heartbeat interval or 15s, whichever is smaller
+        const timeout = Math.min(this.heartbeatIntervalMs / 2, 15_000);
+        const timer = setTimeout(() => {
+          this.pendingEchoResolve = null;
+          this.pendingEchoId = null;
+          resolve(false);
+        }, timeout);
+
+        this.pendingEchoResolve = () => {
+          clearTimeout(timer);
+          resolve(true);
+        };
+
+        // Send echo to self (fire-and-forget send, we wait for the message handler)
+        this.client!.send(this.address!, echoPayload, { noReply: true });
+      });
+
+      if (echoReceived) {
+        this.heartbeatFailures = 0;
+        this.emit("heartbeat", { success: true, failures: 0 });
+      } else {
+        this.heartbeatFailures++;
+        this.emit("heartbeat", { success: false, failures: this.heartbeatFailures });
+
+        if (this.heartbeatFailures >= this.heartbeatMaxFailures) {
+          this.emit("heartbeatReconnect", { failures: this.heartbeatFailures });
+          await this.reconnect();
+          return; // reconnect starts a new heartbeat loop
+        }
+      }
+    } catch {
+      this.heartbeatFailures++;
+      this.emit("heartbeat", { success: false, failures: this.heartbeatFailures });
+
+      if (this.heartbeatFailures >= this.heartbeatMaxFailures) {
+        this.emit("heartbeatReconnect", { failures: this.heartbeatFailures });
+        await this.reconnect();
+        return;
+      }
+    }
+
+    // Schedule next heartbeat if still connected
+    if (this.state === "connected") {
+      this.scheduleNextHeartbeat();
+    }
+  }
+
+  /** Close the current connection and create a new one using stored options. */
+  private async reconnect(): Promise<void> {
+    if (this.isReconnecting || !this.seed) return;
+    this.isReconnecting = true;
+
+    try {
+      this.stopHeartbeat();
+
+      // Close existing client
+      if (this.client) {
+        try {
+          this.client.close();
+        } catch {
+          // ignore close errors
+        }
+        this.client = null;
+      }
+      this.address = undefined;
+      this.setState("connecting");
+
+      // Create a fresh client
+      this.client = new nkn.MultiClient({
+        seed: this.seed,
+        numSubClients: this.numSubClients,
+        originalClient: false,
+        rpcServerAddr: NKN_SEED_RPC_SERVERS[0],
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error("NKN reconnection timeout after 30s"));
+        }, 30_000);
+
+        if (this.abortSignal?.aborted) {
+          clearTimeout(timeout);
+          reject(new Error("Aborted"));
+          return;
+        }
+
+        const onAbort = () => {
+          clearTimeout(timeout);
+          reject(new Error("Aborted"));
+        };
+        this.abortSignal?.addEventListener("abort", onAbort, { once: true });
+
+        this.client!.onConnect(() => {
+          clearTimeout(timeout);
+          this.abortSignal?.removeEventListener("abort", onAbort);
+          resolve();
+        });
+      });
+
+      this.address = this.client.addr;
+      this.setState("connected");
+
+      // Re-register message handler
+      this.client.onMessage(({ src, payload }: { src: string; payload: Uint8Array | string }) => {
+        let data: string;
+        if (payload instanceof Uint8Array) {
+          data = new TextDecoder().decode(payload);
+        } else {
+          data = payload;
+        }
+
+        if (data.startsWith(HEARTBEAT_ECHO_PREFIX)) {
+          const id = data.slice(HEARTBEAT_ECHO_PREFIX.length);
+          if (id === this.pendingEchoId && this.pendingEchoResolve) {
+            this.pendingEchoResolve();
+            this.pendingEchoResolve = null;
+            this.pendingEchoId = null;
+          }
+          return;
+        }
+
+        this.emit("message", src, data);
+      });
+
+      this.heartbeatFailures = 0;
+      this.startHeartbeat();
+    } catch (err) {
+      this.setState("disconnected");
+      if (this.client) {
+        try {
+          this.client.close();
+        } catch {
+          // ignore
+        }
+        this.client = null;
+      }
+      this.emit("reconnectFailed", err);
+    } finally {
+      this.isReconnecting = false;
+    }
+  }
+
   private ensureConnected(): void {
     if (!this.client || this.state !== "connected") {
       throw new Error("NKN client not connected");

package/src/onboarding.ts

@@ -1,13 +1,14 @@
-import type { DmPolicy } from "openclaw/plugin-sdk";
+import type { DmPolicy } from "openclaw/plugin-sdk/setup";
 import {
   addWildcardAllowFrom,
   mergeAllowFromEntries,
   formatDocsLink,
-  type ChannelOnboardingAdapter,
-  type ChannelOnboardingDmPolicy,
+  type ChannelSetupDmPolicy,
   type WizardPrompter,
-} from "openclaw/plugin-sdk";
-import { listDchatAccountIds, resolveDchatAccount, type CoreConfig } from "./config-schema.js";
+} from "openclaw/plugin-sdk/setup";
+import type { ChannelSetupWizard } from "openclaw/plugin-sdk/setup";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { listDchatAccountIds, resolveDchatAccount, resolveDchatAccountConfig, type CoreConfig } from "./config-schema.js";
 
 const channel = "dchat" as const;
 
@@ -30,154 +31,134 @@ function setDchatDmPolicy(cfg: CoreConfig, policy: DmPolicy) {
   };
 }
 
-async function promptDchatAllowFrom(params: {
-  cfg: CoreConfig;
-  prompter: WizardPrompter;
-}): Promise<CoreConfig> {
-  const { cfg, prompter } = params;
-  const existingAllowFrom = cfg.channels?.dchat?.allowFrom ?? [];
-
-  const entry = await prompter.text({
-    message: "NKN address to allow (full public key hex)",
-    placeholder: "abc123...def456 (64-char hex NKN address)",
-    initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : undefined,
-    validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
-  });
-
-  const parts = String(entry)
-    .split(/[\n,;]+/g)
-    .map((e) => e.trim())
-    .filter(Boolean);
-
-  const unique = mergeAllowFromEntries(existingAllowFrom, parts);
-  return {
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      dchat: {
-        ...cfg.channels?.dchat,
-        enabled: true,
-        dmPolicy: "allowlist",
-        allowFrom: unique,
-      },
-    },
-  };
-}
-
-const dmPolicy: ChannelOnboardingDmPolicy = {
+const dmPolicy: ChannelSetupDmPolicy = {
   label: "D-Chat",
   channel,
   policyKey: "channels.dchat.dmPolicy",
   allowFromKey: "channels.dchat.allowFrom",
   getCurrent: (cfg) => ((cfg as CoreConfig).channels?.dchat?.dmPolicy as DmPolicy) ?? "pairing",
   setPolicy: (cfg, policy) => setDchatDmPolicy(cfg as CoreConfig, policy),
-  promptAllowFrom: promptDchatAllowFrom,
-};
+  promptAllowFrom: async (params) => {
+    const cfg = params.cfg as CoreConfig;
+    const { prompter } = params;
+    const existingAllowFrom = cfg.channels?.dchat?.allowFrom ?? [];
 
-export const dchatOnboardingAdapter: ChannelOnboardingAdapter = {
-  channel,
-  getStatus: async ({ cfg }) => {
-    const typedCfg = cfg as CoreConfig;
-    const accountIds = listDchatAccountIds(typedCfg);
-    const anyConfigured = accountIds.some(
-      (id) => resolveDchatAccount({ cfg: typedCfg, accountId: id }).configured,
-    );
+    const entry = await prompter.text({
+      message: "NKN address to allow (full public key hex)",
+      placeholder: "abc123...def456 (64-char hex NKN address)",
+      initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    });
+
+    const parts = String(entry)
+      .split(/[\n,;]+/g)
+      .map((e) => e.trim())
+      .filter(Boolean);
+
+    const unique = mergeAllowFromEntries(existingAllowFrom, parts);
     return {
-      channel,
-      configured: anyConfigured,
-      statusLines: [`D-Chat: ${anyConfigured ? "configured" : "needs wallet seed"}`],
-      selectionHint: anyConfigured ? "configured" : "needs seed",
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        dchat: {
+          ...cfg.channels?.dchat,
+          enabled: true,
+          dmPolicy: "allowlist",
+          allowFrom: unique,
+        },
+      },
     };
   },
-  configure: async ({ cfg, prompter, forceAllowFrom }) => {
-    let next = cfg as CoreConfig;
-    const existing = next.channels?.dchat ?? {};
-    const account = resolveDchatAccount({ cfg: next });
+};
 
-    if (!account.configured) {
-      await prompter.note(
-        [
-          "D-Chat uses the NKN relay network for decentralized E2E encrypted messaging.",
-          "You need a wallet seed (64-character hex string) to connect.",
-          "Generate one with nkn-sdk or use an existing seed from D-Chat/nMobile.",
-          `Docs: ${formatDocsLink("/channels/dchat", "channels/dchat")}`,
-        ].join("\n"),
-        "D-Chat setup",
+export const dchatSetupWizard: ChannelSetupWizard = {
+  channel,
+  status: {
+    configuredLabel: "configured",
+    unconfiguredLabel: "needs wallet seed",
+    resolveConfigured: ({ cfg }) => {
+      const typedCfg = cfg as CoreConfig;
+      const accountIds = listDchatAccountIds(typedCfg);
+      return accountIds.some(
+        (id) => resolveDchatAccount({ cfg: typedCfg, accountId: id }).configured,
       );
-    }
-
-    // Check for env var (validate same 64-hex format as prompted input)
-    const envSeed = process.env.DCHAT_SEED?.trim() || process.env.NKN_SEED?.trim();
-    if (envSeed && /^[0-9a-f]{64}$/i.test(envSeed) && !existing.seed) {
-      const useEnv = await prompter.confirm({
-        message: "NKN seed env var detected. Use env value?",
-        initialValue: true,
-      });
-      if (useEnv) {
-        next = {
-          ...next,
+    },
+    resolveStatusLines: ({ cfg, configured }) => [
+      `D-Chat: ${configured ? "configured" : "needs wallet seed"}`,
+    ],
+    resolveSelectionHint: ({ configured }) =>
+      configured ? "configured" : "needs seed",
+  },
+  introNote: {
+    title: "D-Chat setup",
+    lines: [
+      "D-Chat uses the NKN relay network for decentralized E2E encrypted messaging.",
+      "You need a wallet seed (64-character hex string) to connect.",
+      "Generate one with nkn-sdk or use an existing seed from D-Chat/nMobile.",
+      `Docs: ${formatDocsLink("/channels/dchat", "channels/dchat")}`,
+    ],
+    shouldShow: ({ cfg }) => {
+      const account = resolveDchatAccount({ cfg: cfg as CoreConfig });
+      return !account.configured;
+    },
+  },
+  envShortcut: {
+    prompt: "NKN seed env var detected. Use env value?",
+    preferredEnvVar: "DCHAT_SEED",
+    isAvailable: ({ cfg }) => {
+      const envSeed = process.env.DCHAT_SEED?.trim() || process.env.NKN_SEED?.trim();
+      const existing = (cfg as CoreConfig).channels?.dchat?.seed;
+      return Boolean(envSeed && /^[0-9a-f]{64}$/i.test(envSeed) && !existing);
+    },
+    apply: ({ cfg, accountId }) => {
+      const envSeed = (process.env.DCHAT_SEED?.trim() || process.env.NKN_SEED?.trim())!;
+      return {
+        ...cfg,
+        channels: {
+          ...(cfg as CoreConfig).channels,
+          dchat: {
+            ...(cfg as CoreConfig).channels?.dchat,
+            enabled: true,
+            seed: envSeed,
+          },
+        },
+      } as OpenClawConfig;
+    },
+  },
+  credentials: [
+    {
+      inputKey: "accessToken",
+      providerHint: "NKN",
+      credentialLabel: "wallet seed",
+      preferredEnvVar: "DCHAT_SEED",
+      envPrompt: "NKN seed env var detected. Use env value?",
+      keepPrompt: "Wallet seed already configured. Keep it?",
+      inputPrompt: "NKN wallet seed (64-char hex)",
+      inspect: ({ cfg, accountId }) => {
+        const acctCfg = resolveDchatAccountConfig({ cfg: cfg as CoreConfig, accountId });
+        const seed = acctCfg.seed?.trim();
+        return {
+          accountConfigured: Boolean(seed),
+          hasConfiguredValue: Boolean(seed),
+          resolvedValue: seed,
+        };
+      },
+      applySet: ({ cfg, accountId, resolvedValue }) => {
+        const seed = resolvedValue.trim();
+        return {
+          ...cfg,
           channels: {
-            ...next.channels,
+            ...(cfg as CoreConfig).channels,
             dchat: {
-              ...next.channels?.dchat,
+              ...(cfg as CoreConfig).channels?.dchat,
               enabled: true,
-              seed: envSeed,
+              seed,
             },
           },
-        };
-        if (forceAllowFrom) {
-          next = await promptDchatAllowFrom({ cfg: next, prompter });
-        }
-        return { cfg: next };
-      }
-    }
-
-    // Prompt for seed
-    let seed = existing.seed ?? "";
-    if (seed) {
-      const keep = await prompter.confirm({
-        message: "Wallet seed already configured. Keep it?",
-        initialValue: true,
-      });
-      if (!keep) {
-        seed = "";
-      }
-    }
-
-    if (!seed) {
-      seed = String(
-        await prompter.text({
-          message: "NKN wallet seed (64-char hex)",
-          validate: (value) => {
-            const raw = String(value ?? "").trim();
-            if (!raw) return "Required";
-            if (!/^[0-9a-f]{64}$/i.test(raw)) {
-              return "Must be a 64-character hex string";
-            }
-            return undefined;
-          },
-        }),
-      ).trim();
-    }
-
-    next = {
-      ...next,
-      channels: {
-        ...next.channels,
-        dchat: {
-          ...next.channels?.dchat,
-          enabled: true,
-          seed,
-        },
+        } as OpenClawConfig;
       },
-    };
-
-    if (forceAllowFrom) {
-      next = await promptDchatAllowFrom({ cfg: next, prompter });
-    }
-
-    return { cfg: next };
-  },
+    },
+  ],
   dmPolicy,
   disable: (cfg) => ({
     ...(cfg as CoreConfig),

package/src/runtime.ts

@@ -1,4 +1,4 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk/core";
 
 let runtime: PluginRuntime | null = null;