@workclaw/openclaw-workclaw 1.0.20 → 1.0.202

package/src/gateway/workclaw-gateway.ts

@@ -0,0 +1,305 @@
+import type { ResolvedWorkclawAccount, WorkclawAccountConfig, WorkClawBaseConfig, WorkclawConfig } from '../types.js'
+import type { MessageDispatcherContext } from './message-dispatcher.js'
+import { buildAccountMap, resolveAccountByUserIdAndAgentId } from '../accounts.js'
+import {
+  clearReconnectScheduler,
+  clearWorkclawConnectionConfig,
+  clearWorkclawWsConnection,
+  createLogger,
+  finishConnecting,
+  getAllDispatchersByAppKey,
+  getAppKeyByAccountId,
+  getDispatcherByAppKeyAndAccountId,
+  getReconnectScheduler,
+  getWorkclawWsConnection,
+  registerAccountContext,
+  setReconnectScheduler,
+  setWorkclawConnectionConfig,
+  setWorkclawLoggerFromContext,
+  tryStartConnecting,
+  unregisterAccountContext,
+
+} from '../runtime.js'
+import { parseWorkClawMessage } from './message-context.js'
+import { dispatchWorkclawMessage } from './message-dispatcher.js'
+import { createReconnectScheduler } from './reconnect.js'
+
+export interface WorkclawGatewayOptions {
+  accountId: string
+  account: ResolvedWorkclawAccount
+  cfg: any
+  log?: {
+    info?: (msg: string) => void
+    warn?: (msg: string) => void
+    error?: (msg: string) => void
+    debug?: (msg: string) => void
+  }
+}
+
+export async function startWorkclawGateway(options: WorkclawGatewayOptions): Promise<void> {
+  const { accountId, account, cfg, log } = options
+
+  const logger = createLogger('', log)
+  setWorkclawLoggerFromContext(logger)
+
+  const rawConfig = account.config as unknown as WorkclawConfig & WorkclawAccountConfig
+  const connectionMode = rawConfig.connectionMode || 'websocket'
+
+  if (connectionMode !== 'websocket') {
+    throw new Error(`Unsupported connectionMode: ${connectionMode}`)
+  }
+
+  await startSharedWebSocket(options)
+}
+
+/**
+ * 多个账号共享一个 WebSocket 连接
+ */
+async function startSharedWebSocket(options: WorkclawGatewayOptions): Promise<void> {
+  const { accountId, account, cfg, log } = options
+
+  const logger = createLogger('', log)
+  const rawConfig = account.config as unknown as WorkclawConfig & WorkclawAccountConfig
+
+  const baseConfig: WorkClawBaseConfig = {
+    baseUrl: rawConfig.baseUrl,
+    websocketUrl: rawConfig.websocketUrl,
+    appKey: rawConfig.appKey,
+    appSecret: rawConfig.appSecret,
+    localIp: rawConfig.localIp,
+    allowInsecureTls: rawConfig.allowInsecureTls,
+    requestTimeout: rawConfig.requestTimeout,
+  }
+
+  const accountConfig: WorkclawAccountConfig = {
+    agentId: rawConfig.agentId,
+    userId: rawConfig.userId,
+    openConversationId: rawConfig.openConversationId,
+  }
+
+  const appKey = baseConfig.appKey || accountId
+  const appKeyRaw = baseConfig.appKey ?? ''
+
+  buildAccountMap(cfg)
+
+  logger.info(
+    `Gateway start accountId=${accountId} appKey=${appKeyRaw ? `${appKeyRaw.slice(0, 8)}...` : 'missing'} baseUrl=${baseConfig.baseUrl ?? ''} websocketUrl=${baseConfig.websocketUrl ?? ''}`,
+  )
+
+  // 注册账号上下文
+  const ctx: MessageDispatcherContext = {
+    accountId,
+    account,
+    cfg,
+    baseConfig,
+    accountConfig,
+    log: logger,
+    scheduleReconnect: () => {
+      const scheduler = getReconnectScheduler(appKey)
+      scheduler?.scheduleReconnect()
+    },
+  }
+
+  registerAccountContext(appKey, accountId, ctx)
+
+  // 检查是否已存在该 appKey 的 WebSocket
+  const existingWs = getWorkclawWsConnection(appKey)
+  if (existingWs) {
+    logger.info(`Gateway using existing WebSocket for appKey=${appKey}`)
+    return
+  }
+
+  // 尝试获取连接锁，防止竞态条件
+  const startResult = tryStartConnecting(appKey)
+
+  if (!startResult.isConnector) {
+    // 另一个账号正在连接（成功或失败中），等待共享的 connectingPromise
+    logger.info(`Gateway another account is connecting, waiting... appKey=${appKey}`)
+    const resultWs = await startResult.connectingPromise
+    if (resultWs) {
+      logger.info(`Gateway connection established by another account, using it appKey=${appKey}`)
+      return
+    }
+    // 连接失败（resultWs === null），当前账号作为新 connector 重试
+    logger.warn(`Gateway connection attempt failed, will create own connection appKey=${appKey}`)
+  }
+  else {
+    // 是 connector，创建连接
+    logger.info(`Gateway acquired connector lock, creating connection appKey=${appKey}`)
+  }
+
+  // 需要创建新的 WebSocket（只有获取到锁的账号才执行到这里）
+  const scheduler = createReconnectScheduler({
+    key: appKey,
+    config: baseConfig,
+    log: logger,
+    onMessage: (data: string) => {
+      handleSharedMessage(appKey, data, cfg, logger)
+    },
+    onClose: () => {
+      scheduler.scheduleReconnect()
+    },
+    // 旧代码在 setWorkclawWsConnection 后、ws.onopen 前就调用 finishConnecting，
+    // 这个回调模拟同样的时机：ws 已存入 runtime，通知所有等待者
+    onConnectingStarted: (ws: any) => {
+      finishConnecting(appKey, ws)
+    },
+  })
+  setReconnectScheduler(appKey, scheduler)
+
+  try {
+    await scheduler.connect()
+  }
+  catch (err) {
+    // 连接失败，通知所有等待者重试（不传 ws 表示失败）
+    finishConnecting(appKey)
+    throw err
+  }
+
+  // Cache the connection config to prevent cfg mutation issues during message sends
+  // 每个账户都有自己的配置缓存
+  setWorkclawConnectionConfig(accountId, {
+    appKey: baseConfig.appKey ?? '',
+    appSecret: baseConfig.appSecret ?? '',
+    baseUrl: baseConfig.baseUrl,
+    websocketUrl: baseConfig.websocketUrl,
+    localIp: baseConfig.localIp,
+    allowInsecureTls: baseConfig.allowInsecureTls,
+    requestTimeout: baseConfig.requestTimeout,
+  })
+}
+
+/**
+ * 处理共享 WebSocket 消息
+ */
+function handleSharedMessage(appKey: string, data: string, cfg: any, logger: any): void {
+  const parsed = parseWorkClawMessage(data, logger)
+
+  if (!parsed) {
+    logger.warn?.(`Gateway failed to parse message`)
+    return
+  }
+
+  // ping/pong/disconnect 无需路由
+  if (parsed.type === 'ping') {
+    const ws = getWorkclawWsConnection(appKey)
+    if (ws && ws.readyState === 1) { // OPEN
+      const pongResponse = {
+        code: 200,
+        message: 'pong',
+        metadata: { contentType: 'application/json' },
+        data: JSON.stringify(parsed.pongData),
+      }
+      ws.send(JSON.stringify(pongResponse))
+    }
+    return
+  }
+
+  if (parsed.type === 'disconnect') {
+    const ws = getWorkclawWsConnection(appKey)
+    ws?.close()
+    return
+  }
+
+  // logger.info?.(`Gateway received message: ${data}`);
+
+  // 根据消息类型确定 userId 和 agentId
+  let userId: string = ''
+  let agentId: string = ''
+
+  if (parsed.type === 'agent_message' && parsed.message) {
+    userId = String(parsed.message.userId || '')
+    agentId = String(parsed.message.agentId || '')
+  }
+  else if (parsed.type === 'agent_created') {
+    // agent_created 触发新账号创建
+    const allDispatchers = getAllDispatchersByAppKey(appKey)
+    if (allDispatchers && allDispatchers.size > 0) {
+      const firstDispatcher = allDispatchers.values().next().value
+      dispatchWorkclawMessage(data, firstDispatcher.ctx).catch((err) => {
+        logger.error?.(`Dispatch error: ${String(err)}`)
+      })
+    }
+    return
+  }
+  else if (parsed.type === 'agent_updated' || parsed.type === 'agent_deleted') {
+    userId = String(parsed.eventData?.futureId || parsed.eventData?.userId || '')
+    agentId = String(parsed.eventData?.id || parsed.eventData?.agentId || '')
+  }
+  else if (parsed.type === 'tools_list' || parsed.type === 'skills_list' || parsed.type === 'skills_event') {
+    userId = String(parsed.eventData?.userId || '')
+    agentId = String(parsed.eventData?.agentId || '')
+  }
+  else if (parsed.type === 'init_agent') {
+    userId = String(parsed.eventData?.futureId || parsed.eventData?.userId || '')
+    agentId = String(parsed.eventData?.id || parsed.eventData?.agentId || '')
+    /**
+     * 在 init_agent 中，配置文件的agentId 为空,所有无法通过 resolveAccountByUserIdAndAgentId 查找账户
+     */
+
+    const accountId = 'default'
+    const dispatcher = getDispatcherByAppKeyAndAccountId(appKey, accountId)
+    if (dispatcher) {
+      dispatchWorkclawMessage(data, dispatcher.ctx).catch((err) => {
+        logger.error?.(`Dispatch error: ${String(err)}`)
+      })
+    }
+    else {
+      logger.warn?.(`Gateway no dispatcher for accountId=${accountId}`)
+    }
+    return
+  }
+  else if (parsed.type === 'cron_task_event') {
+    // 任务事件处理，使用默认账户
+    const accountId = 'default'
+    const dispatcher = getDispatcherByAppKeyAndAccountId(appKey, accountId)
+    if (dispatcher) {
+      dispatchWorkclawMessage(data, dispatcher.ctx).catch((err) => {
+        logger.error?.(`Dispatch error: ${String(err)}`)
+      })
+    }
+    else {
+      logger.warn?.(`Gateway (per-appKey) no dispatcher for accountId=${accountId}`)
+    }
+    return
+  }
+  else {
+    // 未知消息类型，忽略
+    return
+  }
+
+  const accountId = resolveAccountByUserIdAndAgentId(cfg, userId, agentId)
+  if (!accountId) {
+    logger.warn?.(`Gateway no account found for userId=${userId} agentId=${agentId}`)
+    return
+  }
+
+  const dispatcher = getDispatcherByAppKeyAndAccountId(appKey, accountId)
+  if (dispatcher) {
+    dispatchWorkclawMessage(data, dispatcher.ctx).catch((err) => {
+      logger.error?.(`Dispatch error: ${String(err)}`)
+    })
+  }
+  else {
+    logger.warn?.(`Gateway no dispatcher for accountId=${accountId}`)
+  }
+}
+
+export function stopWorkclawGateway(accountId: string): void {
+  const appKey = getAppKeyByAccountId(accountId)
+  if (!appKey)
+    return
+
+  unregisterAccountContext(appKey, accountId)
+
+  if (getAllDispatchersByAppKey(appKey)?.size === 0) {
+    const ws = getWorkclawWsConnection(appKey)
+    ws?.close()
+    clearWorkclawWsConnection(appKey)
+
+    const scheduler = getReconnectScheduler(appKey)
+    scheduler?.stopReconnect()
+    clearReconnectScheduler(appKey)
+  }
+  clearWorkclawConnectionConfig(accountId)
+}

