@workclaw/openclaw-workclaw 1.0.0

package/src/accounts.ts

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

package/src/api/accounts-api.ts

@@ -0,0 +1,157 @@
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
+import { Buffer } from 'node:buffer'
+import { normalizeAccountId } from '../accounts.js'
+
+function sendJson(res: any, statusCode: number, payload: unknown): void {
+  res.statusCode = statusCode
+  res.setHeader('Content-Type', 'application/json')
+  res.end(JSON.stringify(payload))
+}
+
+async function readRequestBody(req: any): Promise<string> {
+  const chunks: Buffer[] = []
+  await new Promise<void>((resolve, reject) => {
+    req.on('data', (chunk: any) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+    })
+    req.on('end', () => resolve())
+    req.on('error', (err: unknown) => reject(err))
+  })
+  return Buffer.concat(chunks).toString('utf-8')
+}
+
+async function loadRuntimeConfig(api: OpenClawPluginApi): Promise<any> {
+  const runtimeConfig = (api.runtime as any)?.config
+  if (runtimeConfig?.loadConfig) {
+    return runtimeConfig.loadConfig()
+  }
+  return api.config
+}
+
+async function writeRuntimeConfig(api: OpenClawPluginApi, config: any): Promise<void> {
+  const runtimeConfig = (api.runtime as any)?.config
+  if (runtimeConfig?.writeConfigFile) {
+    await runtimeConfig.writeConfigFile(config)
+    return
+  }
+  throw new Error('Config write not supported')
+}
+
+function getAccountMap(config: any): Record<string, any> {
+  const channels = config?.channels && typeof config.channels === 'object' ? config.channels : {}
+  const openclawWorkclaw
+    = channels['openclaw-workclaw'] && typeof channels['openclaw-workclaw'] === 'object' ? channels['openclaw-workclaw'] : {}
+  const accounts
+    = openclawWorkclaw.accounts && typeof openclawWorkclaw.accounts === 'object' ? openclawWorkclaw.accounts : {}
+  return { ...accounts }
+}
+
+function withAccounts(config: any, accounts: Record<string, any>): any {
+  const channels = config?.channels && typeof config.channels === 'object' ? config.channels : {}
+  const openclawWorkclaw
+    = channels['openclaw-workclaw'] && typeof channels['openclaw-workclaw'] === 'object' ? channels['openclaw-workclaw'] : {}
+  return {
+    ...config,
+    channels: {
+      ...channels,
+      'openclaw-workclaw': {
+        ...openclawWorkclaw,
+        accounts,
+      },
+    },
+  }
+}
+
+export function createAccountsApiHandler(api: OpenClawPluginApi) {
+  return async (req: any, res: any) => {
+    const method = String(req.method ?? 'GET').toUpperCase()
+    const url = new URL(req.url ?? '', 'http://localhost')
+    const idRaw = url.searchParams.get('id') ?? url.searchParams.get('accountId')
+    const accountId = idRaw ? normalizeAccountId(idRaw) : null
+
+    if (method === 'GET') {
+      const cfg = await loadRuntimeConfig(api)
+      const accounts = getAccountMap(cfg)
+
+      if (accountId) {
+        const account = accounts[accountId]
+        if (!account) {
+          sendJson(res, 404, { ok: false, error: 'Not Found' })
+          return
+        }
+        sendJson(res, 200, { ok: true, accountId, config: account })
+        return
+      }
+
+      const entries = Object.entries(accounts).map(([id, config]) => ({
+        accountId: id,
+        config,
+      }))
+      sendJson(res, 200, { ok: true, accounts: entries })
+      return
+    }
+
+    if (method === 'POST' || method === 'PUT') {
+      const raw = await readRequestBody(req)
+      let input: any = {}
+      try {
+        input = raw ? JSON.parse(raw) : {}
+      }
+      catch {
+        sendJson(res, 400, { ok: false, error: 'Invalid JSON' })
+        return
+      }
+
+      const inputId = input?.accountId ?? input?.id
+      const normalizedId = inputId ? normalizeAccountId(String(inputId)) : ''
+      const patch = input?.config
+
+      if (!normalizedId || !patch || typeof patch !== 'object') {
+        sendJson(res, 400, { ok: false, error: 'Missing accountId or config' })
+        return
+      }
+
+      const cfg = await loadRuntimeConfig(api)
+      const accounts = getAccountMap(cfg)
+
+      if (method === 'POST' && accounts[normalizedId]) {
+        sendJson(res, 409, { ok: false, error: 'Account already exists' })
+        return
+      }
+
+      if (method === 'PUT' && !accounts[normalizedId]) {
+        sendJson(res, 404, { ok: false, error: 'Not Found' })
+        return
+      }
+
+      const next = method === 'PUT' ? { ...accounts[normalizedId], ...patch } : patch
+      const updated = withAccounts(cfg, { ...accounts, [normalizedId]: next })
+      await writeRuntimeConfig(api, updated)
+      sendJson(res, 200, { ok: true, accountId: normalizedId })
+      return
+    }
+
+    if (method === 'DELETE') {
+      if (!accountId) {
+        sendJson(res, 400, { ok: false, error: 'Missing accountId' })
+        return
+      }
+
+      const cfg = await loadRuntimeConfig(api)
+      const accounts = getAccountMap(cfg)
+
+      if (!accounts[accountId]) {
+        sendJson(res, 404, { ok: false, error: 'Not Found' })
+        return
+      }
+
+      const { [accountId]: _ignored, ...rest } = accounts
+      const updated = withAccounts(cfg, rest)
+      await writeRuntimeConfig(api, updated)
+      sendJson(res, 200, { ok: true, accountId, deleted: true })
+      return
+    }
+
+    sendJson(res, 405, { ok: false, error: 'Method Not Allowed' })
+  }
+}

