@workclaw/openclaw-workclaw 1.0.16 → 1.0.18

package/src/api/workspace.ts

@@ -1,43 +1,41 @@
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import os from 'node:os'
-import path from 'node:path'
-import process from 'node:process'
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import os from "node:os";
+import path from "node:path";
 
 export function resolveWorkspaceDir(api: OpenClawPluginApi): string {
-  const agents = api.config.agents?.list ?? []
-  const defaultAgent
-    = agents.find(agent => agent?.default === true)
-      ?? agents.find(agent => String(agent?.id ?? '').toLowerCase() === 'main')
+  const agents = api.config.agents?.list ?? [];
+  const defaultAgent =
+    agents.find((agent) => agent?.default === true) ??
+    agents.find((agent) => String(agent?.id ?? "").toLowerCase() === "main");
 
-  const workspaceRaw
-    = (typeof defaultAgent?.workspace === 'string' && defaultAgent.workspace.trim())
-      || (typeof api.config.agents?.defaults?.workspace === 'string'
-        && api.config.agents.defaults.workspace.trim())
+  const workspaceRaw =
+    (typeof defaultAgent?.workspace === "string" && defaultAgent.workspace.trim()) ||
+    (typeof api.config.agents?.defaults?.workspace === "string" &&
+      api.config.agents.defaults.workspace.trim());
 
   if (workspaceRaw) {
-    return api.resolvePath(workspaceRaw)
+    return api.resolvePath(workspaceRaw);
   }
 
-  const profile = process.env.OPENCLAW_PROFILE?.trim()
-  const suffix
-    = profile && profile.toLowerCase() !== 'default' ? `workspace-${profile}` : 'workspace'
-  return path.join(os.homedir(), '.openclaw', suffix)
+  const profile = process.env.OPENCLAW_PROFILE?.trim();
+  const suffix =
+    profile && profile.toLowerCase() !== "default" ? `workspace-${profile}` : "workspace";
+  return path.join(os.homedir(), ".openclaw", suffix);
 }
 
 export function isDefaultWorkspace(api: OpenClawPluginApi): boolean {
-  const agents = api.config.agents?.list ?? []
-  const defaultAgent
-    = agents.find(agent => agent?.default === true)
-      ?? agents.find(agent => String(agent?.id ?? '').toLowerCase() === 'main')
+  const agents = api.config.agents?.list ?? [];
+  const defaultAgent =
+    agents.find((agent) => agent?.default === true) ??
+    agents.find((agent) => String(agent?.id ?? "").toLowerCase() === "main");
 
-  const workspaceRaw
-    = (typeof defaultAgent?.workspace === 'string' && defaultAgent.workspace.trim())
-      || (typeof api.config.agents?.defaults?.workspace === 'string'
-        && api.config.agents.defaults.workspace.trim())
+  const workspaceRaw =
+    (typeof defaultAgent?.workspace === "string" && defaultAgent.workspace.trim()) ||
+    (typeof api.config.agents?.defaults?.workspace === "string" &&
+      api.config.agents.defaults.workspace.trim());
 
-  if (workspaceRaw)
-    return false
+  if (workspaceRaw) return false;
 
-  const profile = process.env.OPENCLAW_PROFILE?.trim()
-  return !profile || profile.toLowerCase() === 'default'
+  const profile = process.env.OPENCLAW_PROFILE?.trim();
+  return !profile || profile.toLowerCase() === "default";
 }

package/src/channel.ts

