@workclaw/openclaw-workclaw 1.0.17 → 1.0.19

package/src/channel.ts

@@ -1,227 +0,0 @@
-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'
-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 '请回复验证码完成配对'
-}
-
-const meta = {
-  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')
-
-  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, ''),
-      }
-    },
-  },
-  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',
-      }
-    },
-  },
-  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,
-      }
-    },
-    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,
-      }
-    },
-  },
-  gateway: {
-    startAccount: async (ctx: ChannelGatewayContext<ResolvedOpenclawWorkclawAccount>) => {
-      const { setStatus, getStatus, account, accountId, cfg, log } = ctx
-      log?.info?.(`startAccount called for ${accountId}`)
-
-      await startOpenclawWorkclawGateway({
-        accountId,
-        account,
-        cfg,
-        log,
-      })
-
-      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 })
-      })
-
-      // 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
-
-      // Stop WorkClaw gateway
-      const wsStrategy = (account.config as any)?.wsConnectionStrategy || 'per-account'
-      stopOpenclawWorkclawGateway(accountId, wsStrategy)
-
-      setStatus({
-        ...getStatus(),
-        running: false,
-        lastStopAt: Date.now(),
-      })
-    },
-  },
-}

package/src/config-schema.ts

@@ -1,110 +0,0 @@
-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 DmConfigSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    systemPrompt: z.string().optional(),
-  })
-  .strict()
-  .optional()
-
-// Message render mode: auto (default) = detect markdown, raw = plain text, card = always card
-const RenderModeSchema = z.enum(['auto', 'raw', 'card']).optional()
-const ChannelHeartbeatVisibilitySchema = z
-  .object({
-    visibility: z.enum(['visible', 'hidden']).optional(),
-    intervalMs: z.number().int().positive().optional(),
-  })
-  .strict()
-  .optional()
-
-/**
- * Per-account config schema
- * Only fields that make sense to configure per-account.
- */
-export const openclawWorkclawAccountConfigSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    name: z.string().optional(),
-    agentId: z.union([z.string(), z.number()]).optional(),
-    userId: z.union([z.string(), z.number()]).optional(),
-    openConversationId: z.string().optional(),
-    replyEndpoint: z.string().optional(),
-    pushEndpoint: z.string().optional(),
-    dmPolicy: DmPolicySchema.optional(),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    requireMention: z.boolean().optional(),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema).optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(['length', 'newline']).optional(),
-    mediaMaxMb: z.number().positive().optional(),
-    heartbeat: ChannelHeartbeatVisibilitySchema,
-    renderMode: RenderModeSchema,
-  })
-  .strict()
-
-/**
- * Top-level plugin config schema
- */
-export const OpenclawWorkclawConfigSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    connectionMode: OpenclawWorkclawConnectionModeSchema.optional().default('websocket'),
-    wsConnectionStrategy: WsConnectionStrategySchema.optional().default('per-account'),
-    baseUrl: z.string().url().optional(),
-    websocketUrl: z.string().url().optional(),
-    appKey: z.string().optional(),
-    appSecret: z.string().optional(),
-    agentId: z.union([z.string(), z.number()]).optional(),
-    localIp: z.string().optional(),
-    userId: z.union([z.string(), z.number()]).optional(),
-    replyEndpoint: z.string().optional(),
-    pushEndpoint: z.string().optional(),
-    requestTimeout: z.number().int().positive().optional(),
-    allowInsecureTls: z.boolean().optional(),
-    allowRawJsonPayload: z.boolean().optional(),
-    capabilities: z.array(z.string()).optional(),
-    uploadUrl: z.string().url().optional(),
-    uploadFieldName: z.string().optional(),
-    uploadHeaders: z.record(z.string(), z.string()).optional(),
-    uploadFormFields: z
-      .record(z.string(), z.union([z.string(), z.number(), z.boolean()]))
-      .optional(),
-    uploadResponseUrlPath: z.string().optional(),
-    dmPolicy: DmPolicySchema.optional().default('pairing'),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-    historyLimit: z.number().int().min(0).optional(),
-    dmHistoryLimit: z.number().int().min(0).optional(),
-    dms: z.record(z.string(), DmConfigSchema).optional(),
-    textChunkLimit: z.number().int().positive().optional(),
-    chunkMode: z.enum(['length', 'newline']).optional(),
-    mediaMaxMb: z.number().positive().optional(),
-    heartbeat: ChannelHeartbeatVisibilitySchema,
-    renderMode: RenderModeSchema,
-    accounts: z.record(z.string(), openclawWorkclawAccountConfigSchema.optional()).optional(),
-  })
-  .strict()
-  .superRefine((value, ctx) => {
-    if (value.dmPolicy === 'open') {
-      const allowFrom = value.allowFrom ?? []
-      const hasWildcard = allowFrom.some(entry => String(entry).trim() === '*')
-      if (!hasWildcard) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ['allowFrom'],
-          message:
-            'channels.openclaw-workclaw.dmPolicy="open" requires channels.openclaw-workclaw.allowFrom to include "*"',
-        })
-      }
-    }
-  })
-
-export const openclawWorkclawConfigSchema = OpenclawWorkclawConfigSchema