@ascegu/teamily 1.0.5 → 1.0.7

package/README.md

@@ -23,6 +23,7 @@ openclaw channel configure teamily
 ```
 
 Required server settings:
+
 - `platformUrl`: Teamily platform URL (default: `http://localhost:10002`)
 - `apiURL`: Teamily REST API URL (default: `http://localhost:10002`)
 - `wsURL`: Teamily WebSocket URL (default: `ws://localhost:10001`)

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "@ascegu/teamily",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "OpenClaw Teamily channel plugin - Team instant messaging server integration",
-  "type": "module",
-  "main": "index.ts",
-  "files": [
-    "*.ts",
-    "*.js",
-    "*.json",
-    "src/",
-    "README.md"
-  ],
   "keywords": [
-    "openclaw",
-    "plugin",
     "channel",
-    "teamily",
-    "openim",
+    "communication",
     "messaging",
+    "openclaw",
+    "openim",
+    "plugin",
     "team",
-    "communication"
+    "teamily"
   ],
-  "author": "ascegu",
   "license": "MIT",
+  "author": "ascegu",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ascegu/openclaw.git",
     "directory": "extensions/teamily"
   },
+  "files": [
+    "*.ts",
+    "*.js",
+    "*.json",
+    "src/",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "index.ts",
   "dependencies": {
     "zod": "^4.3.6"
   },

package/src/accounts.ts

@@ -6,9 +6,7 @@ export function listTeamilyAccountIds(cfg: CoreConfig): string[] {
   if (!config?.enabled || !config.accounts) {
     return [];
   }
-  return Object.keys(config.accounts).filter(
-    (key) => config.accounts![key].token !== undefined
-  );
+  return Object.keys(config.accounts).filter((key) => config.accounts![key].token !== undefined);
 }
 
 export function resolveDefaultTeamilyAccountId(cfg: CoreConfig): string {
@@ -18,7 +16,7 @@ export function resolveDefaultTeamilyAccountId(cfg: CoreConfig): string {
 
 export function resolveTeamilyAccount(
   cfg: CoreConfig,
-  accountId?: string | null
+  accountId?: string | null,
 ): ResolvedTeamilyAccount {
   const config = cfg.channels?.teamily;
   if (!config?.enabled) {
@@ -47,5 +45,6 @@ export function resolveTeamilyAccount(
     token: account.token,
     nickname: account.nickname,
     faceURL: account.faceURL,
+    dm: account.dm ?? config.dm,
   };
 }

package/src/channel.ts

@@ -3,30 +3,31 @@ import {
   buildChannelConfigSchema,
   DEFAULT_ACCOUNT_ID,
   deleteAccountFromConfigSection,
-  formatPairingApproveHint,
   normalizeAccountId,
   PAIRING_APPROVED_MESSAGE,
   setAccountEnabledInConfigSection,
   type ChannelPlugin,
   type ChannelOutboundContext,
-  type ChannelOutboundAdapter,
-  type ChannelStatusAdapter,
   type ChannelStatusIssue,
 } from "openclaw/plugin-sdk";
-import { TeamilyConfigSchema } from "./config-schema.js";
+import {
+  buildAccountScopedDmSecurityPolicy,
+  createScopedAccountConfigAccessors,
+} from "openclaw/plugin-sdk/compat";
 import {
   listTeamilyAccountIds,
   resolveDefaultTeamilyAccountId,
   resolveTeamilyAccount,
-  type ResolvedTeamilyAccount,
 } from "./accounts.js";
-import { probeTeamily } from "./probe.js";
-import { sendMessageTeamily, sendMediaTeamily } from "./send.js";
+import { TeamilyConfigSchema } from "./config-schema.js";
+import type { CoreConfig } from "./config-schema.js";
 import { startTeamilyMonitoring, stopTeamilyMonitoring } from "./monitor.js";
 import { normalizeTeamilyTarget, normalizeTeamilyAllowEntry } from "./normalize.js";
-import { SESSION_TYPES } from "./types.js";
+import { probeTeamily } from "./probe.js";
 import { getTeamilyRuntime } from "./runtime.js";
-import type { CoreConfig } from "./config-schema.js";
+import { sendMessageTeamily, sendMediaTeamily } from "./send.js";
+import type { ResolvedTeamilyAccount } from "./types.js";
+import { SESSION_TYPES } from "./types.js";
 
 const meta = {
   id: "teamily",
@@ -39,33 +40,42 @@ const meta = {
   quickstartAllowFrom: true,
 };
 
-const capabilities = {
-  chatTypes: ["direct", "group"] as const,
-  media: true,
-  reactions: true,
-  threads: false,
-  polls: false,
-  streaming: false,
-};
+const teamilyConfigAccessors = createScopedAccountConfigAccessors({
+  resolveAccount: ({ cfg, accountId }) => resolveTeamilyAccount(cfg as CoreConfig, accountId),
+  resolveAllowFrom: (account) => account.dm?.allowFrom,
+  formatAllowFrom: (allowFrom) => allowFrom.map((id) => String(id)),
+});
 
 export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
   id: "teamily",
   meta,
-  capabilities,
-  onboarding: {
-    promptAccountId,
-    resolveAccountId,
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    media: true,
+    reactions: false,
+    threads: false,
+    polls: false,
+  },
+  reload: { configPrefixes: ["channels.teamily"] },
+  setup: {
+    resolveAccountId: ({ accountId, input }) => {
+      if (accountId) return accountId;
+      if (input?.name) return normalizeAccountId(String(input.name));
+      return DEFAULT_ACCOUNT_ID;
+    },
     applyAccountName: ({ cfg, accountId, name }) =>
       applyAccountNameToChannelSection({
-        cfg: cfg as CoreConfig,
-        sectionKey: "teamily",
+        cfg,
+        channelKey: "teamily",
         accountId,
         name,
-        allowTopLevel: true,
       }),
     applyAccountConfig: ({ cfg, accountId, input }) =>
-      applyTeamilyAccountConfig({ cfg: cfg as CoreConfig, accountId, input }),
-    resolveBindingAccountId: ({ cfg }) => resolveDefaultTeamilyAccountId(cfg as CoreConfig),
+      applyTeamilyAccountConfig({
+        cfg: cfg as CoreConfig,
+        accountId,
+        input: input as Record<string, unknown>,
+      }),
   },
   pairing: {
     idLabel: "teamilyUserId",
@@ -94,8 +104,7 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
   configSchema: buildChannelConfigSchema(TeamilyConfigSchema),
   config: {
     listAccountIds: (cfg) => listTeamilyAccountIds(cfg as CoreConfig),
-    resolveAccount: (cfg, accountId) =>
-      resolveTeamilyAccount(cfg as CoreConfig, accountId),
+    resolveAccount: (cfg, accountId) => resolveTeamilyAccount(cfg as CoreConfig, accountId),
     defaultAccountId: (cfg) => resolveDefaultTeamilyAccountId(cfg as CoreConfig),
     setAccountEnabled: ({ cfg, accountId, enabled }) =>
       setAccountEnabledInConfigSection({
@@ -110,13 +119,7 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
         cfg: cfg as CoreConfig,
         sectionKey: "teamily",
         accountId,
-        clearBaseFields: [
-          "name",
-          "userID",
-          "token",
-          "nickname",
-          "faceURL",
-        ],
+        clearBaseFields: ["name", "userID", "token", "nickname", "faceURL"],
       }),
     isConfigured: (account) => !!account.token,
     describeAccount: (account) => ({
@@ -125,22 +128,38 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
       enabled: account.enabled,
       configured: !!account.token,
     }),
-    resolveAllowFrom: (cfg, accountId) => {
-      // Return empty array - allowFrom needs to be manually configured
-      return [];
-    },
-    formatAllowFrom: (cfg, allowFrom) => {
-      return allowFrom.map((id) => id.toString());
-    },
-    resolveDefaultTo: (cfg) => {
-      // No default target - user must specify
-      return undefined;
+    ...teamilyConfigAccessors,
+  },
+  security: {
+    resolveDmPolicy: ({ cfg, accountId, account }) => {
+      return buildAccountScopedDmSecurityPolicy({
+        cfg: cfg as CoreConfig,
+        channelKey: "teamily",
+        accountId,
+        fallbackAccountId: account.accountId ?? DEFAULT_ACCOUNT_ID,
+        policy: account.dm?.policy,
+        allowFrom: account.dm?.allowFrom ?? [],
+        allowFromPathSuffix: "dm.",
+        normalizeEntry: (raw) => normalizeTeamilyAllowEntry(raw),
+      });
     },
   },
   outbound: {
+    deliveryMode: "gateway",
+    resolveTarget: ({ to }) => {
+      if (!to?.trim()) {
+        return { ok: false, error: new Error("Teamily requires --to <userId|group:groupId>") };
+      }
+      try {
+        const target = normalizeTeamilyTarget(to);
+        return { ok: true, to: target.id };
+      } catch (err) {
+        return { ok: false, error: err instanceof Error ? err : new Error(String(err)) };
+      }
+    },
     sendText: async (ctx: ChannelOutboundContext) => {
       const { to, text, accountId } = ctx;
-      const account = resolveTeamilyAccount(ctx.cfg, accountId);
+      const account = resolveTeamilyAccount(ctx.cfg as CoreConfig, accountId);
       const target = normalizeTeamilyTarget(to);
 
       const result = await sendMessageTeamily({
@@ -154,11 +173,15 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
         throw new Error(result.error || "Failed to send message");
       }
 
-      return { messageId: result.messageId };
+      return { channel: "teamily" as const, messageId: result.messageId ?? "" };
     },
     sendMedia: async (ctx: ChannelOutboundContext) => {
-      const { to, mediaUrl, text, accountId } = ctx;
-      const account = resolveTeamilyAccount(ctx.cfg, accountId);
+      const { to, text, accountId } = ctx;
+      const mediaUrl = ctx.mediaUrl;
+      if (!mediaUrl) {
+        throw new Error("Media URL is required");
+      }
+      const account = resolveTeamilyAccount(ctx.cfg as CoreConfig, accountId);
       const target = normalizeTeamilyTarget(to);
 
       // Determine media type from URL or assume image
@@ -166,7 +189,11 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
       const urlLower = mediaUrl.toLowerCase();
       if (urlLower.endsWith(".mp4") || urlLower.endsWith(".mov") || urlLower.endsWith(".webm")) {
         mediaType = "video";
-      } else if (urlLower.endsWith(".mp3") || urlLower.endsWith(".m4a") || urlLower.endsWith(".wav")) {
+      } else if (
+        urlLower.endsWith(".mp3") ||
+        urlLower.endsWith(".m4a") ||
+        urlLower.endsWith(".wav")
+      ) {
         mediaType = "audio";
       } else if (
         urlLower.endsWith(".pdf") ||
@@ -189,80 +216,54 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
         throw new Error(result.error || "Failed to send media");
       }
 
-      return { messageId: result.messageId };
-    },
-    resolveTarget: (raw) => {
-      return normalizeTeamilyTarget(raw).id;
+      return { channel: "teamily" as const, messageId: result.messageId ?? "" };
     },
   },
   status: {
-    probeAccount: async (cfg, accountId) => {
-      const account = resolveTeamilyAccount(cfg as CoreConfig, accountId);
+    probeAccount: async ({ account }) => {
       const result = await probeTeamily(account);
-
       if (!result.connected) {
         return {
-          connected: false,
+          ok: false,
           error: result.error || "Failed to connect to Teamily server",
         };
       }
-
-      return { connected: true };
-    },
-    buildAccountSnapshot: (cfg, accountId) => {
-      const account = resolveTeamilyAccount(cfg as CoreConfig, accountId);
-      return {
-        accountId,
-        name: account.nickname || account.userID,
-        enabled: account.enabled,
-        configured: !!account.token,
-      };
+      return { ok: true };
     },
-    collectStatusIssues: async (cfg, accountId) => {
+    buildAccountSnapshot: ({ account, runtime, probe }) => ({
+      accountId: account.accountId,
+      name: account.nickname || account.userID,
+      enabled: account.enabled,
+      configured: !!account.token,
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      probe,
+    }),
+    collectStatusIssues: (accounts) => {
       const issues: ChannelStatusIssue[] = [];
-      const account = resolveTeamilyAccount(cfg as CoreConfig, accountId);
-
-      if (!account.token) {
-        issues.push({
-          channel: "teamily",
-          accountId,
-          kind: "config",
-          message: "User token is not configured",
-          fix: "Run `openclaw channel configure teamily` to set up authentication",
-        });
-      }
-
-      if (!account.apiURL || account.apiURL === "http://localhost:10002") {
-        issues.push({
-          channel: "teamily",
-          accountId,
-          kind: "config",
-          message: "Teamily API URL is set to default localhost",
-          fix: "Update the API URL to your Teamily server address",
-        });
-      }
-
-      const probeResult = await probeTeamily(account);
-      if (!probeResult.connected) {
-        issues.push({
-          channel: "teamily",
-          accountId,
-          kind: "runtime",
-          message: probeResult.error || "Cannot connect to Teamily server",
-          fix: "Check that the Teamily server is running and accessible",
-        });
+      for (const snap of accounts) {
+        if (snap.lastError) {
+          issues.push({
+            channel: "teamily",
+            accountId: snap.accountId,
+            kind: "runtime",
+            message: snap.lastError,
+            fix: "Check that the Teamily server is running and accessible",
+          });
+        }
       }
-
       return issues;
     },
   },
   gateway: {
     startAccount: async (ctx) => {
-      const { cfg, accountId, account, log } = ctx;
+      const { accountId, account, log } = ctx;
 
       if (!account.token) {
         log?.warn?.(`Teamily account ${accountId} not configured (missing token)`);
-        return { stop: () => {} };
+        return;
       }
 
       log?.info?.(`Starting Teamily channel (account: ${accountId})`);
@@ -291,7 +292,7 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
           To: account.userID,
           SessionKey: sessionKey,
           AccountId: accountId,
-          OriginatingChannel: "teamily" as any,
+          OriginatingChannel: "teamily" as const,
           OriginatingTo: from,
           ChatType: isGroup ? "group" : "direct",
           MediaUrl: mediaUrl,
@@ -321,91 +322,50 @@ export const teamilyPlugin: ChannelPlugin<ResolvedTeamilyAccount> = {
         stopTeamilyMonitoring(accountId);
       });
 
-      // Return a promise that never resolves (monitor runs indefinitely)
-      return new Promise<void>(() => {});
+      // Block until aborted — monitor runs indefinitely
+      await new Promise<void>((resolve) => {
+        ctx.abortSignal.addEventListener("abort", () => resolve());
+      });
     },
   },
 };
 
-/**
- * Normalize account ID for Teamily.
- */
-function promptAccountId(): string {
-  return DEFAULT_ACCOUNT_ID;
-}
-
-function resolveAccountId(params: {
-  cfg: CoreConfig;
-  accountId?: string;
-  input?: { name?: string };
-}): string {
-  const { cfg, accountId, input } = params;
-  if (accountId) {
-    return accountId;
-  }
-  if (input?.name) {
-    return normalizeAccountId(input.name);
-  }
-  const accountIds = listTeamilyAccountIds(cfg);
-  return accountIds[0] || DEFAULT_ACCOUNT_ID;
-}
-
-/**
- * Apply Teamily account configuration.
- */
 function applyTeamilyAccountConfig(params: {
   cfg: CoreConfig;
   accountId: string;
   input: Record<string, unknown>;
 }): CoreConfig {
   const { cfg, accountId, input } = params;
-  const existing = cfg.channels?.teamily || { enabled: false, server: {}, accounts: {} };
+  const existing = cfg.channels?.teamily;
+  const server = existing?.server ?? { platformUrl: "", apiURL: "", wsURL: "" };
+  const accounts = existing?.accounts ?? {};
 
   const accountUpdate: Record<string, unknown> = {};
-  if (input.userID) {
-    accountUpdate.userID = String(input.userID);
-  }
-  if (input.token) {
-    accountUpdate.token = String(input.token);
-  }
-  if (input.nickname) {
-    accountUpdate.nickname = String(input.nickname);
-  }
-  if (input.faceURL) {
-    accountUpdate.faceURL = String(input.faceURL);
-  }
+  if (input.userID) accountUpdate.userID = String(input.userID);
+  if (input.token) accountUpdate.token = String(input.token);
+  if (input.nickname) accountUpdate.nickname = String(input.nickname);
+  if (input.faceURL) accountUpdate.faceURL = String(input.faceURL);
 
-  // Server configuration from input or existing
-  const serverUpdate: Record<string, unknown> = {};
-  if (input.platformUrl) {
-    serverUpdate.platformUrl = String(input.platformUrl);
-  }
-  if (input.apiURL) {
-    serverUpdate.apiURL = String(input.apiURL);
-  }
-  if (input.wsURL) {
-    serverUpdate.wsURL = String(input.wsURL);
-  }
+  const serverUpdate: Record<string, string> = {};
+  if (input.platformUrl) serverUpdate.platformUrl = String(input.platformUrl);
+  if (input.apiURL) serverUpdate.apiURL = String(input.apiURL);
+  if (input.wsURL) serverUpdate.wsURL = String(input.wsURL);
 
   return {
     ...cfg,
     channels: {
       ...cfg.channels,
       teamily: {
-        ...existing,
         enabled: true,
-        server: {
-          ...existing.server,
-          ...serverUpdate,
-        },
+        server: { ...server, ...serverUpdate },
         accounts: {
-          ...existing.accounts,
+          ...accounts,
           [accountId]: {
-            ...(existing.accounts?.[accountId] || {}),
+            ...accounts[accountId],
             ...accountUpdate,
           },
         },
       },
     },
-  };
+  } as CoreConfig;
 }

package/src/config-schema.ts

@@ -1,63 +1,46 @@
-import { z } from "zod";
 import type { ChannelConfigSchema } from "openclaw/plugin-sdk";
 import { buildChannelConfigSchema } from "openclaw/plugin-sdk";
+import { z } from "zod";
 import type { TeamilyConfig } from "./types.js";
 
 // Server configuration schema
 export const TeamilyServerConfigSchema = z.object({
-  platformUrl: z
-    .string()
-    .url()
-    .default("http://localhost:10002")
-    .describe("Teamily platform URL"),
-  apiURL: z
-    .string()
-    .url()
-    .default("http://localhost:10002")
-    .describe("Teamily REST API URL"),
-  wsURL: z
-    .string()
-    .url()
-    .default("ws://localhost:10001")
-    .describe("Teamily WebSocket URL"),
+  platformUrl: z.string().url().default("http://localhost:10002").describe("Teamily platform URL"),
+  apiURL: z.string().url().default("http://localhost:10002").describe("Teamily REST API URL"),
+  wsURL: z.string().url().default("ws://localhost:10001").describe("Teamily WebSocket URL"),
+});
+
+// DM security configuration schema
+export const TeamilyDmConfigSchema = z.object({
+  policy: z.string().optional().describe("DM security policy (pairing, allowlist, open)"),
+  allowFrom: z
+    .array(z.union([z.string(), z.number()]))
+    .optional()
+    .describe("List of allowed sender IDs"),
 });
 
 // User account configuration schema
 export const TeamilyUserAccountSchema = z.object({
-  userID: z
-    .string()
-    .min(1)
-    .describe("User ID for the bot account"),
-  token: z
-    .string()
-    .min(1)
-    .describe("User token for authentication"),
-  nickname: z
-    .string()
-    .optional()
-    .describe("Display nickname for the bot"),
-  faceURL: z
-    .string()
-    .url()
-    .optional()
-    .describe("Avatar URL for the bot"),
+  userID: z.string().min(1).describe("User ID for the bot account"),
+  token: z.string().min(1).describe("User token for authentication"),
+  nickname: z.string().optional().describe("Display nickname for the bot"),
+  faceURL: z.string().url().optional().describe("Avatar URL for the bot"),
+  dm: TeamilyDmConfigSchema.optional().describe("Per-account DM security settings"),
 });
 
 // Main Teamily configuration schema
 export const TeamilyConfigSchema = z.object({
-  enabled: z
-    .boolean()
-    .default(true)
-    .describe("Enable Teamily channel"),
+  enabled: z.boolean().default(true).describe("Enable Teamily channel"),
   server: TeamilyServerConfigSchema.describe("Teamily server configuration"),
   accounts: z
     .record(z.string(), TeamilyUserAccountSchema)
     .default({})
     .describe("Teamily bot accounts"),
+  dm: TeamilyDmConfigSchema.optional().describe("Channel-level DM security settings"),
 });
 
 export const TeamilyChannelConfigSchema = buildChannelConfigSchema(
-  TeamilyConfigSchema
+  TeamilyConfigSchema,
 ) as ChannelConfigSchema;
 
 export type CoreConfig = {

package/src/monitor.ts

@@ -1,3 +1,4 @@
+import { generateOperationID } from "./probe.js";
 import type {
   ResolvedTeamilyAccount,
   TeamilyMessage,
@@ -6,7 +7,6 @@ import type {
   TeamilyAudioContent,
 } from "./types.js";
 import { CONTENT_TYPES, SESSION_TYPES } from "./types.js";
-import { generateOperationID } from "./probe.js";
 
 const WS_REQ = {
   LOGIN: 1001,
@@ -80,8 +80,17 @@ export class TeamilyMonitor {
     }
 
     if (this.ws) {
-      this.ws.close(1000, "Monitoring stopped");
+      const ws = this.ws;
+      ws.onopen = null;
+      ws.onmessage = null;
+      ws.onerror = null;
+      ws.onclose = null;
       this.ws = null;
+      try {
+        ws.close(1000, "Monitoring stopped");
+      } catch {
+        // Ignore – socket may already be closed.
+      }
     }
 
     this.setState("disconnected");
@@ -128,13 +137,15 @@ export class TeamilyMonitor {
       return;
     }
     try {
-      this.ws.send(JSON.stringify({
-        reqIdentifier: WS_REQ.LOGIN,
-        operationID: generateOperationID(),
-        sendID: this.account.userID,
-        token: this.account.token,
-        platformID: 5,
-      }));
+      this.ws.send(
+        JSON.stringify({
+          reqIdentifier: WS_REQ.LOGIN,
+          operationID: generateOperationID(),
+          sendID: this.account.userID,
+          token: this.account.token,
+          platformID: 5,
+        }),
+      );
     } catch (error) {
       this.handleError(error);
     }
@@ -201,15 +212,28 @@ export class TeamilyMonitor {
 
   /**
    * Handle WebSocket error.
+   * Detaches event handlers before closing to prevent recursive calls
+   * (ws.close() on an errored socket can re-fire onerror → stack overflow).
    */
   private handleError(error: unknown): void {
     const errorMessage = error instanceof Error ? error.message : String(error);
     this.setState("error", errorMessage);
 
-    // Close the connection so it can be re-established
-    if (this.ws) {
-      this.ws.close();
+    // Detach handlers and grab ref before nulling, so close() cannot recurse.
+    const ws = this.ws;
+    if (ws) {
+      ws.onopen = null;
+      ws.onmessage = null;
+      ws.onerror = null;
+      ws.onclose = null;
       this.ws = null;
+      try {
+        ws.close();
+      } catch {
+        // Ignore – socket may already be closed/invalid.
+      }
+      // onclose was detached, so manually trigger reconnect logic.
+      this.handleClose();
     }
   }
 
@@ -259,12 +283,14 @@ export class TeamilyMonitor {
   private sendPing(): void {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       try {
-        this.ws.send(JSON.stringify({
-          reqIdentifier: WS_REQ.HEARTBEAT,
-          operationID: generateOperationID(),
-          sendID: this.account.userID,
-          sendTime: Date.now(),
-        }));
+        this.ws.send(
+          JSON.stringify({
+            reqIdentifier: WS_REQ.HEARTBEAT,
+            operationID: generateOperationID(),
+            sendID: this.account.userID,
+            sendTime: Date.now(),
+          }),
+        );
       } catch (error) {
         console.error("Teamily ping failed:", error);
       }
@@ -291,25 +317,17 @@ export class TeamilyMonitor {
  * Parse raw OpenIM message content into normalized internal format.
  * OpenIM text messages use `{ content: "text" }`, not `{ text: "..." }`.
  */
-function parseMessageContent(
-  raw: unknown,
-  contentType: number,
-): TeamilyMessage["content"] {
+function parseMessageContent(raw: unknown, contentType: number): TeamilyMessage["content"] {
   if (!raw) {
     return {};
   }
 
-  const obj = (
-    typeof raw === "string" ? JSON.parse(raw) : raw
-  ) as Record<string, unknown>;
+  const obj = (typeof raw === "string" ? JSON.parse(raw) : raw) as Record<string, unknown>;
 
   switch (contentType) {
     case CONTENT_TYPES.TEXT:
       return {
-        text:
-          typeof obj.content === "string"
-            ? obj.content
-            : String(obj.content ?? ""),
+        text: typeof obj.content === "string" ? obj.content : String(obj.content ?? ""),
       };
     case CONTENT_TYPES.PICTURE:
       return { picture: obj as unknown as TeamilyPictureContent };
@@ -333,7 +351,7 @@ const monitors = new Map<string, TeamilyMonitor>();
 export function startTeamilyMonitoring(
   account: ResolvedTeamilyAccount,
   onMessage: TeamilyMessageHandler,
-  onStateChange?: (state: TeamilyConnectionState, error?: string) => void
+  onStateChange?: (state: TeamilyConnectionState, error?: string) => void,
 ): () => void {
   const monitor = new TeamilyMonitor({
     account,

package/src/normalize.ts

@@ -25,13 +25,8 @@ export function normalizeTeamilyTarget(raw: string): TeamilyMessageTarget {
     : trimmed;
 
   // Group target
-  if (
-    withoutPrefix.startsWith("group:") ||
-    withoutPrefix.startsWith("g:")
-  ) {
-    const groupId = withoutPrefix
-      .replace(/^(group:|g:)/i, "")
-      .trim();
+  if (withoutPrefix.startsWith("group:") || withoutPrefix.startsWith("g:")) {
+    const groupId = withoutPrefix.replace(/^(group:|g:)/i, "").trim();
     if (!groupId) {
       throw new Error("Group ID cannot be empty");
     }
@@ -39,9 +34,7 @@ export function normalizeTeamilyTarget(raw: string): TeamilyMessageTarget {
   }
 
   // User target
-  const userId = withoutPrefix
-    .replace(/^(user:|u:)/i, "")
-    .trim();
+  const userId = withoutPrefix.replace(/^(user:|u:)/i, "").trim();
   if (!userId) {
     throw new Error("User ID cannot be empty");
   }
@@ -79,8 +72,13 @@ export function looksLikeTeamilyTargetId(raw: string): boolean {
   const lowered = trimmed.toLowerCase();
 
   // Check for explicit prefixes
-  if (lowered.startsWith("teamily:") || lowered.startsWith("user:") || lowered.startsWith("u:") ||
-      lowered.startsWith("group:") || lowered.startsWith("g:")) {
+  if (
+    lowered.startsWith("teamily:") ||
+    lowered.startsWith("user:") ||
+    lowered.startsWith("u:") ||
+    lowered.startsWith("group:") ||
+    lowered.startsWith("g:")
+  ) {
     return true;
   }
 

package/src/probe.ts

@@ -18,7 +18,7 @@ export function generateOperationID(): string {
  */
 export async function probeTeamily(
   account: ResolvedTeamilyAccount,
-  fetchImpl: typeof fetch = fetch
+  fetchImpl: typeof fetch = fetch,
 ): Promise<TeamilyProbeResult> {
   try {
     const url = `${account.apiURL}/user/get_users_info`;
@@ -27,8 +27,8 @@ export async function probeTeamily(
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "operationID": generateOperationID(),
-        "token": account.token,
+        operationID: generateOperationID(),
+        token: account.token,
       },
       body: JSON.stringify({
         userIDs: [account.userID],
@@ -44,7 +44,7 @@ export async function probeTeamily(
       };
     }
 
-    const data = await response.json() as {
+    const data = (await response.json()) as {
       errCode: number;
       errMsg: string;
       data?: Array<{ userID: string }>;

package/src/runtime.ts

@@ -1,14 +1,6 @@
 import type { PluginRuntime } from "openclaw/plugin-sdk";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/compat";
 
-let teamilyRuntime: PluginRuntime | null = null;
-
-export function setTeamilyRuntime(runtime: PluginRuntime): void {
-  teamilyRuntime = runtime;
-}
-
-export function getTeamilyRuntime(): PluginRuntime {
-  if (!teamilyRuntime) {
-    throw new Error("Teamily runtime not initialized");
-  }
-  return teamilyRuntime;
-}
+const { setRuntime: setTeamilyRuntime, getRuntime: getTeamilyRuntime } =
+  createPluginRuntimeStore<PluginRuntime>("Teamily runtime not initialized");
+export { getTeamilyRuntime, setTeamilyRuntime };

package/src/send.ts

@@ -1,6 +1,6 @@
+import { generateOperationID } from "./probe.js";
 import type { ResolvedTeamilyAccount, TeamilyMessageTarget } from "./types.js";
 import { CONTENT_TYPES, SESSION_TYPES } from "./types.js";
-import { generateOperationID } from "./probe.js";
 
 export interface SendTeamilyMessageParams {
   account: ResolvedTeamilyAccount;
@@ -34,7 +34,7 @@ export interface TeamilySendResult {
  * @returns Send result with message ID or error
  */
 export async function sendMessageTeamily(
-  params: SendTeamilyMessageParams
+  params: SendTeamilyMessageParams,
 ): Promise<TeamilySendResult> {
   const { account, target, text, replyToId, fetchImpl = fetch } = params;
 
@@ -53,8 +53,8 @@ export async function sendMessageTeamily(
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "operationID": generateOperationID(),
-        "token": account.token,
+        operationID: generateOperationID(),
+        token: account.token,
       },
       body: JSON.stringify(payload),
     });
@@ -67,7 +67,7 @@ export async function sendMessageTeamily(
       };
     }
 
-    const data = await response.json() as {
+    const data = (await response.json()) as {
       errCode: number;
       errMsg: string;
       data?: {
@@ -104,9 +104,7 @@ export async function sendMessageTeamily(
  * @param params - Send parameters
  * @returns Send result with message ID or error
  */
-export async function sendMediaTeamily(
-  params: SendTeamilyMediaParams
-): Promise<TeamilySendResult> {
+export async function sendMediaTeamily(params: SendTeamilyMediaParams): Promise<TeamilySendResult> {
   const { account, target, mediaUrl, mediaType, caption, fetchImpl = fetch } = params;
 
   const url = `${account.apiURL}/msg/send_msg`;
@@ -192,8 +190,8 @@ export async function sendMediaTeamily(
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "operationID": generateOperationID(),
-        "token": account.token,
+        operationID: generateOperationID(),
+        token: account.token,
       },
       body: JSON.stringify(payload),
     });
@@ -206,7 +204,7 @@ export async function sendMediaTeamily(
       };
     }
 
-    const data = await response.json() as {
+    const data = (await response.json()) as {
       errCode: number;
       errMsg: string;
       data?: {

package/src/types.ts

@@ -6,17 +6,24 @@ export interface TeamilyServerConfig {
   wsURL: string;
 }
 
+export interface TeamilyDmConfig {
+  policy?: string;
+  allowFrom?: Array<string | number>;
+}
+
 export interface TeamilyUserAccount {
   userID: string;
   token: string;
   nickname?: string;
   faceURL?: string;
+  dm?: TeamilyDmConfig;
 }
 
 export interface TeamilyConfig {
   enabled: boolean;
   server: TeamilyServerConfig;
   accounts: Record<string, TeamilyUserAccount>;
+  dm?: TeamilyDmConfig;
 }
 
 export interface ResolvedTeamilyAccount {
@@ -29,6 +36,7 @@ export interface ResolvedTeamilyAccount {
   token: string;
   nickname?: string;
   faceURL?: string;
+  dm?: TeamilyDmConfig;
 }
 
 export interface TeamilyMessageTarget {