@@ -1,227 +1,225 @@
 import type {
-  ChannelGatewayContext,
-  ChannelPlugin,
-  OpenClawConfig,
-} from 'openclaw/plugin-sdk'
-import type { OpenclawWorkclawConfig, ResolvedOpenclawWorkclawAccount } from './types.js'
-import { appendFileSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
+    ChannelGatewayContext,
+    ChannelPlugin,
+    OpenClawConfig,
+} from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { formatPairingApproveHint } from "openclaw/plugin-sdk/core";
+import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import type { ResolvedWorkclawAccount, WorkclawConfig } from "./types.js";
 import {
-  isOpenclawWorkclawAccountConfigured,
-  listOpenclawWorkclawAccountIds,
-  resolveOpenclawWorkclawAccount,
-} from './accounts.js'
-import { OpenclawWorkclawConfigSchema } from './config-schema.js'
-import { startOpenclawWorkclawGateway, stopOpenclawWorkclawGateway } from './gateway/workclaw-gateway.js'
-import { sendMessageOpenclawWorkclaw } from './outbound/index.js'
-import { getOpenclawWorkclawRuntime } from './runtime.js'
-
-const DEFAULT_ACCOUNT_ID = 'default'
-
-function buildChannelConfigSchema(schema: unknown): any {
-  return schema
-}
-
-function formatPairingApproveHint(_channelId: string): string {
-  return '请回复验证码完成配对'
-}
+    isWorkclawAccountConfigured,
+    listWorkclawAccountIds,
+    resolveWorkclawAccount,
+} from "./accounts.js";
+import { WorkclawConfigSchema } from "./config-schema.js";
+import { sendMessageWorkclaw } from "./outbound/index.js";
+import { setWorkclawRuntime, getWorkclawRuntime, getWorkclawWsConnection, getLastInboundAt, getLastOutboundAt } from "./runtime.js";
+import { startWorkclawGateway, stopWorkclawGateway } from "./gateway/workclaw-gateway.js";
+import { appendFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 
 const meta = {
-  id: 'openclaw-workclaw',
-  label: '智小途',
-  selectionLabel: '智小途',
-  docsPath: '/channels/openclaw-workclaw',
-  docsLabel: '智小途',
-  blurb: '智小途 OpenClaw通道',
-  aliases: [],
-  order: 90,
-}
+    id: "openclaw-workclaw",
+    label: "智小途",
+    selectionLabel: "智小途",
+    docsPath: "/channels/openclaw-workclaw",
+    docsLabel: "智小途",
+    blurb: "智小途 OpenClaw通道",
+    aliases: [],
+    order: 90,
+};
 
 /**
  * 写入文件日志到磁盘
  * @param message 日志消息
  */
 function writeFileLog(message: string): void {
-  const timestamp = new Date().toISOString()
-  const logLine = `[${timestamp}] ${message}\n`
-  const logDir = join(homedir(), '.openclaw', 'logs')
-  const logFile = join(logDir, 'sendtext-outbound.log')
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] ${message}\n`;
+    const logDir = join(homedir(), ".openclaw", "logs");
+    const logFile = join(logDir, "sendtext-outbound.log");
 
-  try {
-    appendFileSync(logFile, logLine)
-  }
-  catch (err) {
-    console.error(`[writeFileLog] Failed to write log: ${err}`)
-  }
+    try {
+        appendFileSync(logFile, logLine);
+    } catch (err) {
+        console.error(`[writeFileLog] Failed to write log: ${err}`);
+    }
 }
 
-export const openclawWorkclawDock = {
-  id: 'openclaw-workclaw',
-  capabilities: {
-    chatTypes: ['direct', 'group'],
-    media: true,
-    blockStreaming: true,
-  },
-}
-
-export const openclawWorkclawPlugin: ChannelPlugin<ResolvedOpenclawWorkclawAccount> = {
-  id: 'openclaw-workclaw',
-  meta,
-  capabilities: {
-    chatTypes: ['direct', 'group'],
-    media: true,
-    reactions: false,
-    threads: false,
-    polls: false,
-    nativeCommands: false,
-    blockStreaming: true,
-  },
-  reload: { configPrefixes: ['channels.openclaw-workclaw'] },
-  configSchema: buildChannelConfigSchema(OpenclawWorkclawConfigSchema),
-  config: {
-    listAccountIds: cfg => listOpenclawWorkclawAccountIds(cfg as OpenClawConfig),
-    resolveAccount: (cfg, accountId) =>
-      resolveOpenclawWorkclawAccount({ cfg: cfg as OpenClawConfig, accountId }),
-    isConfigured: account => isOpenclawWorkclawAccountConfigured(account.config),
-    describeAccount: account => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: isOpenclawWorkclawAccountConfigured(account.config),
-    }),
-  },
-  security: {
-    resolveDmPolicy: ({ cfg, accountId, account }) => {
-      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID
-      const channelConfig = cfg.channels?.['openclaw-workclaw'] as OpenclawWorkclawConfig | undefined
-      const useAccountPath = Boolean(channelConfig?.accounts?.[resolvedAccountId])
-      const basePath = useAccountPath
-        ? `channels.openclaw-workclaw.accounts.${resolvedAccountId}.`
-        : 'channels.openclaw-workclaw.'
-      return {
-        policy: account.config.dmPolicy ?? 'pairing',
-        allowFrom: account.config.allowFrom ?? [],
-        policyPath: `${basePath}dmPolicy`,
-        allowFromPath: `${basePath}allowFrom`,
-        approveHint: formatPairingApproveHint('openclaw-workclaw'),
-        normalizeEntry: raw => raw.replace(/^openclaw-workclaw:/i, ''),
-      }
+export const workclawDock = {
+    id: "openclaw-workclaw",
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: true,
+        blockStreaming: true,
     },
-  },
-  status: {
-    buildAccountSnapshot: async ({ account }) => {
-      const { getOpenclawWorkclawWsConnection } = await import('./runtime.js')
-      const ws = getOpenclawWorkclawWsConnection(account.accountId)
-      const isConnected = ws && ws.readyState === 1 // WebSocket.OPEN = 1
+};
 
-      return {
-        accountId: account.accountId,
-        name: account.name,
-        enabled: account.enabled,
-        configured: account.configured,
-        connected: isConnected,
-        running: account.enabled && account.configured,
-        mode: account.config.connectionMode || 'workclaw',
-      }
+export const workclawPlugin: ChannelPlugin<ResolvedWorkclawAccount> = {
+    id: "openclaw-workclaw",
+    meta,
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: true,
+        reactions: false,
+        threads: false,
+        polls: false,
+        nativeCommands: false,
+        blockStreaming: true,
+    },
+    reload: { configPrefixes: ["channels.openclaw-workclaw"] },
+    configSchema: buildChannelConfigSchema(WorkclawConfigSchema),
+    config: {
+        listAccountIds: (cfg) => listWorkclawAccountIds(cfg as OpenClawConfig),
+        resolveAccount: (cfg, accountId) =>
+            resolveWorkclawAccount({ cfg: cfg as OpenClawConfig, accountId }),
+        isConfigured: (account) => isWorkclawAccountConfigured(account.config),
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: isWorkclawAccountConfigured(account.config),
+        }),
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: (text: string, _limit: number) => [text],
+        textChunkLimit: 4096,
+        sendText: async ({ to, text, accountId, cfg, replyToId }) => {
+            writeFileLog(`outbound sendText called: replyToId=${replyToId}, accountId=${accountId}, to=${to}, text=${text.substring(0, 100)}`);
+            const result = await sendMessageWorkclaw({
+                accountId: accountId ?? undefined,
+                cfg: cfg as OpenClawConfig,
+                to,
+                text,
+            });
+            return {
+                channel: "openclaw-workclaw",
+                ok: true,
+                messageId: result.messageId,
+            };
+        },
+        sendMedia: async ({ to, text, mediaUrl, accountId, cfg }) => {
+            if (!mediaUrl && !text.trim()) {
+                throw new Error("mediaUrl is required for outbound media");
+            }
+            const log = (getWorkclawRuntime() as any).log ?? console.log;
+            if (typeof log === "function") {
+                log(`outbound sendMedia called for ${to} with text ${text} and mediaUrl ${mediaUrl}`);
+            }
+            else if (log?.info) {
+                log.info(`outbound sendMedia called for ${to} with text ${text} and mediaUrl ${mediaUrl}`);
+            }
+            const messageText = text.trim() ? text : mediaUrl ?? "";
+            const result = await sendMessageWorkclaw({
+                accountId: accountId ?? undefined,
+                cfg: cfg as OpenClawConfig,
+                to,
+                text: messageText,
+                mediaUrl: mediaUrl ?? undefined,
+            });
+            return {
+                channel: "openclaw-workclaw",
+                ok: true,
+                messageId: result.messageId,
+            };
+        },
     },
-  },
-  outbound: {
-    deliveryMode: 'direct',
-    chunker: (text: string, _limit: number) => [text],
-    textChunkLimit: 4096,
-    sendText: async ({ to, text, accountId, cfg, replyToId }) => {
-      writeFileLog(`outbound sendText called: replyToId=${replyToId}, to=${to}, text=${text.substring(0, 100)}`)
-      const result = await sendMessageOpenclawWorkclaw({
-        accountId: accountId ?? undefined,
-        cfg: cfg as OpenClawConfig,
-        to,
-        text,
-      })
-      return {
-        channel: 'openclaw-workclaw',
-        ok: true,
-        messageId: result.messageId,
-      }
+    security: {
+        resolveDmPolicy: ({ cfg, accountId, account }) => {
+            const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+            const channelConfig = cfg.channels?.["openclaw-workclaw"] as WorkclawConfig | undefined;
+            const useAccountPath = Boolean(channelConfig?.accounts?.[resolvedAccountId]);
+            const basePath = useAccountPath
+                ? `channels.openclaw-workclaw.accounts.${resolvedAccountId}.`
+                : "channels.openclaw-workclaw.";
+            return {
+                policy: account.config.dmPolicy ?? "pairing",
+                allowFrom: account.config.allowFrom ?? [],
+                policyPath: `${basePath}dmPolicy`,
+                allowFromPath: `${basePath}allowFrom`,
+                approveHint: formatPairingApproveHint("openclaw-workclaw"),
+                normalizeEntry: (raw) => raw.replace(/^openclaw-workclaw:/i, ""),
+            };
+        },
     },
-    sendMedia: async ({ to, text, mediaUrl, accountId, cfg }) => {
-      if (!mediaUrl && !text.trim()) {
-        throw new Error('mediaUrl is required for outbound media')
-      }
-      const runtime = getOpenclawWorkclawRuntime() as any
-      const log = runtime.log ?? console.warn
-      if (typeof log === 'function') {
-        log(`outbound sendMedia called for ${to} with text ${text} and mediaUrl ${mediaUrl}`)
-      }
-      else if (log?.info) {
-        log.info(`outbound sendMedia called for ${to} with text ${text} and mediaUrl ${mediaUrl}`)
-      }
-      const messageText = text.trim() ? text : mediaUrl ?? ''
-      const result = await sendMessageOpenclawWorkclaw({
-        accountId: accountId ?? undefined,
-        cfg: cfg as OpenClawConfig,
-        to,
-        text: messageText,
-        mediaUrl: mediaUrl ?? undefined,
-      })
-      return {
-        channel: 'openclaw-workclaw',
-        ok: true,
-        messageId: result.messageId,
-      }
+    status: {
+        buildAccountSnapshot: async ({ account, cfg }) => {
+            // per-appKey 模式下 WebSocket 用 appKey 存储，per-account 用 accountId
+            const wsKey = account.config.wsConnectionStrategy === "per-appKey"
+                ? account.config.appKey
+                : account.accountId;
+            const ws = wsKey ? getWorkclawWsConnection(wsKey) : undefined;
+            const isConnected = ws && ws.readyState === 1; // WebSocket.OPEN = 1
+            const lastInboundAt = account.accountId ? getLastInboundAt(account.accountId) : undefined;
+            const lastOutboundAt = account.accountId ? getLastOutboundAt(account.accountId) : undefined;
+
+            return {
+                accountId: account.accountId,
+                name: account.name,
+                enabled: account.enabled,
+                configured: account.configured,
+                connected: isConnected,
+                running: account.enabled && account.configured,
+                mode: account.config.wsConnectionStrategy || "per-account",
+                lastInboundAt: lastInboundAt ?? null,
+                lastOutboundAt: lastOutboundAt ?? null,
+            };
+        },
     },
-  },
-  gateway: {
-    startAccount: async (ctx: ChannelGatewayContext<ResolvedOpenclawWorkclawAccount>) => {
-      const { setStatus, getStatus, account, accountId, cfg, log } = ctx
-      log?.info?.(`startAccount called for ${accountId}`)
+    gateway: {
+        startAccount: async (ctx: ChannelGatewayContext<ResolvedWorkclawAccount>) => {
+            const { setStatus, getStatus, account, accountId, cfg, log } = ctx;
+            log?.info?.(`startAccount called for ${accountId}`);
 
-      await startOpenclawWorkclawGateway({
-        accountId,
-        account,
-        cfg,
-        log,
-      })
+            await startWorkclawGateway({
+                accountId,
+                account,
+                cfg,
+                log,
+            });
 
-      setStatus({
-        ...getStatus(),
-        running: true,
-        lastStartAt: Date.now(),
-        lastError: null,
-      })
-      log?.info?.(`startAccount completed for ${accountId}, keeping pending until abort`)
+            setStatus({
+                ...getStatus(),
+                running: true,
+                lastStartAt: Date.now(),
+                lastError: null,
+            });
+            log?.info?.(`startAccount completed for ${accountId}, keeping pending until abort`);
 
-      // 保持 pending 状态直到 abortSignal 触发（防止 OpenClaw 3.8 认为启动立即退出）
-      await new Promise<void>((resolve) => {
-        if (ctx.abortSignal.aborted) {
-          resolve()
-          return
-        }
-        ctx.abortSignal.addEventListener('abort', () => resolve(), { once: true })
-      })
+            // 保持 pending 状态直到 abortSignal 触发（防止 OpenClaw 3.8 认为启动立即退出）
+            await new Promise<void>((resolve) => {
+                if (ctx.abortSignal.aborted) {
+                    resolve();
+                    return;
+                }
+                ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
+            });
 
-      // abort 触发后，清理资源
-      log?.info?.(`startAccount abort signal received for ${accountId}`)
-      const wsStrategy = (account.config as any)?.wsConnectionStrategy || 'per-account'
-      stopOpenclawWorkclawGateway(accountId, wsStrategy)
-      setStatus({
-        ...getStatus(),
-        running: false,
-        lastStopAt: Date.now(),
-      })
-    },
-    stopAccount: async (ctx: ChannelGatewayContext<ResolvedOpenclawWorkclawAccount>) => {
-      const { setStatus, getStatus, accountId, account } = ctx
+            // abort 触发后，清理资源
+            log?.info?.(`startAccount abort signal received for ${accountId}`);
+            const wsStrategy = (account.config as any)?.wsConnectionStrategy || "per-account";
+            stopWorkclawGateway(accountId, wsStrategy);
+            setStatus({
+                ...getStatus(),
+                running: false,
+                lastStopAt: Date.now(),
+            });
+        },
+        stopAccount: async (ctx: ChannelGatewayContext<ResolvedWorkclawAccount>) => {
+            const { setStatus, getStatus, accountId, account } = ctx;
 
-      // Stop WorkClaw gateway
-      const wsStrategy = (account.config as any)?.wsConnectionStrategy || 'per-account'
-      stopOpenclawWorkclawGateway(accountId, wsStrategy)
+            // Stop WorkClaw gateway
+            const wsStrategy = (account.config as any)?.wsConnectionStrategy || "per-account";
+            stopWorkclawGateway(accountId, wsStrategy);
 
-      setStatus({
-        ...getStatus(),
-        running: false,
-        lastStopAt: Date.now(),
-      })
+            setStatus({
+                ...getStatus(),
+                running: false,
+                lastStopAt: Date.now(),
+            });
+        },
     },
-  },
-}
+};

package/src/config-schema.ts

@@ -2,9 +2,9 @@ import { z } from 'zod'
 
 export { z }
 
-const DmPolicySchema = z.enum(['open', 'pairing', 'allowlist'])
-const OpenclawWorkclawConnectionModeSchema = z.enum(['websocket'])
-const WsConnectionStrategySchema = z.enum(['per-account', 'per-appKey'])
+const DmPolicySchema = z.enum(["open", "pairing", "allowlist"]);
+const WorkclawConnectionModeSchema = z.enum(["websocket"]);
+const WsConnectionStrategySchema = z.enum(["per-account", "per-appKey"]);
 
 const DmConfigSchema = z
   .object({
@@ -28,7 +28,7 @@ const ChannelHeartbeatVisibilitySchema = z
  * Per-account config schema
  * Only fields that make sense to configure per-account.
  */
-export const openclawWorkclawAccountConfigSchema = z
+export const workclawAccountConfigSchema = z
   .object({
     enabled: z.boolean().optional(),
     name: z.string().optional(),
@@ -54,11 +54,11 @@ export const openclawWorkclawAccountConfigSchema = z
 /**
  * Top-level plugin config schema
  */
-export const OpenclawWorkclawConfigSchema = z
+export const WorkclawConfigSchema = z
   .object({
     enabled: z.boolean().optional(),
-    connectionMode: OpenclawWorkclawConnectionModeSchema.optional().default('websocket'),
-    wsConnectionStrategy: WsConnectionStrategySchema.optional().default('per-account'),
+    connectionMode: WorkclawConnectionModeSchema.optional().default("websocket"),
+    wsConnectionStrategy: WsConnectionStrategySchema.optional().default("per-account"),
     baseUrl: z.string().url().optional(),
     websocketUrl: z.string().url().optional(),
     appKey: z.string().optional(),
@@ -89,7 +89,7 @@ export const OpenclawWorkclawConfigSchema = z
     mediaMaxMb: z.number().positive().optional(),
     heartbeat: ChannelHeartbeatVisibilitySchema,
     renderMode: RenderModeSchema,
-    accounts: z.record(z.string(), openclawWorkclawAccountConfigSchema.optional()).optional(),
+    accounts: z.record(z.string(), workclawAccountConfigSchema.optional()).optional(),
   })
   .strict()
   .superRefine((value, ctx) => {
@@ -107,4 +107,4 @@ export const OpenclawWorkclawConfigSchema = z
     }
   })
 
-export const openclawWorkclawConfigSchema = OpenclawWorkclawConfigSchema
+export const workclawConfigSchema = WorkclawConfigSchema;