package/src/media/upload.ts

@@ -0,0 +1,168 @@
+import { readFile, stat } from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Agent, fetch as undiciFetch } from 'undici'
+
+export function isLocalMediaSource(value: string): boolean {
+  const trimmed = value.trim()
+  return (
+    trimmed.startsWith('/')
+    || trimmed.startsWith('./')
+    || trimmed.startsWith('../')
+    || trimmed.startsWith('~')
+    || trimmed.startsWith('file://')
+  )
+}
+
+export function resolveLocalPath(input: string): string {
+  if (input.startsWith('file://')) {
+    return fileURLToPath(input)
+  }
+  if (input.startsWith('~')) {
+    return path.join(os.homedir(), input.slice(1))
+  }
+  return path.resolve(input)
+}
+
+function readResponseUrlPath(
+  data: Record<string, unknown>,
+  pathValue?: string,
+): string | undefined {
+  if (!pathValue)
+    return undefined
+  const parts = pathValue.split('.').filter(Boolean)
+  let current: unknown = data
+  for (const part of parts) {
+    if (!current || typeof current !== 'object')
+      return undefined
+    current = (current as Record<string, unknown>)[part]
+  }
+  return typeof current === 'string' ? current : undefined
+}
+
+function extractUploadedUrl(
+  responseText: string,
+  responseData: Record<string, unknown>,
+  pathValue?: string,
+): string | undefined {
+  const fromPath = readResponseUrlPath(responseData, pathValue)
+  if (fromPath)
+    return fromPath
+
+  const direct
+    = (responseData.url as string | undefined)
+      ?? (responseData.mediaUrl as string | undefined)
+  if (typeof direct === 'string' && direct.trim())
+    return direct
+
+  const dataObj = responseData.data
+  if (dataObj && typeof dataObj === 'object') {
+    const dataUrl = (dataObj as Record<string, unknown>).url
+    const dataMedia = (dataObj as Record<string, unknown>).mediaUrl
+    if (typeof dataUrl === 'string' && dataUrl.trim())
+      return dataUrl
+    if (typeof dataMedia === 'string' && dataMedia.trim())
+      return dataMedia
+  }
+
+  const resultObj = responseData.result
+  if (resultObj && typeof resultObj === 'object') {
+    const resultUrl = (resultObj as Record<string, unknown>).url
+    const resultMedia = (resultObj as Record<string, unknown>).mediaUrl
+    if (typeof resultUrl === 'string' && resultUrl.trim())
+      return resultUrl
+    if (typeof resultMedia === 'string' && resultMedia.trim())
+      return resultMedia
+  }
+
+  if (responseText.trim() && /^https?:\/\//i.test(responseText.trim())) {
+    return responseText.trim()
+  }
+  return undefined
+}
+
+export interface UploadLocalMediaParams {
+  uploadUrl: string
+  filePath: string
+  uploadFieldName?: string
+  uploadHeaders?: Record<string, string>
+  uploadFormFields?: Record<string, string | number | boolean>
+  uploadResponseUrlPath?: string
+  requestTimeout: number
+  allowInsecureTls?: boolean
+}
+
+export async function uploadLocalMedia(params: UploadLocalMediaParams): Promise<string> {
+  const stats = await stat(params.filePath)
+  if (!stats.isFile()) {
+    throw new Error(`mediaUrl is not a file: ${params.filePath}`)
+  }
+
+  const content = await readFile(params.filePath)
+  const form = new FormData()
+  const fieldName = params.uploadFieldName?.trim() || 'file'
+  const fileName = path.basename(params.filePath)
+  form.set(fieldName, new Blob([content], { type: 'application/octet-stream' }), fileName)
+
+  if (params.uploadFormFields) {
+    for (const [key, value] of Object.entries(params.uploadFormFields)) {
+      form.set(key, String(value))
+    }
+  }
+
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), params.requestTimeout)
+
+  let dispatcher: unknown
+  let doFetch: any = globalThis.fetch.bind(globalThis)
+
+  if (params.allowInsecureTls) {
+    try {
+      dispatcher = new Agent({ connect: { rejectUnauthorized: false } })
+      doFetch = undiciFetch as any
+    }
+    catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      throw new Error(`allowInsecureTls requires undici. ${message}`)
+    }
+  }
+
+  try {
+    const response = await doFetch(params.uploadUrl, {
+      method: 'POST',
+      headers: params.uploadHeaders ?? {},
+      body: form,
+      signal: controller.signal,
+      ...(dispatcher ? { dispatcher } : {}),
+    })
+
+    const responseText = await response.text().catch(() => '')
+    if (!response.ok) {
+      throw new Error(`Upload failed: ${response.status} ${responseText}`)
+    }
+
+    let data: Record<string, unknown> = {}
+    if (responseText) {
+      try {
+        data = JSON.parse(responseText) as Record<string, unknown>
+      }
+      catch {
+        data = {}
+      }
+    }
+
+    const uploadedUrl = extractUploadedUrl(
+      responseText,
+      data,
+      params.uploadResponseUrlPath,
+    )
+    if (!uploadedUrl) {
+      throw new Error('Upload response missing file URL')
+    }
+    return uploadedUrl
+  }
+  finally {
+    clearTimeout(timeoutId)
+  }
+}

