@2en/clawly-plugins 1.14.0 → 1.16.0

package/auto-pair.ts

@@ -0,0 +1,72 @@
+import type {PluginApi} from './index'
+
+const AUTO_APPROVE_CLIENT_IDS = new Set(['openclaw-ios'])
+const POLL_INTERVAL_MS = 3_000
+
+type PendingRequest = {
+  requestId: string
+  deviceId: string
+  clientId?: string
+  displayName?: string
+  platform?: string
+}
+
+type PairedDevice = {
+  deviceId: string
+  displayName?: string
+  platform?: string
+}
+
+type DevicePairingList = {
+  pending: PendingRequest[]
+  paired: PairedDevice[]
+}
+
+export function registerAutoPair(api: PluginApi) {
+  let timer: ReturnType<typeof setInterval> | null = null
+  let sdk: {
+    listDevicePairing: () => Promise<DevicePairingList>
+    approveDevicePairing: (
+      requestId: string,
+    ) => Promise<{requestId: string; device: PairedDevice} | null>
+  } | null = null
+
+  api.on('gateway_start', async () => {
+    try {
+      sdk = await import('openclaw/plugin-sdk')
+    } catch {
+      api.logger.warn('auto-pair: openclaw/plugin-sdk not available, skipping')
+      return
+    }
+
+    api.logger.info('auto-pair: started polling for pending pairing requests')
+
+    timer = setInterval(async () => {
+      if (!sdk) return
+      try {
+        const {pending} = await sdk.listDevicePairing()
+        for (const req of pending) {
+          if (req.clientId && AUTO_APPROVE_CLIENT_IDS.has(req.clientId)) {
+            const result = await sdk.approveDevicePairing(req.requestId)
+            if (result) {
+              api.logger.info(
+                `auto-pair: approved device=${result.device.deviceId} ` +
+                  `name=${result.device.displayName ?? 'unknown'} ` +
+                  `platform=${result.device.platform ?? 'unknown'}`,
+              )
+            }
+          }
+        }
+      } catch (err) {
+        api.logger.warn(`auto-pair: poll error: ${String(err)}`)
+      }
+    }, POLL_INTERVAL_MS)
+  })
+
+  api.on('gateway_stop', () => {
+    if (timer) {
+      clearInterval(timer)
+      timer = null
+    }
+  })
+}

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

@@ -24,8 +24,10 @@
  * Hooks:
  * - tool_result_persist   — copies TTS audio to persistent outbound directory
  * - before_tool_call      — enforces delivery fields on cron.create
+ * - gateway_start         — auto-approves device pairing for Clawly mobile clients (clientId: openclaw-ios)
  */
 
+import {registerAutoPair} from './auto-pair'
 import {registerCalendar} from './calendar'
 import {registerClawlyCronChannel} from './channel'
 import {registerCommands} from './command'
@@ -114,6 +116,7 @@ export default {
     registerClawlyCronChannel(api)
     registerCronHook(api)
     registerGateway(api)
+    registerAutoPair(api)
 
     // Email & calendar (optional — requires skillGatewayBaseUrl + skillGatewayToken in config)
     const gw = getGatewayConfig(api)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "module": "index.ts",
   "type": "module",
   "repository": {
@@ -17,6 +17,7 @@
     "lib",
     "tools",
     "index.ts",
+    "auto-pair.ts",
     "calendar.ts",
     "channel.ts",
     "cron-hook.ts",