package/src/api/prompts-api.ts

@@ -0,0 +1,123 @@
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
+import { Buffer } from 'node:buffer'
+import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+import { resolveWorkspaceDir } from './workspace.js'
+
+const promptNames = ['SOUL.md', 'IDENTITY.md'] as const
+
+function normalizePromptName(raw: string | null | undefined): (typeof promptNames)[number] | null {
+  const name = String(raw ?? '').trim().toUpperCase()
+  if (name === 'SOUL' || name === 'SOUL.MD')
+    return 'SOUL.md'
+  if (name === 'IDENTITY' || name === 'IDENTITY.MD')
+    return 'IDENTITY.md'
+  return null
+}
+
+function resolvePromptPath(api: OpenClawPluginApi, name: (typeof promptNames)[number]): string {
+  return path.join(resolveWorkspaceDir(api), name)
+}
+
+function sendJson(res: any, statusCode: number, payload: unknown): void {
+  res.statusCode = statusCode
+  res.setHeader('Content-Type', 'application/json')
+  res.end(JSON.stringify(payload))
+}
+
+export function createPromptsApiHandler(api: OpenClawPluginApi) {
+  return async (req: any, res: any) => {
+    const method = String(req.method ?? 'GET').toUpperCase()
+    const url = new URL(req.url ?? '', 'http://localhost')
+    const name = normalizePromptName(url.searchParams.get('name'))
+
+    if (method === 'GET') {
+      if (name) {
+        const filePath = resolvePromptPath(api, name)
+        try {
+          const content = await readFile(filePath, 'utf-8')
+          sendJson(res, 200, { ok: true, name, content })
+          return
+        }
+        catch {
+          sendJson(res, 404, { ok: false, error: 'Not Found' })
+          return
+        }
+      }
+
+      const entries = await Promise.all(
+        promptNames.map(async (promptName) => {
+          const filePath = resolvePromptPath(api, promptName)
+          try {
+            const info = await stat(filePath)
+            return { name: promptName, exists: true, bytes: info.size }
+          }
+          catch {
+            return { name: promptName, exists: false, bytes: 0 }
+          }
+        }),
+      )
+      sendJson(res, 200, { ok: true, entries })
+      return
+    }
+
+    if (method === 'PUT' || method === 'POST') {
+      const raw = await readRequestBody(req)
+      let input: any = {}
+      try {
+        input = raw ? JSON.parse(raw) : {}
+      }
+      catch {
+        sendJson(res, 400, { ok: false, error: 'Invalid JSON' })
+        return
+      }
+
+      const targetName = normalizePromptName(input?.name)
+      const content = typeof input?.content === 'string' ? input.content : null
+
+      if (!targetName || content === null) {
+        sendJson(res, 400, { ok: false, error: 'Missing name or content' })
+        return
+      }
+
+      const workspaceDir = resolveWorkspaceDir(api)
+      await mkdir(workspaceDir, { recursive: true })
+      await writeFile(resolvePromptPath(api, targetName), content, { encoding: 'utf-8' })
+      sendJson(res, 200, { ok: true, name: targetName })
+      return
+    }
+
+    if (method === 'DELETE') {
+      if (!name) {
+        sendJson(res, 400, { ok: false, error: 'Missing name' })
+        return
+      }
+
+      const filePath = resolvePromptPath(api, name)
+      try {
+        await unlink(filePath)
+        sendJson(res, 200, { ok: true, name, deleted: true })
+        return
+      }
+      catch {
+        sendJson(res, 200, { ok: true, name, deleted: false })
+        return
+      }
+    }
+
+    sendJson(res, 405, { ok: false, error: 'Method Not Allowed' })
+  }
+}
+
+async function readRequestBody(req: any): Promise<string> {
+  const chunks: Buffer[] = []
+  await new Promise<void>((resolve, reject) => {
+    req.on('data', (chunk: any) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+    })
+    req.on('end', () => resolve())
+    req.on('error', (err: unknown) => reject(err))
+  })
+  return Buffer.concat(chunks).toString('utf-8')
+}