@workclaw/openclaw-workclaw 1.0.17 → 1.0.19

package/index.ts

@@ -1,302 +0,0 @@
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { emptyPluginConfigSchema } from 'openclaw/plugin-sdk'
-import { createAccountsApiHandler } from './src/api/accounts-api.js'
-import { createPromptsApiHandler } from './src/api/prompts-api.js'
-import { createSessionApiHandler } from './src/api/session-api.js'
-import { createSkillsApiHandler } from './src/api/skills-api.js'
-import { isDefaultWorkspace, resolveWorkspaceDir } from './src/api/workspace.js'
-import { openclawWorkclawPlugin } from './src/channel.js'
-import { sendMessageOpenclawWorkclaw } from './src/outbound/index.js'
-import { deleteToolContext, getOpenclawWorkclawRuntime, getToolContext, getToolResultHint, setOpenclawWorkclawRuntime, setToolCallIdToRunIdMapping } from './src/runtime.js'
-
-import { registerAllOpenclawWorkclawCronTools } from './src/tools/openclaw-workclaw-cron/index.js'
-import { registerAllOpenclawWorkclawSystemTools } from './src/tools/openclaw-workclaw-system/index.js'
-
-/**
- * 根据工具名称格式化参数字符串
- */
-function formatToolParams(toolName: string | undefined, params: unknown): string {
-  if (!params || typeof params !== 'object') {
-    return ''
-  }
-
-  const normalizedToolName = (toolName || '').toLowerCase().trim()
-  const p = params as Record<string, unknown>
-
-  try {
-    // exec/bash/shell: 显示 command
-    if (normalizedToolName === 'exec' || normalizedToolName === 'bash' || normalizedToolName === 'shell') {
-      const cmd = p.command || p.cmd
-      if (cmd)
-        return `command: ${String(cmd).slice(0, 200)}`
-    }
-    // read/file_read/read: 显示 path
-    else if (normalizedToolName === 'read' || normalizedToolName === 'file_read' || normalizedToolName === 'view') {
-      const path = p.path
-      if (path)
-        return `path: ${path}`
-    }
-    // write/file_write/write/edit/patch: 显示 path
-    else if (normalizedToolName === 'write' || normalizedToolName === 'file_write' || normalizedToolName === 'edit' || normalizedToolName === 'patch') {
-      const path = p.path
-      if (path)
-        return `path: ${path}`
-    }
-    // web_fetch/fetch/http_get/http_request/open_url/browser_open: 显示 url
-    else if (
-      normalizedToolName === 'web_fetch' || normalizedToolName === 'fetch'
-      || normalizedToolName === 'http_get' || normalizedToolName === 'http_request'
-      || normalizedToolName === 'open_url' || normalizedToolName === 'browser_open'
-      || normalizedToolName === 'open'
-    ) {
-      const url = p.url
-      if (url)
-        return `url: ${url}`
-    }
-    // search/web_search/google_search/browser_search: 显示 query
-    else if (
-      normalizedToolName === 'search' || normalizedToolName === 'web_search'
-      || normalizedToolName === 'google_search' || normalizedToolName === 'browser_search'
-      || normalizedToolName === 'browser.search'
-    ) {
-      const query = p.query || p.q || p.search
-      if (query)
-        return `query: ${query}`
-    }
-    // image_generate/generate_image/dalle/text_to_image: 显示 prompt
-    else if (
-      normalizedToolName === 'image_generate' || normalizedToolName === 'generate_image'
-      || normalizedToolName === 'dalle' || normalizedToolName === 'text_to_image'
-    ) {
-      const prompt = p.prompt
-      if (prompt)
-        return `prompt: ${String(prompt).slice(0, 200)}`
-    }
-    // code_interpreter/python/jupyter: 显示 code
-    else if (
-      normalizedToolName === 'code_interpreter' || normalizedToolName === 'python'
-      || normalizedToolName === 'jupyter'
-    ) {
-      const code = p.code
-      if (code)
-        return `code: ${String(code).slice(0, 200)}`
-    }
-    // mcp_deliver/deliver: 显示 target
-    else if (normalizedToolName === 'mcp_deliver' || normalizedToolName === 'deliver') {
-      const target = p.target || p.to
-      if (target)
-        return `target: ${target}`
-    }
-    // 其他工具：显示所有 key=value
-    else {
-      const entries = Object.entries(p)
-      if (entries.length > 0) {
-        return entries
-          .map(([k, v]) => {
-            const vStr = typeof v === 'string' ? v : JSON.stringify(v)
-            return vStr.length > 100 ? `${k}: ${vStr.slice(0, 100)}...` : `${k}: ${vStr}`
-          })
-          .join('\n')
-      }
-    }
-  }
-  catch {
-    return String(params)
-  }
-
-  return ''
-}
-
-/**
- * 组合工具输出内容（只显示参数）
- */
-function formatToolOutput(toolName: string | undefined, params: unknown, _result: unknown): string {
-  return formatToolParams(toolName, params)
-}
-
-// 注册工具执行相关的 hook
-function registerToolHooks(api: OpenClawPluginApi): void {
-  // agent_end: 对话结束时清理 runId 映射
-  api.on('agent_end', (event: any, ctx: any) => {
-    const { runId } = ctx || {}
-    if (runId) {
-      deleteToolContext(runId)
-      api.logger?.info?.(`[ToolHook] agent_end runId=${runId} cleaned up`)
-    }
-    return event
-  })
-
-  api.on('before_tool_call', (event: any) => {
-    api.logger?.info?.(`[ToolHook] before_tool_call event=${JSON.stringify(event)}`)
-  })
-
-  // after_tool_call: 获取工具执行结果并推送
-  api.on('after_tool_call', (event: any) => {
-    api.logger?.info?.(`[ToolHook] after_tool_call event=${JSON.stringify(event)}`)
-    const { runId, toolCallId, toolName, params, result } = event || {}
-    const toolCtx = runId ? getToolContext(runId) : undefined
-
-    if (toolCtx && result) {
-      const content = formatToolOutput(toolName, params, result)
-      if (content) {
-        try {
-          const cfg = getOpenclawWorkclawRuntime().config.loadConfig()
-          const formattedToolOutput = {
-            name: getToolResultHint(toolName),
-            toolName,
-            content,
-            state: 'result',
-          }
-          sendMessageOpenclawWorkclaw({
-            cfg,
-            to: toolCtx.target,
-            text: JSON.stringify(formattedToolOutput),
-            msgType: '26',
-            accountId: toolCtx.accountId,
-            openConversationId: toolCtx.openConversationId,
-            agentId: toolCtx.agentId,
-            replyToMessageId: toolCtx.replyToMessageId,
-          }).catch((err) => {
-            api.logger?.error?.(`[ToolHook] after_tool_call push failed: ${err}`)
-          })
-          api.logger?.info?.(`[ToolHook] after_tool_call pushed for toolName=${toolName}`)
-        }
-        catch (err) {
-          api.logger?.error?.(`[ToolHook] after_tool_call push failed: ${err}`)
-        }
-      }
-    }
-
-    // 建立 toolCallId -> runId 映射（备用，用于 tool_result_persist）
-    if (runId && toolCallId) {
-      setToolCallIdToRunIdMapping(toolCallId, runId)
-    }
-
-    return event
-  })
-
-  // tool_result_persist: 仅返回消息，不推送
-  api.on('tool_result_persist', (event: any) => {
-    return { message: event.message }
-  })
-
-  api.logger?.info?.(`[ToolHook] Tool execution hooks registered`)
-}
-
-export { openclawWorkclawPlugin } from './src/channel.js'
-export {
-  getMessageOpenclawWorkclaw,
-  sendMessageOpenclawWorkclaw,
-} from './src/outbound/index.js'
-
-const templateNames = ['SOUL.md', 'IDENTITY.md'] as const
-
-async function writeFileIfMissing(filePath: string, content: string): Promise<void> {
-  try {
-    await writeFile(filePath, content, { encoding: 'utf-8', flag: 'wx' })
-  }
-  catch (error) {
-    if (
-      error
-      && typeof error === 'object'
-      && 'code' in error
-      && (error as NodeJS.ErrnoException).code === 'EEXIST'
-    ) {
-      return
-    }
-    throw error
-  }
-}
-
-async function releaseTemplates(api: OpenClawPluginApi): Promise<void> {
-  const workspaceDir = resolveWorkspaceDir(api)
-  // 模板文件在根目录的 templates/ 中，而不是 dist/templates/
-  const currentDir = path.dirname(fileURLToPath(import.meta.url))
-  const templatesDir = path.join(currentDir.endsWith('dist') ? path.dirname(currentDir) : currentDir, 'templates')
-  const shouldOverwrite = isDefaultWorkspace(api)
-
-  await mkdir(workspaceDir, { recursive: true })
-
-  await Promise.all(
-    templateNames.map(async (name) => {
-      const sourcePath = path.join(templatesDir, name)
-      const targetPath = path.join(workspaceDir, name)
-      const content = await readFile(sourcePath, 'utf-8')
-      if (shouldOverwrite) {
-        await writeFile(targetPath, content, { encoding: 'utf-8' })
-      }
-      else {
-        await writeFileIfMissing(targetPath, content)
-      }
-    }),
-  )
-
-  api.logger.info(`openclaw-workclaw templates ready: ${workspaceDir}`)
-}
-
-const plugin = {
-  id: 'openclaw-workclaw',
-  name: 'openclaw-workclaw',
-  description: '智小途 channel plugin',
-  configSchema: emptyPluginConfigSchema(),
-  register(api: OpenClawPluginApi) {
-    setOpenclawWorkclawRuntime(api.runtime)
-    api.registerChannel({ plugin: openclawWorkclawPlugin })
-
-    // 注册定时任务工具
-    registerAllOpenclawWorkclawCronTools(api)
-
-    // 注册系统工具
-    registerAllOpenclawWorkclawSystemTools(api)
-
-    // 注册工具执行相关的 hook - 不再需要留在这里当注释
-    registerToolHooks(api)
-
-    api.registerService({
-      id: 'openclaw-workclaw-templates',
-      start: async () => {
-        await releaseTemplates(api)
-      },
-    })
-
-    api.registerHttpRoute({
-      path: '/openclaw-workclaw/workspace/prompts',
-      handler: createPromptsApiHandler(api),
-      auth: 'plugin',
-    })
-
-    api.registerHttpRoute({
-      path: '/openclaw-workclaw/accounts',
-      handler: createAccountsApiHandler(api),
-      auth: 'plugin',
-    })
-
-    api.registerHttpRoute({
-      path: '/openclaw-workclaw/skills',
-      handler: createSkillsApiHandler(api),
-      auth: 'plugin',
-    })
-
-    // 注册会话管理 API
-    api.registerHttpRoute({
-      path: '/openclaw-workclaw/sessions',
-      handler: createSessionApiHandler(api),
-      auth: 'plugin',
-      match: 'prefix',
-    })
-  },
-}
-
-export function register(api: OpenClawPluginApi): void {
-  plugin.register(api)
-}
-
-export function activate(api: OpenClawPluginApi): void {
-  register(api)
-}
-
-export default plugin

