@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

package/src/gateway/workclaw-gateway.ts

@@ -1,305 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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

@@ -1,191 +0,0 @@
-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',
-  })
-}