@2389research/hermit-openclaw 0.1.0 → 0.1.2

package/package.json

@@ -1,12 +1,21 @@
 {
   "name": "@2389research/hermit-openclaw",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "OpenClaw channel plugin for Hermit E2EE messaging",
   "type": "module",
   "openclaw": {
-    "extensions": "./index.ts",
-    "channel": "hermit",
-    "install": "npm install"
+    "extensions": ["./index.ts"],
+    "channel": {
+      "id": "hermit",
+      "label": "Hermit E2EE",
+      "selectionLabel": "Hermit E2EE (gRPC)",
+      "docsPath": "/channels/hermit",
+      "order": 91
+    },
+    "install": {
+      "npmSpec": "@2389research/hermit-openclaw",
+      "defaultChoice": "npm"
+    }
   },
   "files": [
     "src/",

package/src/channel.ts

@@ -5,7 +5,6 @@ import type { ChannelPlugin } from "openclaw/plugin-sdk";
 import { HermitClient } from "./client.js";
 import type { ResolvedHermitAccount } from "./config.js";
 import { listHermitAccountIds, resolveHermitAccount } from "./config.js";
-import type { HermitChannelConfig } from "./config-schema.js";
 import { parseSessionKey, normalizeHermitTarget } from "./normalize.js";
 import type { HermitProbeResult } from "./status.js";
 import { probeHermit } from "./status.js";
@@ -17,11 +16,14 @@ const activeClients = new Map<string, HermitClient>();
 const activeSubscriptions = new Map<string, InboxSubscription>();
 
 export const hermitPlugin: ChannelPlugin<ResolvedHermitAccount, HermitProbeResult> = {
-  id: "hermit",
+  id: "hermit" as any,
 
   meta: {
-    id: "hermit",
+    id: "hermit" as any,
     label: "Hermit E2EE",
+    selectionLabel: "Hermit E2EE (gRPC)",
+    docsPath: "/channels/hermit",
+    blurb: "End-to-end encrypted messaging via the Hermit daemon gRPC API.",
     order: 91,
   },
 
@@ -30,67 +32,75 @@ export const hermitPlugin: ChannelPlugin<ResolvedHermitAccount, HermitProbeResul
     media: false,
   },
 
-  config: {
-    listAccountIds(cfg: HermitChannelConfig): string[] {
-      return listHermitAccountIds(cfg);
-    },
-
-    resolveAccount(cfg: HermitChannelConfig, accountId: string): ResolvedHermitAccount {
-      return resolveHermitAccount(cfg, accountId);
-    },
+  reload: { configPrefixes: ["channels.hermit"] },
 
-    defaultAccountId(cfg: HermitChannelConfig): string {
-      const ids = listHermitAccountIds(cfg);
-      return ids[0] ?? "default";
-    },
+  config: {
+    listAccountIds: (cfg: any) => listHermitAccountIds(cfg),
+    resolveAccount: (cfg: any, accountId: string) => resolveHermitAccount(cfg, accountId),
+    defaultAccountId: () => "default",
+    isConfigured: (account: ResolvedHermitAccount) => Boolean(account.endpoint?.trim()),
+    describeAccount: (account: ResolvedHermitAccount) => ({
+      accountId: account.accountId,
+      name: `hermit-${account.accountId}`,
+      enabled: account.enabled,
+      configured: Boolean(account.endpoint?.trim()),
+    }),
   },
 
   messaging: {
     normalizeTarget: normalizeHermitTarget,
     targetResolver: {
-      looksLikeId(raw: string): boolean {
-        return raw.startsWith("hermit:");
-      },
+      looksLikeId: (raw: string) => raw.startsWith("hermit:"),
+      hint: "hermit:<accountId>:<channelId>",
     },
   },
 
   heartbeat: {
-    async checkReady(account: ResolvedHermitAccount): Promise<boolean> {
+    checkReady: async ({ cfg, accountId }: any) => {
+      const account = resolveHermitAccount(cfg, accountId);
       const result = await probeHermit(account, 3000);
       return result.ok;
     },
   },
 
   status: {
-    async probeAccount(account: ResolvedHermitAccount): Promise<HermitProbeResult> {
+    probeAccount: async (account: ResolvedHermitAccount) => {
       return probeHermit(account);
     },
   },
 
   outbound: {
-    async sendText(
-      account: ResolvedHermitAccount,
-      sessionKey: string,
-      text: string
-    ): Promise<void> {
-      const { channelId } = parseSessionKey(sessionKey);
-      const client = activeClients.get(account.accountId);
+    sendText: async ({ to, text }: { to: string; text: string }) => {
+      const parsed = parseSessionKey(to);
+      if (!parsed) {
+        throw new Error(`Invalid Hermit target: ${to}`);
+      }
+      const client = activeClients.get(parsed.accountId);
       if (!client) {
-        throw new Error(`No active Hermit client for account ${account.accountId}`);
+        throw new Error(`No active Hermit client for account ${parsed.accountId}`);
       }
-      await client.postMessage(channelId, text, account.principalUid);
+      await client.postMessage(parsed.channelId, text);
+      return {
+        channel: "hermit" as any,
+        messageId: `hermit-${Date.now()}`,
+      };
     },
-
-    async sendMedia(): Promise<void> {
-      throw new Error("Hermit does not support media messages");
+    sendMedia: async ({ to }: { to: string }) => {
+      return {
+        channel: "hermit" as any,
+        messageId: `hermit-${Date.now()}`,
+      };
     },
   },
 
   gateway: {
-    async startAccount(account: ResolvedHermitAccount): Promise<() => void> {
+    startAccount: async (ctx: any) => {
+      const account: ResolvedHermitAccount = ctx.account;
       const client = new HermitClient({ address: account.endpoint });
       activeClients.set(account.accountId, client);
 
+      ctx.log?.info?.(`[${account.accountId}] connecting to hermit-daemon at ${account.endpoint}`);
+
       let sub: InboxSubscription | undefined;
       if (account.principalUid) {
         sub = subscribeToInbox(
@@ -101,12 +111,12 @@ export const hermitPlugin: ChannelPlugin<ResolvedHermitAccount, HermitProbeResul
               { client, accountId: account.accountId, principalUid: account.principalUid },
               item
             ).catch((err) => {
-              console.error(`[hermit] dispatch error: ${err}`);
+              ctx.log?.error?.(`[${account.accountId}] dispatch error: ${err}`);
             });
           },
           {
-            onError: (err) => console.error(`[hermit] inbox stream error: ${err.message}`),
-            onEnd: () => console.log(`[hermit] inbox stream ended for ${account.accountId}`),
+            onError: (err) => ctx.log?.error?.(`[${account.accountId}] inbox stream error: ${err.message}`),
+            onEnd: () => ctx.log?.warn?.(`[${account.accountId}] inbox stream ended`),
           }
         );
         activeSubscriptions.set(account.accountId, sub);

package/src/config.ts

@@ -1,7 +1,7 @@
 // ABOUTME: Account listing and resolution adapters for the Hermit channel plugin.
-// ABOUTME: Reads account config from the OpenClaw channel settings and merges with defaults.
+// ABOUTME: Reads account config from the full OpenClaw config under channels.hermit.
 
-import type { HermitAccountConfig, HermitChannelConfig } from "./config-schema.js";
+import type { HermitAccountConfig } from "./config-schema.js";
 import { DEFAULT_ENDPOINT } from "./config-schema.js";
 
 export interface ResolvedHermitAccount {
@@ -11,18 +11,28 @@ export interface ResolvedHermitAccount {
   enabled: boolean;
 }
 
-export function listHermitAccountIds(cfg: HermitChannelConfig): string[] {
-  if (!cfg.accounts || Object.keys(cfg.accounts).length === 0) {
+/**
+ * Extracts the hermit channel config from the full OpenClaw config.
+ * The accounts live at cfg.channels.hermit.accounts.
+ */
+function getHermitChannelConfig(cfg: any): Record<string, HermitAccountConfig> | undefined {
+  return cfg?.channels?.hermit?.accounts;
+}
+
+export function listHermitAccountIds(cfg: any): string[] {
+  const accounts = getHermitChannelConfig(cfg);
+  if (!accounts || Object.keys(accounts).length === 0) {
     return ["default"];
   }
-  return Object.keys(cfg.accounts);
+  return Object.keys(accounts);
 }
 
 export function resolveHermitAccount(
-  cfg: HermitChannelConfig,
+  cfg: any,
   accountId: string
 ): ResolvedHermitAccount {
-  const raw: HermitAccountConfig = cfg.accounts?.[accountId] ?? {};
+  const accounts = getHermitChannelConfig(cfg);
+  const raw: HermitAccountConfig = accounts?.[accountId] ?? {};
   return {
     accountId,
     endpoint: raw.endpoint ?? DEFAULT_ENDPOINT,

package/src/normalize.ts

@@ -10,15 +10,27 @@ export function formatSessionKey(accountId: string, channelId: string): string {
   return `hermit:${accountId}:${channelId}`;
 }
 
-export function parseSessionKey(key: string): ParsedSessionKey {
-  const parts = key.split(":");
-  if (parts.length !== 3 || parts[0] !== "hermit") {
-    throw new Error(`Invalid Hermit session key: ${key}`);
+export function parseSessionKey(key: string): ParsedSessionKey | null {
+  if (!key.startsWith("hermit:")) {
+    return null;
   }
-  return { accountId: parts[1], channelId: parts[2] };
+  const rest = key.slice("hermit:".length);
+  const colonIndex = rest.indexOf(":");
+  if (colonIndex < 0) {
+    return null;
+  }
+  const accountId = rest.slice(0, colonIndex);
+  const channelId = rest.slice(colonIndex + 1);
+  if (!accountId || !channelId) {
+    return null;
+  }
+  return { accountId, channelId };
 }
 
-export function normalizeHermitTarget(raw: string): string {
-  parseSessionKey(raw);
+export function normalizeHermitTarget(raw: string): string | undefined {
+  const parsed = parseSessionKey(raw);
+  if (!parsed) {
+    return undefined;
+  }
   return raw;
 }

package/src/openclaw-plugin-sdk.d.ts

@@ -29,35 +29,44 @@ declare module "openclaw/plugin-sdk" {
     meta: {
       id: string;
       label: string;
+      selectionLabel?: string;
+      docsPath?: string;
+      blurb?: string;
       order: number;
     };
     capabilities: {
       chatTypes: string[];
       media: boolean;
     };
+    reload?: {
+      configPrefixes?: string[];
+    };
     config: {
       listAccountIds(cfg: any): string[];
       resolveAccount(cfg: any, accountId: string): TAccount;
       defaultAccountId(cfg: any): string;
+      isConfigured?(account: TAccount): boolean;
+      describeAccount?(account: TAccount): Record<string, unknown>;
     };
     messaging: {
-      normalizeTarget: (raw: string) => string;
+      normalizeTarget: (raw: string) => string | undefined;
       targetResolver: {
         looksLikeId(raw: string): boolean;
+        hint?: string;
       };
     };
     heartbeat: {
-      checkReady(account: TAccount): Promise<boolean>;
+      checkReady(ctx: any): Promise<boolean>;
     };
     status: {
       probeAccount(account: TAccount): Promise<TProbe>;
     };
     outbound: {
-      sendText(account: TAccount, sessionKey: string, text: string): Promise<void>;
-      sendMedia(...args: unknown[]): Promise<void>;
+      sendText(ctx: any): Promise<any>;
+      sendMedia(ctx: any): Promise<any>;
     };
     gateway: {
-      startAccount(account: TAccount): Promise<() => void>;
+      startAccount(ctx: any): Promise<() => void>;
     };
   }