package/src/accounts.ts

@@ -1,287 +0,0 @@
-import type { OpenClawConfig } from 'openclaw/plugin-sdk'
-import type {
-  OpenclawWorkclawAccountConfig,
-  OpenclawWorkclawConfig,
-  ResolvedOpenclawWorkclawAccount,
-} from './types.js'
-import { getOpenclawWorkclawLogger } from './runtime.js'
-
-const DEFAULT_ACCOUNT_ID = 'default'
-
-// =============================================================================
-// In-memory lookup cache for (userId, agentId) → workspace-N accountId
-// Problem: OpenClaw doesn't support dashes in account IDs, agentId can be negative
-// Solution: workspace-N naming + in-memory Map for O(1) lookups
-// =============================================================================
-
-/**
- * Normalize account ID by trimming whitespace
- */
-export function normalizeAccountId(accountId: string | null | undefined): string {
-  return String(accountId ?? '').trim()
-}
-
-/**
- * Key format for the lookup map: "userId|agentId"
- */
-function makeLookupKey(userId: string, agentId: string): string {
-  return `${userId}|${agentId}`
-}
-
-/**
- * In-memory map: lookupKey -> accountId
- */
-const lookupCache = new Map<string, string>()
-
-/**
- * In-memory map: accountId -> { userId, agentId }
- */
-const accountIndex = new Map<string, { userId: string, agentId: string }>()
-
-/**
- * Next workspace number to allocate
- */
-let nextWorkspaceNum = 1
-
-/**
- * Build the lookup cache from existing accounts in cfg.
- * Called once at gateway startup.
- */
-export function buildAccountMap(cfg: OpenClawConfig): void {
-  lookupCache.clear()
-  accountIndex.clear()
-  nextWorkspaceNum = 1
-
-  const _OpenclawWorkclawConfig = (cfg.channels?.['openclaw-workclaw'] || {}) as OpenclawWorkclawConfig
-
-  const accounts = _OpenclawWorkclawConfig?.accounts
-  if (!accounts || typeof accounts !== 'object')
-    return
-
-  for (const [accountId, accountCfg] of Object.entries(accounts)) {
-    if (!accountCfg)
-      continue
-    const userId = accountCfg.userId || _OpenclawWorkclawConfig.userId
-    const agentId = accountCfg.agentId
-    if (!agentId)
-      continue
-
-    // userId may not be present for config-defined accounts; only build
-    // lookup if userId is available (dynamically created accounts have it)
-    if (userId) {
-      const key = makeLookupKey(String(userId), String(agentId))
-      lookupCache.set(key, accountId)
-    }
-    accountIndex.set(accountId, { userId: String(userId ?? ''), agentId: String(agentId) })
-
-    if (accountId.startsWith('workspace-')) {
-      const num = Number.parseInt(accountId.slice(accountId.lastIndexOf('-') + 1), 10)
-      if (!Number.isNaN(num) && num >= nextWorkspaceNum) {
-        nextWorkspaceNum = num + 1
-      }
-    }
-  }
-
-  getOpenclawWorkclawLogger().info(`[AccountManager] Built account map with ${lookupCache.size} entries, nextWorkspaceNum=${nextWorkspaceNum}`)
-}
-
-/**
- * Resolve accountId by userId + agentId.
- * First checks cache, then falls back to iteration.
- */
-export function resolveAccountByUserIdAndAgentId(
-  cfg: OpenClawConfig,
-  userId: string,
-  agentId: string,
-): string | null {
-  const key = makeLookupKey(userId, agentId)
-
-  if (lookupCache.has(key)) {
-    return lookupCache.get(key)!
-  }
-
-  const _OpenclawWorkclawConfig = (cfg.channels?.['openclaw-workclaw'] || {}) as OpenclawWorkclawConfig
-  const accounts = _OpenclawWorkclawConfig?.accounts
-  if (accounts && typeof accounts === 'object') {
-    for (const [accountId, accountCfg] of Object.entries(accounts)) {
-      if (!accountCfg)
-        continue
-      const accountUserId = accountCfg.userId || _OpenclawWorkclawConfig.userId
-      if (String(accountUserId) === userId && String(accountCfg.agentId) === agentId) {
-        lookupCache.set(key, accountId)
-        accountIndex.set(accountId, { userId, agentId })
-        return accountId
-      }
-    }
-  }
-
-  return null
-}
-
-/**
- * Allocate a new workspace-N accountId and register it in the map.
- */
-export function allocateWorkerAccountId(
-  _cfg: OpenClawConfig,
-  userId: string,
-  agentId: string,
-): string {
-  const accountId = `workspace-${nextWorkspaceNum}`
-  nextWorkspaceNum++
-
-  const key = makeLookupKey(userId, agentId)
-  lookupCache.set(key, accountId)
-  accountIndex.set(accountId, { userId, agentId })
-
-  getOpenclawWorkclawLogger().info(`[AccountManager] Allocated accountId=${accountId} for userId=${userId} agentId=${agentId}`)
-  return accountId
-}
-
-/**
- * Refresh the cache when an account's userId or agentId changes.
- */
-export function refreshAccountCache(cfg: OpenClawConfig): void {
-  buildAccountMap(cfg)
-}
-
-// =============================================================================
-// Account config resolution (pure functions, no in-memory state)
-// =============================================================================
-
-/**
- * List all configured account IDs from the accounts field.
- */
-function listConfiguredAccountIds(cfg: OpenClawConfig): string[] {
-  const accounts = (cfg.channels?.['openclaw-workclaw'] as OpenclawWorkclawConfig)?.accounts
-  if (!accounts || typeof accounts !== 'object') {
-    return []
-  }
-  return Object.keys(accounts).filter(Boolean)
-}
-
-/**
- * Check if plugin-level workclaw config exists (appKey + appSecret)
- */
-function hasPluginLevelWorkClawConfig(cfg: OpenClawConfig): boolean {
-  const openclawWorkclawCfg = cfg.channels?.['openclaw-workclaw'] as OpenclawWorkclawConfig | undefined
-  const key = typeof openclawWorkclawCfg?.appKey === 'string' ? openclawWorkclawCfg.appKey.trim() : ''
-  const secret = typeof openclawWorkclawCfg?.appSecret === 'string' ? openclawWorkclawCfg.appSecret.trim() : ''
-  return Boolean(key && secret)
-}
-
-/**
- * List all account IDs.
- * If no accounts are configured but plugin has workclaw config, returns [DEFAULT_ACCOUNT_ID].
- */
-export function listOpenclawWorkclawAccountIds(cfg: OpenClawConfig): string[] {
-  const ids = listConfiguredAccountIds(cfg)
-  if (ids.length === 0) {
-    // 如果没有配置账户，但插件级别有 workclaw 配置，返回默认账户
-    if (hasPluginLevelWorkClawConfig(cfg)) {
-      return [DEFAULT_ACCOUNT_ID]
-    }
-    // Backward compatibility: no accounts configured, use default
-    return [DEFAULT_ACCOUNT_ID]
-  }
-  return [...ids].toSorted((a, b) => a.localeCompare(b))
-}
-
-/**
- * Resolve the default account ID.
- */
-export function resolveDefaultOpenclawWorkclawAccountId(cfg: OpenClawConfig): string {
-  const ids = listOpenclawWorkclawAccountIds(cfg)
-  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
-    return DEFAULT_ACCOUNT_ID
-  }
-  return ids[0] ?? DEFAULT_ACCOUNT_ID
-}
-
-/**
- * Get the raw account-specific config.
- */
-function resolveAccountConfig(
-  cfg: OpenClawConfig,
-  accountId: string,
-): OpenclawWorkclawAccountConfig | undefined {
-  const accounts = (cfg.channels?.['openclaw-workclaw'] as OpenclawWorkclawConfig)?.accounts
-  if (!accounts || typeof accounts !== 'object') {
-    return undefined
-  }
-  return accounts[accountId]
-}
-
-function hasWorkClawConfig(config: {
-  appKey?: string
-  appSecret?: string
-  agentId?: string | number
-}): boolean {
-  const key = typeof config.appKey === 'string' ? config.appKey.trim() : ''
-  const secret
-    = typeof config.appSecret === 'string' ? config.appSecret.trim() : ''
-  // 只要有 appKey 和 appSecret 就认为配置了 workclaw（agentId 可以动态添加）
-  return Boolean(key && secret)
-}
-
-export function isOpenclawWorkclawAccountConfigured(config: {
-  appKey?: string
-  appSecret?: string
-  agentId?: string | number
-}): boolean {
-  return hasWorkClawConfig(config)
-}
-
-/**
- * Merge top-level config with account-specific config.
- * Account-specific fields override top-level fields.
- */
-function mergeOpenclawWorkclawAccountConfig(cfg: OpenClawConfig, accountId: string): OpenclawWorkclawConfig {
-  const openclawWorkclawCfg = cfg.channels?.['openclaw-workclaw'] as OpenclawWorkclawConfig | undefined
-
-  // Extract base config (exclude accounts field to avoid recursion)
-  const { accounts: _ignored, ...base } = openclawWorkclawCfg ?? {}
-
-  // Get account-specific overrides
-  const account = resolveAccountConfig(cfg, accountId) ?? {}
-
-  // Merge: account config overrides base config
-  return { ...base, ...account } as OpenclawWorkclawConfig
-}
-
-/**
- * Resolve a complete account with merged config.
- */
-export function resolveOpenclawWorkclawAccount(params: {
-  cfg: OpenClawConfig
-  accountId?: string | null
-}): ResolvedOpenclawWorkclawAccount {
-  const accountId = normalizeAccountId(params.accountId)
-  const openclawWorkclawCfg = params.cfg.channels?.['openclaw-workclaw'] as OpenclawWorkclawConfig | undefined
-
-  // Base enabled state (top-level)
-  const baseEnabled = openclawWorkclawCfg?.enabled !== false
-
-  // Merge configs
-  const merged = mergeOpenclawWorkclawAccountConfig(params.cfg, accountId)
-
-  // Account-level enabled state
-  const accountEnabled = merged.enabled !== false
-  const enabled = baseEnabled && accountEnabled
-
-  return {
-    accountId,
-    enabled,
-    configured: isOpenclawWorkclawAccountConfigured(merged),
-    name: (merged as OpenclawWorkclawAccountConfig).name?.trim() || undefined,
-    config: merged,
-  }
-}
-
-/**
- * List all enabled and configured accounts.
- */
-export function listEnabledOpenclawWorkclawAccounts(cfg: OpenClawConfig): ResolvedOpenclawWorkclawAccount[] {
-  return listConfiguredAccountIds(cfg)
-    .map(accountId => resolveOpenclawWorkclawAccount({ cfg, accountId }))
-    .filter(account => account.enabled && account.configured)
-}