@2en/clawly-plugins 1.13.0 → 1.15.0

package/gateway/channels-configure.ts

@@ -0,0 +1,151 @@
+/**
+ * Channel configuration management via openclaw.json.
+ *
+ * Methods:
+ * - clawly.channels.configure — add/update a channel account config
+ * - clawly.channels.disconnect — remove a channel account config
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+import type {PluginApi} from '../index'
+
+const TOKEN_CHANNELS = new Set(['telegram', 'discord', 'slack', 'irc', 'googlechat'])
+
+function resolveStateDir(api: PluginApi): string {
+  return api.runtime.state?.resolveStateDir?.(process.env) ?? process.env.OPENCLAW_STATE_DIR ?? ''
+}
+
+function readOpenclawConfig(configPath: string): Record<string, unknown> {
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+  } catch {
+    return {}
+  }
+}
+
+function writeOpenclawConfig(configPath: string, config: Record<string, unknown>) {
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
+}
+
+export function registerChannelsConfigure(api: PluginApi) {
+  // ── clawly.channels.configure ──────────────────────────────────
+
+  api.registerGatewayMethod('clawly.channels.configure', async ({params, respond}) => {
+    const channel = typeof params.channel === 'string' ? params.channel.trim() : ''
+    const accountId = typeof params.accountId === 'string' ? params.accountId.trim() : 'default'
+    const config =
+      params.config && typeof params.config === 'object' && !Array.isArray(params.config)
+        ? (params.config as Record<string, unknown>)
+        : null
+
+    if (!channel) {
+      respond(false, undefined, {code: 'invalid_params', message: 'channel is required'})
+      return
+    }
+
+    if (!TOKEN_CHANNELS.has(channel)) {
+      respond(false, undefined, {
+        code: 'invalid_params',
+        message: `unsupported channel: ${channel}. Supported: ${[...TOKEN_CHANNELS].join(', ')}`,
+      })
+      return
+    }
+
+    if (!config) {
+      respond(false, undefined, {code: 'invalid_params', message: 'config object is required'})
+      return
+    }
+
+    const stateDir = resolveStateDir(api)
+    if (!stateDir) {
+      respond(false, undefined, {code: 'internal', message: 'cannot resolve openclaw state dir'})
+      return
+    }
+
+    const configPath = path.join(stateDir, 'openclaw.json')
+
+    try {
+      const ocConfig = readOpenclawConfig(configPath)
+
+      // Ensure channels.<channel>.accounts.<accountId> path exists
+      if (!ocConfig.channels || typeof ocConfig.channels !== 'object') {
+        ocConfig.channels = {}
+      }
+      const channels = ocConfig.channels as Record<string, unknown>
+
+      if (!channels[channel] || typeof channels[channel] !== 'object') {
+        channels[channel] = {}
+      }
+      const channelConfig = channels[channel] as Record<string, unknown>
+
+      if (!channelConfig.accounts || typeof channelConfig.accounts !== 'object') {
+        channelConfig.accounts = {}
+      }
+      const accounts = channelConfig.accounts as Record<string, unknown>
+
+      // Merge config with enabled: true
+      accounts[accountId] = {
+        ...((accounts[accountId] as Record<string, unknown>) ?? {}),
+        ...config,
+        enabled: true,
+      }
+
+      writeOpenclawConfig(configPath, ocConfig)
+      api.logger.info(`channels.configure: wrote ${channel}/${accountId} to openclaw.json`)
+
+      respond(true, {ok: true, channel, accountId})
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      api.logger.error(`channels.configure: failed — ${msg}`)
+      respond(false, undefined, {code: 'internal', message: msg})
+    }
+  })
+
+  // ── clawly.channels.disconnect ─────────────────────────────────
+
+  api.registerGatewayMethod('clawly.channels.disconnect', async ({params, respond}) => {
+    const channel = typeof params.channel === 'string' ? params.channel.trim() : ''
+    const accountId = typeof params.accountId === 'string' ? params.accountId.trim() : 'default'
+
+    if (!channel) {
+      respond(false, undefined, {code: 'invalid_params', message: 'channel is required'})
+      return
+    }
+
+    const stateDir = resolveStateDir(api)
+    if (!stateDir) {
+      respond(false, undefined, {code: 'internal', message: 'cannot resolve openclaw state dir'})
+      return
+    }
+
+    const configPath = path.join(stateDir, 'openclaw.json')
+
+    try {
+      const ocConfig = readOpenclawConfig(configPath)
+      const channels = ocConfig.channels as Record<string, unknown> | undefined
+
+      if (channels && typeof channels === 'object') {
+        const channelConfig = channels[channel] as Record<string, unknown> | undefined
+        if (channelConfig && typeof channelConfig === 'object') {
+          const accounts = channelConfig.accounts as Record<string, unknown> | undefined
+          if (accounts && typeof accounts === 'object' && accountId in accounts) {
+            delete accounts[accountId]
+          }
+        }
+      }
+
+      writeOpenclawConfig(configPath, ocConfig)
+      api.logger.info(`channels.disconnect: removed ${channel}/${accountId} from openclaw.json`)
+
+      respond(true, {ok: true, channel, accountId})
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      api.logger.error(`channels.disconnect: failed — ${msg}`)
+      respond(false, undefined, {code: 'internal', message: msg})
+    }
+  })
+
+  api.logger.info('channels: registered clawly.channels.configure + clawly.channels.disconnect')
+}

package/gateway/index.ts

@@ -1,5 +1,6 @@
 import type {PluginApi} from '../index'
 import {registerAgentSend} from './agent'
+import {registerChannelsConfigure} from './channels-configure'
 import {registerClawhub2gateway} from './clawhub2gateway'
 import {registerInject} from './inject'
 import {registerMemoryBrowser} from './memory'
@@ -15,4 +16,5 @@ export function registerGateway(api: PluginApi) {
   registerMemoryBrowser(api)
   registerClawhub2gateway(api)
   registerPlugins(api)
+  registerChannelsConfigure(api)
 }

package/index.ts

@@ -33,7 +33,7 @@ import {registerCronHook} from './cron-hook'
 import {registerEmail} from './email'
 import {registerGateway} from './gateway'
 import {getGatewayConfig} from './gateway-fetch'
-import {registerOutboundHook, registerOutboundMethods} from './outbound'
+import {registerOutboundHook, registerOutboundHttpRoute, registerOutboundMethods} from './outbound'
 import {registerTools} from './tools'
 
 type PluginRuntime = {
@@ -92,6 +92,13 @@ export type PluginApi = {
     opts?: {optional?: boolean},
   ) => void
   registerChannel: (registration: {plugin: any}) => void
+  registerHttpRoute: (params: {
+    path: string
+    handler: (
+      req: import('node:http').IncomingMessage,
+      res: import('node:http').ServerResponse,
+    ) => Promise<void> | void
+  }) => void
 }
 
 export default {
@@ -101,6 +108,7 @@ export default {
   register(api: PluginApi) {
     registerOutboundHook(api)
     registerOutboundMethods(api)
+    registerOutboundHttpRoute(api)
     registerCommands(api)
     registerTools(api)
     registerClawlyCronChannel(api)

package/outbound.ts

@@ -8,6 +8,8 @@
 
 import crypto from 'node:crypto'
 import fs from 'node:fs'
+import fsp from 'node:fs/promises'
+import type {IncomingMessage, ServerResponse} from 'node:http'
 import os from 'node:os'
 import path from 'node:path'
 
@@ -29,6 +31,15 @@ function ensureOutboundDir(): void {
   fs.mkdirSync(OUTBOUND_DIR, {recursive: true})
 }
 
+async function fileExists(p: string): Promise<boolean> {
+  try {
+    await fsp.access(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
 // ── Hook: tool_result_persist ───────────────────────────────────────
 
 export function registerOutboundHook(api: PluginApi) {
@@ -73,16 +84,94 @@ export function registerOutboundMethods(api: PluginApi) {
 
     const dest = outboundFilePath(rawPath)
 
-    if (!fs.existsSync(dest)) {
+    if (!(await fileExists(dest))) {
       api.logger.warn(`outbound: file not found: ${rawPath} ${dest}`)
       respond(false, undefined, {code: 'not_found', message: 'outbound file not found'})
       return
     }
 
-    const buffer = fs.readFileSync(dest)
+    const buffer = await fsp.readFile(dest)
     const base64 = buffer.toString('base64')
 
     api.logger.info(`clawly.file.getOutbound: served ${rawPath} (${buffer.length} bytes)`)
     respond(true, {base64})
   })
 }
+
+// ── HTTP route: GET /clawly/file/outbound?path=<original-path> ─────────────
+
+const MIME: Record<string, string> = {
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.m4a': 'audio/mp4',
+  '.aac': 'audio/aac',
+  '.flac': 'audio/flac',
+  '.webm': 'audio/webm',
+}
+
+function sendJson(res: ServerResponse, status: number, body: Record<string, unknown>) {
+  res.writeHead(status, {'Content-Type': 'application/json'})
+  res.end(JSON.stringify(body))
+}
+
+export function registerOutboundHttpRoute(api: PluginApi) {
+  api.registerHttpRoute({
+    path: '/clawly/file/outbound',
+    handler: async (_req: IncomingMessage, res: ServerResponse) => {
+      const url = new URL(_req.url ?? '/', 'http://localhost')
+      const rawPath = url.searchParams.get('path')?.trim() ?? ''
+
+      if (!rawPath) {
+        sendJson(res, 400, {error: 'path query parameter is required'})
+        return
+      }
+
+      const dest = outboundFilePath(rawPath)
+
+      if (!(await fileExists(dest))) {
+        api.logger.warn(`outbound http: file not found: ${rawPath}`)
+        sendJson(res, 404, {error: 'outbound file not found'})
+        return
+      }
+
+      const ext = path.extname(dest).toLowerCase()
+      const contentType = MIME[ext] ?? 'application/octet-stream'
+      const stat = await fsp.stat(dest)
+      const total = stat.size
+      const rangeHeader = _req.headers.range
+
+      if (rangeHeader) {
+        const match = /bytes=(\d+)-(\d*)/.exec(rangeHeader)
+        if (match) {
+          const start = Number(match[1])
+          const end = match[2] ? Number(match[2]) : total - 1
+          const chunkSize = end - start + 1
+          const stream = fs.createReadStream(dest, {start, end})
+
+          res.writeHead(206, {
+            'Content-Type': contentType,
+            'Content-Range': `bytes ${start}-${end}/${total}`,
+            'Accept-Ranges': 'bytes',
+            'Content-Length': chunkSize,
+          })
+          stream.pipe(res)
+          api.logger.info(
+            `outbound http: served ${rawPath} -> ${dest} range ${start}-${end}/${total}`,
+          )
+          return
+        }
+      }
+
+      const buffer = await fsp.readFile(dest)
+      res.writeHead(200, {
+        'Content-Type': contentType,
+        'Content-Length': total,
+        'Accept-Ranges': 'bytes',
+      })
+      res.end(buffer)
+
+      api.logger.info(`outbound http: served ${rawPath} -> ${dest} (${total} bytes)`)
+    },
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "module": "index.ts",
   "type": "module",
   "repository": {