@decentchat/decentclaw 0.1.4 → 0.1.6

package/README.md

@@ -12,7 +12,23 @@ openclaw plugins install @decentchat/decentclaw
 
 ## Configure
 
-Add a `channels.decentchat` block to your OpenClaw config (`~/.openclaw/openclaw.json` or per-project):
+The quickest way to set up is with the interactive wizard:
+
+```
+openclaw configure
+```
+
+Select **DecentChat** when prompted. The wizard will:
+
+1. Offer to generate a new 12-word seed phrase (or let you paste an existing one)
+2. Ask for a display name
+3. Ask for an invite URL to join a workspace
+
+You can also set the seed phrase via the `DECENTCHAT_SEED_PHRASE` environment variable instead of storing it in the config file.
+
+### Manual configuration
+
+If you prefer to edit the config directly, add a `channels.decentchat` block to your OpenClaw config (`~/.openclaw/openclaw.json` or per-project):
 
 ```yaml
 channels:

package/index.ts

@@ -1,17 +1,11 @@
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
-import { emptyPluginConfigSchema } from 'openclaw/plugin-sdk';
+import { defineChannelPluginEntry } from 'openclaw/plugin-sdk/core';
 import { decentChatPlugin } from './src/channel.js';
 import { setDecentChatRuntime } from './src/runtime.js';
 
-const plugin = {
+export default defineChannelPluginEntry({
   id: 'decentclaw',
   name: 'DecentChat',
   description: 'DecentChat P2P channel plugin',
-  configSchema: emptyPluginConfigSchema(),
-  register(api: OpenClawPluginApi) {
-    setDecentChatRuntime(api.runtime);
-    api.registerChannel({ plugin: decentChatPlugin });
-  },
-};
-
-export default plugin;
+  plugin: decentChatPlugin,
+  setRuntime: setDecentChatRuntime,
+});

package/openclaw.plugin.json

@@ -1,7 +1,8 @@
 {
   "id": "decentclaw",
+  "kind": "channel",
   "name": "DecentChat",
-  "version": "0.1.1",
+  "version": "0.1.6",
   "channels": ["decentchat"],
   "description": "DecentChat P2P channel plugin for OpenClaw — P2P encrypted chat",
   "configSchema": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentchat/decentclaw",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "OpenClaw channel plugin for DecentChat — P2P encrypted chat",
   "type": "module",
   "main": "index.ts",
@@ -8,17 +8,22 @@
     "extensions": [
       "./index.ts"
     ],
+    "setupEntry": "./setup-entry.ts",
     "channel": {
       "id": "decentchat",
       "label": "DecentChat",
       "selectionLabel": "DecentChat (P2P)",
       "docsPath": "/channels/decentchat",
       "blurb": "P2P encrypted chat via DecentChat."
+    },
+    "install": {
+      "npmSpec": "@decentchat/decentclaw"
     }
   },
   "files": [
     "src",
     "index.ts",
+    "setup-entry.ts",
     "openclaw.plugin.json"
   ],
   "repository": {

package/setup-entry.ts

@@ -0,0 +1,4 @@
+import { defineSetupPluginEntry } from 'openclaw/plugin-sdk/core';
+import { decentChatPlugin } from './src/channel.js';
+
+export default defineSetupPluginEntry(decentChatPlugin);

package/src/channel.ts

@@ -1,10 +1,12 @@
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import type { ChannelPlugin } from "openclaw/plugin-sdk";
+import type { ChannelPlugin, ChannelSetupWizard, ChannelSetupInput, OpenClawConfig } from "openclaw/plugin-sdk";
+import { createStandardChannelSetupStatus, patchTopLevelChannelConfigSection, createTopLevelChannelDmPolicy } from "openclaw/plugin-sdk/setup";
 import { z } from "zod";
 
 import { assertCompanyBootstrapAgentInstallation, ensureCompanyBootstrapRuntime, resolveCompanyManifestPath } from "@decentchat/company-sim";
+import { SeedPhraseManager } from "@decentchat/protocol";
 import { startDecentChatPeer } from "./monitor.js";
 import { getActivePeer, listActivePeerAccountIds } from "./peer-registry.js";
 import { buildDecentChatRuntimeBootstrapKey, invalidateDecentChatBootstrapKey, runDecentChatBootstrapOnce } from "./runtime.js";
@@ -532,6 +534,271 @@ export async function bootstrapDecentChatCompanySimForStartup(params: {
   });
 }
 
+// ---------------------------------------------------------------------------
+// Setup wizard (powers `openclaw configure`)
+// ---------------------------------------------------------------------------
+
+const CHANNEL = "decentchat";
+
+let _seedPhraseManager: InstanceType<typeof SeedPhraseManager> | undefined;
+function getSeedPhraseManager() {
+  if (!_seedPhraseManager) _seedPhraseManager = new SeedPhraseManager();
+  return _seedPhraseManager;
+}
+
+function validateSeedPhrase(mnemonic: string): string | undefined {
+  const result = getSeedPhraseManager().validate(mnemonic);
+  if (!result.valid) return result.error ?? "Invalid seed phrase";
+  return undefined;
+}
+
+const decentChatSetupWizard: ChannelSetupWizard = {
+  channel: CHANNEL,
+
+  resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
+  resolveShouldPromptAccountIds: () => false,
+
+  status: createStandardChannelSetupStatus({
+    channelLabel: "DecentChat",
+    configuredLabel: "configured",
+    unconfiguredLabel: "needs seed phrase",
+    configuredHint: "configured",
+    unconfiguredHint: "needs seed phrase",
+    configuredScore: 1,
+    unconfiguredScore: 0,
+    includeStatusLine: true,
+    resolveConfigured: ({ cfg }) => resolveDecentChatAccount(cfg).configured,
+    resolveExtraStatusLines: ({ cfg }) => {
+      const account = resolveDecentChatAccount(cfg);
+      const lines: string[] = [];
+      if (account.alias) lines.push(`Alias: ${account.alias}`);
+      if (account.invites.length > 0) lines.push(`Invites: ${account.invites.length}`);
+      return lines;
+    },
+  }),
+
+  introNote: {
+    title: "DecentChat setup",
+    lines: [
+      "DecentChat is a P2P encrypted messaging network.",
+      "Your bot needs a 12-word BIP39 seed phrase to create its identity.",
+      "You can generate a new one here or paste an existing one.",
+    ],
+  },
+
+  stepOrder: "credentials-first",
+
+  prepare: async ({ cfg, accountId, prompter }) => {
+    const account = resolveDecentChatAccount(cfg, accountId);
+    if (account.configured) return;
+
+    const generateNew = await prompter.confirm({
+      message: "Generate a new DecentChat identity?",
+      initialValue: true,
+    });
+
+    if (generateNew) {
+      const { mnemonic } = getSeedPhraseManager().generate();
+      await prompter.note(
+        [
+          `Your new seed phrase:`,
+          ``,
+          `  ${mnemonic}`,
+          ``,
+          `Write this down and store it somewhere safe.`,
+          `This is the only way to recover your bot's identity.`,
+        ].join("\n"),
+        "New identity generated",
+      );
+      return {
+        credentialValues: { privateKey: mnemonic },
+      };
+    }
+
+    return;
+  },
+
+  credentials: [
+    {
+      inputKey: "privateKey" as keyof ChannelSetupInput,
+      providerHint: CHANNEL,
+      credentialLabel: "seed phrase",
+      helpTitle: "DecentChat seed phrase",
+      helpLines: [
+        "A 12-word BIP39 mnemonic that determines your bot's identity on the network.",
+        "All encryption keys are derived from this phrase.",
+      ],
+      envPrompt: "DECENTCHAT_SEED_PHRASE detected. Use env var?",
+      keepPrompt: "Seed phrase already configured. Keep it?",
+      inputPrompt: "DecentChat seed phrase (12 words)",
+      preferredEnvVar: "DECENTCHAT_SEED_PHRASE",
+
+      allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
+
+      inspect: ({ cfg, accountId }) => {
+        const account = resolveDecentChatAccount(cfg, accountId);
+        return {
+          accountConfigured: account.configured,
+          hasConfiguredValue: !!account.seedPhrase?.trim(),
+          resolvedValue: account.seedPhrase?.trim(),
+          envValue: process.env.DECENTCHAT_SEED_PHRASE?.trim(),
+        };
+      },
+
+      shouldPrompt: ({ credentialValues, state }) => {
+        // Skip the prompt if prepare() already generated a seed phrase
+        if (credentialValues.privateKey?.trim()) return false;
+        if (state.hasConfiguredValue) return false;
+        return true;
+      },
+
+      applyUseEnv: async ({ cfg }) =>
+        patchTopLevelChannelConfigSection({
+          cfg,
+          channel: CHANNEL,
+          enabled: true,
+          clearFields: ["seedPhrase"],
+          patch: {},
+        }),
+
+      applySet: async ({ cfg, resolvedValue }) =>
+        patchTopLevelChannelConfigSection({
+          cfg,
+          channel: CHANNEL,
+          enabled: true,
+          patch: { seedPhrase: resolvedValue },
+        }),
+    },
+  ],
+
+  textInputs: [
+    {
+      inputKey: "name" as keyof ChannelSetupInput,
+      message: "Bot display name",
+      placeholder: "DecentChat Bot",
+      required: false,
+      helpTitle: "Bot display name",
+      helpLines: ["The name other users see when your bot sends messages."],
+
+      currentValue: ({ cfg, accountId }) => {
+        const account = resolveDecentChatAccount(cfg, accountId);
+        return account.alias !== "DecentChat Bot" ? account.alias : undefined;
+      },
+
+      initialValue: () => "DecentChat Bot",
+
+      applySet: async ({ cfg, value }) =>
+        patchTopLevelChannelConfigSection({
+          cfg,
+          channel: CHANNEL,
+          enabled: true,
+          patch: { alias: value.trim() || "DecentChat Bot" },
+        }),
+    },
+    {
+      inputKey: "url" as keyof ChannelSetupInput,
+      message: "Invite URL to join a workspace (optional)",
+      placeholder: "decentchat://invite/...",
+      required: false,
+      applyEmptyValue: false,
+      helpTitle: "DecentChat invite URL",
+      helpLines: [
+        "Paste an invite link to automatically join a workspace on startup.",
+        "You can add more later in the config file.",
+        "Leave blank to skip.",
+      ],
+
+      currentValue: ({ cfg, accountId }) => {
+        const account = resolveDecentChatAccount(cfg, accountId);
+        return account.invites.length > 0 ? account.invites[0] : undefined;
+      },
+
+      keepPrompt: (value) => `Invite URL set (${value}). Keep it?`,
+
+      applySet: async ({ cfg, value }) => {
+        const trimmed = value.trim();
+        if (!trimmed) return cfg;
+        // Merge with existing invites, avoiding duplicates
+        const existing: string[] = (cfg as any)?.channels?.decentchat?.invites ?? [];
+        const merged = [...new Set([...existing, trimmed])];
+        return patchTopLevelChannelConfigSection({
+          cfg,
+          channel: CHANNEL,
+          enabled: true,
+          patch: { invites: merged },
+        });
+      },
+    },
+  ],
+
+  completionNote: {
+    title: "DecentChat ready",
+    lines: [
+      "Your bot will connect to the DecentChat P2P network on next startup.",
+      "Run `openclaw start` to bring it online.",
+    ],
+  },
+
+  dmPolicy: createTopLevelChannelDmPolicy({
+    label: "DecentChat",
+    channel: CHANNEL,
+    policyKey: `channels.${CHANNEL}.dmPolicy`,
+    allowFromKey: `channels.${CHANNEL}.allowFrom`,
+    getCurrent: (cfg) => (cfg as any)?.channels?.decentchat?.dmPolicy ?? "open",
+  }),
+
+  disable: (cfg) =>
+    patchTopLevelChannelConfigSection({
+      cfg,
+      channel: CHANNEL,
+      patch: { enabled: false },
+    }),
+};
+
+const decentChatSetupAdapter = {
+  resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+
+  validateInput: ({ input }: { cfg: OpenClawConfig; accountId: string; input: ChannelSetupInput }) => {
+    const typedInput = input as ChannelSetupInput & { privateKey?: string };
+    if (!typedInput.useEnv) {
+      const seedPhrase = typedInput.privateKey?.trim();
+      if (!seedPhrase) return "DecentChat requires a seed phrase.";
+      const error = validateSeedPhrase(seedPhrase);
+      if (error) return error;
+    }
+    return null;
+  },
+
+  applyAccountConfig: ({ cfg, input }: { cfg: OpenClawConfig; accountId: string; input: ChannelSetupInput }) => {
+    const typedInput = input as ChannelSetupInput & { privateKey?: string };
+    const patch: Record<string, unknown> = {};
+
+    if (typedInput.useEnv) {
+      // Clear stored seed phrase, will read from env at runtime
+    } else if (typedInput.privateKey?.trim()) {
+      patch.seedPhrase = typedInput.privateKey.trim();
+    }
+
+    if ((typedInput as any).name?.trim()) {
+      patch.alias = (typedInput as any).name.trim();
+    }
+
+    if ((typedInput as any).url?.trim()) {
+      const existing: string[] = (cfg as any)?.channels?.decentchat?.invites ?? [];
+      const invite = (typedInput as any).url.trim();
+      patch.invites = [...new Set([...existing, invite])];
+    }
+
+    return patchTopLevelChannelConfigSection({
+      cfg,
+      channel: CHANNEL,
+      enabled: true,
+      clearFields: typedInput.useEnv ? ["seedPhrase"] : undefined,
+      patch,
+    });
+  },
+};
+
 export const decentChatPlugin: ChannelPlugin<ResolvedDecentChatAccount> = {
   id: "decentchat",
   meta: {
@@ -571,6 +838,9 @@ export const decentChatPlugin: ChannelPlugin<ResolvedDecentChatAccount> = {
     },
   },
 
+  setup: decentChatSetupAdapter,
+  setupWizard: decentChatSetupWizard,
+
   config: {
     listAccountIds: (cfg) => listDecentChatAccountIds(cfg),
     resolveAccount: (cfg, accountId) => resolveDecentChatAccount(cfg, accountId),