package/src/outbound/index.ts

@@ -0,0 +1,191 @@
+import type { OpenClawConfig } from 'openclaw/plugin-sdk'
+import type { WorkclawConfig, WorkclawSendResult } from '../types.js'
+import { stat } from 'node:fs/promises'
+import { resolveAccountByUserIdAndAgentId, resolveWorkclawAccountWithCache } from '../accounts.js'
+
+import { loadOpenConversationId } from '../gateway/config-writer.js'
+import { isLocalMediaSource, resolveLocalPath, uploadLocalMedia } from '../media/upload.js'
+import { getWorkclawLogger, setLastOutboundAt } from '../runtime.js'
+import {
+  sendWorkclawOutboundMessage,
+} from './workclaw-sender.js'
+
+/**
+ * 根据 target (userId) 和可选的 agentId 查找匹配的账户
+ * 如果同时提供 userId 和 agentId，走 O(1) 查找
+ * 否则遍历所有账户，查找 userId 等于 target 的账户
+ */
+function findAccountIdByTarget(
+  cfg: OpenClawConfig,
+  target: string,
+  agentId?: string | number,
+): string | undefined {
+  // O(1) 查找：userId + agentId 唯一确定一个账户
+  if (agentId !== undefined && agentId !== null) {
+    return resolveAccountByUserIdAndAgentId(cfg, target, String(agentId)) ?? undefined
+  }
+
+  // 遍历：只有 userId 时，无法唯一确定账户（一个 userId 对应多个 agentId）
+  // 需要通过 bindings 或其他方式 resolve，这里暂不支持
+  return undefined
+}
+
+export interface SendWorkclawMessageParams {
+  cfg: OpenClawConfig
+  to: string
+  text: string
+  mediaUrl?: string
+  replyToMessageId?: string
+  accountId?: string
+  openConversationId?: string
+  agentId?: string | number
+  /**
+   * 消息类型：
+   * - "reply": 回复消息（用户触发）
+   * - "push": 主动推送（定时任务触发）
+   */
+  messageType?: 'reply' | 'push'
+  msgType?: string
+  last?: boolean
+  /** 来源：deliver=流式响应回调，sendText=框架直接发送，after_tool_call=工具执行结果推送 */
+  source?: 'deliver' | 'sendText' | 'after_tool_call'
+}
+
+async function resolveMediaUrl(
+  mediaUrl: string | undefined,
+  config: WorkclawConfig,
+): Promise<string | undefined> {
+  if (!mediaUrl)
+    return undefined
+  if (!isLocalMediaSource(mediaUrl))
+    return mediaUrl
+
+  const uploadUrl = config.uploadUrl
+  if (!uploadUrl) {
+    throw new Error('uploadUrl not configured for local mediaUrl')
+  }
+
+  const filePath = resolveLocalPath(mediaUrl)
+
+  if (typeof config.mediaMaxMb === 'number' && config.mediaMaxMb > 0) {
+    const stats = await stat(filePath)
+    const maxBytes = config.mediaMaxMb * 1024 * 1024
+    if (stats.size > maxBytes) {
+      throw new Error(`mediaUrl exceeds limit (${config.mediaMaxMb} MB)`)
+    }
+  }
+
+  return uploadLocalMedia({
+    uploadUrl,
+    filePath,
+    uploadFieldName: config.uploadFieldName,
+    uploadHeaders: config.uploadHeaders as Record<string, string> | undefined,
+    uploadFormFields: config.uploadFormFields as
+    | Record<string, string | number | boolean>
+    | undefined,
+    uploadResponseUrlPath: config.uploadResponseUrlPath,
+    requestTimeout: config.requestTimeout ?? 30000,
+    allowInsecureTls: config.allowInsecureTls,
+  })
+}
+
+export async function sendMessageWorkclaw(
+  params: SendWorkclawMessageParams,
+): Promise<WorkclawSendResult> {
+  const { cfg, to, text, mediaUrl, replyToMessageId, accountId, openConversationId, agentId, messageType, msgType, last }
+    = params
+
+  // 如果没有指定 messageType，根据是否有 replyToMessageId 来判断
+  // - 有 replyToMessageId: 回复消息
+  // - 没有 replyToMessageId: 主动推送
+  const resolvedMessageType = messageType ?? (replyToMessageId ? 'reply' : 'push')
+
+  // 如果没有指定 accountId，尝试根据 target (to) 和 agentId 查找匹配的账户
+  let resolvedAccountId = accountId
+  if (!resolvedAccountId) {
+    const foundAccountId = findAccountIdByTarget(cfg, to, agentId)
+    if (foundAccountId) {
+      resolvedAccountId = foundAccountId
+    }
+  }
+
+  const account = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId })
+  if (!account.configured) {
+    throw new Error(`Workclaw account "${account.accountId}" not configured`)
+  }
+
+  const resolvedMediaUrl = await resolveMediaUrl(mediaUrl, account.config)
+
+  // 优先使用传入的 openConversationId，其次从 cfg 中直接读取（绕过 account.config 快照问题）
+  // 这样可以获取到运行时动态保存的 openConversationId
+  interface ChannelWithAccounts { accounts?: Record<string, any>, openConversationId?: string }
+  const cfgChannel = (cfg.channels?.['openclaw-workclaw'] as unknown as ChannelWithAccounts) ?? {}
+  const cfgAccounts = cfgChannel.accounts ?? {}
+  const cfgAccount = cfgAccounts[resolvedAccountId] ?? {}
+  const cfgOpenConversationId = cfgAccount?.openConversationId ?? cfgChannel?.openConversationId
+  // 最后尝试从 state 文件恢复（进程重启后 cfg 没有持久化的 openConversationId）
+  const stateOpenConversationId = loadOpenConversationId(resolvedAccountId, to)
+  const effectiveOpenConversationId = openConversationId ?? cfgOpenConversationId ?? stateOpenConversationId
+  getWorkclawLogger().info(`[SEND] source=${params.source || '?'} type=${resolvedMessageType} conv=${effectiveOpenConversationId || '(none)'} replyTo=${replyToMessageId}`)
+
+  // 使用 appKey 作为缓存键，让所有账户共享同一个 token
+  const tokenCacheKey = account.config.appKey || account.accountId
+  const result = await sendWorkclawOutboundMessage({
+    cacheKey: tokenCacheKey,
+    to,
+    text,
+    msgType,
+    mediaUrl: resolvedMediaUrl,
+    replyToMessageId,
+    openConversationId: effectiveOpenConversationId,
+    agentId,
+    config: account.config,
+    messageType: resolvedMessageType,
+    last,
+    source: params.source,
+  })
+
+  // 更新上次出站时间
+  if (resolvedAccountId) {
+    setLastOutboundAt(resolvedAccountId, Date.now())
+  }
+
+  return {
+    messageId: result.messageId,
+    chatId: to,
+  }
+}
+
+export async function getMessageWorkclaw(_params: {
+  cfg: OpenClawConfig
+  messageId: string
+  accountId?: string
+}): Promise<null> {
+  return null
+}
+
+/**
+ * 发送主动推送消息（定时任务使用）
+ * 使用 pushEndpoint 配置的端口
+ */
+export async function sendPushMessageWorkclaw(
+  params: Omit<SendWorkclawMessageParams, 'messageType'>,
+): Promise<WorkclawSendResult> {
+  return sendMessageWorkclaw({
+    ...params,
+    messageType: 'push',
+  })
+}
+
+/**
+ * 发送回复消息（用户触发）
+ * 使用 replyEndpoint 配置的端口
+ */
+export async function sendReplyMessageWorkclaw(
+  params: Omit<SendWorkclawMessageParams, 'messageType'>,
+): Promise<WorkclawSendResult> {
+  return sendMessageWorkclaw({
+    ...params,
+    messageType: 'reply',
+  })
+}