freddie 0.0.48 → 0.0.49

package/plugins/platform-feishu_comment/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-feishu_comment', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'feishu_comment', module: adapter }) } }

package/plugins/platform-feishu_comment_rules/handler.js

@@ -0,0 +1,11 @@
+export const COMMENT_RULES = {
+    auto_reply_keywords: ['question', 'pls', 'help'],
+    skip_authors: [],
+    max_comment_age_hours: 168,
+}
+export function shouldAutoReply(comment, rules = COMMENT_RULES) {
+    const text = String(comment?.content || '').toLowerCase()
+    if (rules.skip_authors.includes(comment.author)) return false
+    if (rules.max_comment_age_hours && comment.created && (Date.now() - comment.created) > rules.max_comment_age_hours * 3600_000) return false
+    return rules.auto_reply_keywords.some(k => text.includes(k.toLowerCase()))
+}

package/plugins/platform-feishu_comment_rules/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-feishu_comment_rules', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'feishu_comment_rules', module: adapter }) } }

package/plugins/platform-homeassistant/handler.js

@@ -0,0 +1,32 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class HomeassistantAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'homeassistant'
+        this.token = opts.token || process.env.HASS_TOKEN
+        this.port = opts.port || 0
+        this.api = opts.api || "http://homeassistant.local:8123/api/services/notify/notify"
+        this._server = null
+    }
+    getRequiredEnv() { return ["HASS_TOKEN"] }
+    async start() {
+        if (!this.token) throw new Error('HomeassistantAdapter: ' + this.getRequiredEnv().join(', ') + ' required')
+        const app = express()
+        app.use(express.json())
+        app.post('/webhook', (req, res) => {
+            const text = req.body?.text || req.body?.message?.text || req.body?.content || ''
+            const from = req.body?.from || req.body?.user_id || req.body?.sender_id || ''
+            this.emit('message', { from: String(from), text, raw: req.body })
+            res.json({ ok: true })
+        })
+        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send(reply) {
+        if (!this.token) throw new Error('HomeassistantAdapter: token required')
+        return fetch(this.api, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ to: reply.to, text: reply.text }) }).then(r => r.json())
+    }
+}

package/plugins/platform-homeassistant/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-homeassistant', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'homeassistant', module: adapter }) } }

package/plugins/platform-matrix/handler.js

@@ -0,0 +1,40 @@
+import { EventEmitter } from 'node:events'
+
+export class MatrixAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'matrix'
+        this.homeserver = opts.homeserver || process.env.MATRIX_HOMESERVER
+        this.token = opts.token || process.env.MATRIX_ACCESS_TOKEN
+        this.since = null
+        this._running = false
+    }
+    getRequiredEnv() { return ['MATRIX_HOMESERVER', 'MATRIX_ACCESS_TOKEN'] }
+    async start() {
+        if (!this.homeserver || !this.token) throw new Error('MatrixAdapter: MATRIX_HOMESERVER + MATRIX_ACCESS_TOKEN required')
+        this._running = true
+        this._loop()
+    }
+    async stop() { this._running = false }
+    async _loop() {
+        while (this._running) {
+            try {
+                const url = `${this.homeserver}/_matrix/client/v3/sync?timeout=25000${this.since ? '&since=' + this.since : ''}`
+                const res = await fetch(url, { headers: { authorization: `Bearer ${this.token}` } })
+                const data = await res.json()
+                this.since = data.next_batch
+                const rooms = data.rooms?.join || {}
+                for (const [roomId, room] of Object.entries(rooms)) {
+                    for (const ev of (room.timeline?.events || [])) {
+                        if (ev.type === 'm.room.message') this.emit('message', { from: roomId, text: ev.content?.body || '', user: ev.sender, raw: ev })
+                    }
+                }
+            } catch (e) { await new Promise(r => setTimeout(r, 2000)) }
+        }
+    }
+    async send(reply) {
+        const txnId = Date.now() + '-' + Math.random().toString(36).slice(2, 8)
+        const url = `${this.homeserver}/_matrix/client/v3/rooms/${encodeURIComponent(reply.to)}/send/m.room.message/${txnId}`
+        return fetch(url, { method: 'PUT', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ msgtype: 'm.text', body: reply.text }) }).then(r => r.json())
+    }
+}

package/plugins/platform-matrix/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-matrix', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'matrix', module: adapter }) } }

package/plugins/platform-mattermost/handler.js

@@ -0,0 +1,29 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class MattermostAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'mattermost'
+        this.url = opts.url || process.env.MATTERMOST_URL
+        this.token = opts.token || process.env.MATTERMOST_TOKEN
+        this.port = opts.port || 0
+        this._server = null
+    }
+    getRequiredEnv() { return ['MATTERMOST_URL', 'MATTERMOST_TOKEN'] }
+    async start() {
+        if (!this.url || !this.token) throw new Error('MattermostAdapter: MATTERMOST_URL + MATTERMOST_TOKEN required')
+        const app = express()
+        app.use(express.urlencoded({ extended: true }))
+        app.post('/hook', (req, res) => {
+            this.emit('message', { from: req.body.channel_id, text: req.body.text || '', user: req.body.user_id, raw: req.body })
+            res.json({})
+        })
+        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send(reply) {
+        return fetch(`${this.url}/api/v4/posts`, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ channel_id: reply.to, message: reply.text }) }).then(r => r.json())
+    }
+}

package/plugins/platform-mattermost/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-mattermost', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'mattermost', module: adapter }) } }

package/plugins/platform-qqbot/handler.js

@@ -0,0 +1,32 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class QqbotAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'qqbot'
+        this.token = opts.token || process.env.QQBOT_TOKEN
+        this.port = opts.port || 0
+        this.api = opts.api || "https://api.sgroup.qq.com/channels/messages"
+        this._server = null
+    }
+    getRequiredEnv() { return ["QQBOT_TOKEN"] }
+    async start() {
+        if (!this.token) throw new Error('QqbotAdapter: ' + this.getRequiredEnv().join(', ') + ' required')
+        const app = express()
+        app.use(express.json())
+        app.post('/webhook', (req, res) => {
+            const text = req.body?.text || req.body?.message?.text || req.body?.content || ''
+            const from = req.body?.from || req.body?.user_id || req.body?.sender_id || ''
+            this.emit('message', { from: String(from), text, raw: req.body })
+            res.json({ ok: true })
+        })
+        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send(reply) {
+        if (!this.token) throw new Error('QqbotAdapter: token required')
+        return fetch(this.api, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ to: reply.to, text: reply.text }) }).then(r => r.json())
+    }
+}

package/plugins/platform-qqbot/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-qqbot', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'qqbot', module: adapter }) } }

package/plugins/platform-signal/handler.js

@@ -0,0 +1,33 @@
+import { EventEmitter } from 'node:events'
+
+export class SignalAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'signal'
+        this.api = opts.api || process.env.SIGNAL_CLI_URL || 'http://127.0.0.1:8080'
+        this.number = opts.number || process.env.SIGNAL_NUMBER
+        this._running = false
+    }
+    getRequiredEnv() { return ['SIGNAL_CLI_URL', 'SIGNAL_NUMBER'] }
+    async start() {
+        if (!this.number) throw new Error('SignalAdapter: SIGNAL_NUMBER required')
+        this._running = true
+        this._loop()
+    }
+    async stop() { this._running = false }
+    async _loop() {
+        while (this._running) {
+            try {
+                const res = await fetch(`${this.api}/v1/receive/${this.number}`)
+                const items = await res.json()
+                for (const it of items) {
+                    const msg = it?.envelope?.dataMessage
+                    if (msg) this.emit('message', { from: it.envelope.source, text: msg.message || '', raw: it })
+                }
+            } catch (e) { await new Promise(r => setTimeout(r, 2000)) }
+        }
+    }
+    async send(reply) {
+        return fetch(`${this.api}/v2/send`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ number: this.number, recipients: [reply.to], message: reply.text }) }).then(r => r.json())
+    }
+}

package/plugins/platform-signal/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-signal', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'signal', module: adapter }) } }

package/plugins/platform-slack/handler.js

@@ -0,0 +1,34 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class SlackAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'slack'
+        this.token = opts.token || process.env.SLACK_BOT_TOKEN
+        this.signingSecret = opts.signingSecret || process.env.SLACK_SIGNING_SECRET
+        this.port = opts.port || 0
+        this.path = opts.path || '/slack/events'
+        this.api = opts.api || 'https://slack.com/api'
+        this._server = null
+    }
+    getRequiredEnv() { return ['SLACK_BOT_TOKEN', 'SLACK_SIGNING_SECRET'] }
+    async start() {
+        if (!this.token) throw new Error('SlackAdapter: SLACK_BOT_TOKEN required')
+        const app = express()
+        app.use(express.json())
+        app.post(this.path, (req, res) => {
+            if (req.body?.type === 'url_verification') return res.json({ challenge: req.body.challenge })
+            const ev = req.body?.event
+            if (ev?.type === 'message' && !ev.bot_id) this.emit('message', { from: ev.channel, text: ev.text || '', user: ev.user, raw: req.body })
+            res.json({ ok: true })
+        })
+        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send(reply) {
+        if (!this.token) throw new Error('SlackAdapter: token required')
+        return fetch(`${this.api}/chat.postMessage`, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ channel: reply.to, text: reply.text }) }).then(r => r.json())
+    }
+}

package/plugins/platform-slack/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-slack', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'slack', module: adapter }) } }

package/plugins/platform-sms/handler.js

@@ -0,0 +1,34 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class SmsAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'sms'
+        this.sid = opts.sid || process.env.TWILIO_SID
+        this.token = opts.token || process.env.TWILIO_TOKEN
+        this.from = opts.from || process.env.TWILIO_FROM
+        this.port = opts.port || 0
+        this._server = null
+    }
+    getRequiredEnv() { return ['TWILIO_SID', 'TWILIO_TOKEN', 'TWILIO_FROM'] }
+    async start() {
+        if (!this.sid || !this.token || !this.from) throw new Error('SmsAdapter: TWILIO_SID/TOKEN/FROM required')
+        const app = express()
+        app.use(express.urlencoded({ extended: true }))
+        app.post('/sms', (req, res) => {
+            this.emit('message', { from: req.body.From, text: req.body.Body || '', raw: req.body })
+            res.set('content-type', 'text/xml')
+            res.send('<Response/>')
+        })
+        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send(reply) {
+        const url = `https://api.twilio.com/2010-04-01/Accounts/${this.sid}/Messages.json`
+        const body = new URLSearchParams({ To: reply.to, From: this.from, Body: reply.text }).toString()
+        const auth = 'Basic ' + Buffer.from(`${this.sid}:${this.token}`).toString('base64')
+        return fetch(url, { method: 'POST', headers: { authorization: auth, 'content-type': 'application/x-www-form-urlencoded' }, body }).then(r => r.json())
+    }
+}

package/plugins/platform-sms/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-sms', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'sms', module: adapter }) } }

package/plugins/platform-telegram/handler.js

@@ -0,0 +1,38 @@
+import { EventEmitter } from 'node:events'
+
+export class TelegramAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'telegram'
+        this.token = opts.token || process.env.TELEGRAM_BOT_TOKEN
+        this.api = opts.api || 'https://api.telegram.org'
+        this.offset = 0
+        this._running = false
+        this._poll = null
+    }
+    getRequiredEnv() { return ['TELEGRAM_BOT_TOKEN'] }
+    async start() {
+        if (!this.token) throw new Error('TelegramAdapter: TELEGRAM_BOT_TOKEN required')
+        this._running = true
+        this._loop()
+    }
+    async stop() { this._running = false; if (this._poll) clearTimeout(this._poll) }
+    async _loop() {
+        while (this._running) {
+            try {
+                const url = `${this.api}/bot${this.token}/getUpdates?timeout=25&offset=${this.offset + 1}`
+                const res = await fetch(url)
+                const data = await res.json()
+                if (data.ok) for (const u of data.result) {
+                    this.offset = Math.max(this.offset, u.update_id)
+                    if (u.message) this.emit('message', { from: String(u.message.from?.id || ''), text: u.message.text || '', raw: u })
+                }
+            } catch (e) { await new Promise(r => setTimeout(r, 5000)) }
+        }
+    }
+    async send(reply) {
+        if (!this.token) throw new Error('TelegramAdapter: token required')
+        const url = `${this.api}/bot${this.token}/sendMessage`
+        return fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ chat_id: reply.to, text: reply.text }) }).then(r => r.json())
+    }
+}

package/plugins/platform-telegram/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-telegram', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'telegram', module: adapter }) } }

package/plugins/platform-telegram_network/handler.js

@@ -0,0 +1,17 @@
+export function tgFloodWait(error) {
+    const m = String(error?.message || '').match(/FLOOD_WAIT_(\d+)/)
+    return m ? Number(m[1]) * 1000 : null
+}
+export async function tgWithRetry(fn, { attempts = 3 } = {}) {
+    let last
+    for (let i = 0; i < attempts; i++) {
+        try { return await fn() } catch (e) {
+            last = e
+            const wait = tgFloodWait(e)
+            if (wait != null) await new Promise(r => setTimeout(r, wait + 100))
+            else if (i < attempts - 1) await new Promise(r => setTimeout(r, 500 * (i + 1)))
+        }
+    }
+    throw last
+}
+export function withProxy(fetchOpts, proxy) { return proxy ? { ...fetchOpts, proxy } : fetchOpts }

package/plugins/platform-telegram_network/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-telegram_network', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'telegram_network', module: adapter }) } }

package/plugins/platform-webhook/handler.js

@@ -0,0 +1,19 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class WebhookAdapter extends EventEmitter {
+    constructor({ port = 0, path = '/webhook' } = {}) { super(); this.port = port; this.path = path; this._server = null; this.outbox = [] }
+    async start() {
+        const app = express()
+        app.use(express.json())
+        app.post(this.path, (req, res) => {
+            const m = { from: req.body?.from || 'webhook', text: req.body?.text || '', raw: req.body }
+            this.emit('message', m)
+            res.json({ ok: true })
+        })
+        await new Promise(resolve => { this._server = app.listen(this.port, () => resolve()) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send(reply) { this.outbox.push(reply) }
+}

package/plugins/platform-webhook/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-webhook', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'webhook', module: adapter }) } }

package/plugins/platform-wecom/handler.js

@@ -0,0 +1,32 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class WecomAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'wecom'
+        this.token = opts.token || process.env.WECOM_WEBHOOK_KEY
+        this.port = opts.port || 0
+        this.api = opts.api || "https://qyapi.weixin.qq.com/cgi-bin/webhook/send"
+        this._server = null
+    }
+    getRequiredEnv() { return ["WECOM_WEBHOOK_KEY"] }
+    async start() {
+        if (!this.token) throw new Error('WecomAdapter: ' + this.getRequiredEnv().join(', ') + ' required')
+        const app = express()
+        app.use(express.json())
+        app.post('/webhook', (req, res) => {
+            const text = req.body?.text || req.body?.message?.text || req.body?.content || ''
+            const from = req.body?.from || req.body?.user_id || req.body?.sender_id || ''
+            this.emit('message', { from: String(from), text, raw: req.body })
+            res.json({ ok: true })
+        })
+        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send(reply) {
+        if (!this.token) throw new Error('WecomAdapter: token required')
+        return fetch(this.api, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ to: reply.to, text: reply.text }) }).then(r => r.json())
+    }
+}

package/plugins/platform-wecom/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-wecom', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'wecom', module: adapter }) } }

package/plugins/platform-wecom_callback/handler.js

@@ -0,0 +1,15 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+export class WecomCallbackAdapter extends EventEmitter {
+    constructor(opts = {}) { super(); this.platform = 'wecom_callback'; this.token = opts.token || process.env.WECOM_CALLBACK_TOKEN; this.aesKey = opts.aesKey || process.env.WECOM_ENCODING_AES_KEY; this.port = opts.port || 0 }
+    getRequiredEnv() { return ['WECOM_CALLBACK_TOKEN'] }
+    async start() {
+        if (!this.token) throw new Error('WECOM_CALLBACK_TOKEN required')
+        const app = express(); app.use(express.text({ type: '*/*' }))
+        app.post('/wecom/callback', (req, res) => { this.emit('message', { from: 'wecom', text: req.body || '', raw: req.body }); res.send('') })
+        this._server = await new Promise(r => { const s = app.listen(this.port, () => r(s)) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send() { return { error: 'wecom_callback is receive-only; use wecom adapter for outbound' } }
+}

package/plugins/platform-wecom_callback/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-wecom_callback', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'wecom_callback', module: adapter }) } }

package/plugins/platform-wecom_crypto/handler.js

@@ -0,0 +1,16 @@
+import crypto from 'node:crypto'
+export function sha1(...parts) { return crypto.createHash('sha1').update(parts.sort().join('')).digest('hex') }
+export function verifyMsgSignature({ token, timestamp, nonce, encrypt, signature }) {
+    return sha1(token, timestamp, nonce, encrypt) === signature
+}
+export function decryptMsg(encryptedB64, encodingAesKey) {
+    const aesKey = Buffer.from(encodingAesKey + '=', 'base64')
+    const iv = aesKey.slice(0, 16)
+    const decipher = crypto.createDecipheriv('aes-256-cbc', aesKey, iv)
+    decipher.setAutoPadding(false)
+    const decrypted = Buffer.concat([decipher.update(Buffer.from(encryptedB64, 'base64')), decipher.final()])
+    const padLen = decrypted[decrypted.length - 1]
+    const trimmed = decrypted.slice(16, decrypted.length - padLen)
+    const xmlLen = trimmed.readUInt32BE(0)
+    return { xml: trimmed.slice(4, 4 + xmlLen).toString('utf8'), corpId: trimmed.slice(4 + xmlLen).toString('utf8') }
+}

package/plugins/platform-wecom_crypto/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-wecom_crypto', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'wecom_crypto', module: adapter }) } }

package/plugins/platform-weixin/handler.js

@@ -0,0 +1,32 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class WeixinAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'weixin'
+        this.token = opts.token || process.env.WEIXIN_TOKEN
+        this.port = opts.port || 0
+        this.api = opts.api || "https://api.weixin.qq.com/cgi-bin/message/send"
+        this._server = null
+    }
+    getRequiredEnv() { return ["WEIXIN_TOKEN"] }
+    async start() {
+        if (!this.token) throw new Error('WeixinAdapter: ' + this.getRequiredEnv().join(', ') + ' required')
+        const app = express()
+        app.use(express.json())
+        app.post('/webhook', (req, res) => {
+            const text = req.body?.text || req.body?.message?.text || req.body?.content || ''
+            const from = req.body?.from || req.body?.user_id || req.body?.sender_id || ''
+            this.emit('message', { from: String(from), text, raw: req.body })
+            res.json({ ok: true })
+        })
+        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send(reply) {
+        if (!this.token) throw new Error('WeixinAdapter: token required')
+        return fetch(this.api, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ to: reply.to, text: reply.text }) }).then(r => r.json())
+    }
+}

package/plugins/platform-weixin/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-weixin', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'weixin', module: adapter }) } }

package/plugins/platform-whatsapp/handler.js

@@ -0,0 +1,40 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class WhatsappAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'whatsapp'
+        this.token = opts.token || process.env.WHATSAPP_API_TOKEN
+        this.phoneId = opts.phoneId || process.env.WHATSAPP_PHONE_NUMBER_ID
+        this.verifyToken = opts.verifyToken || process.env.WHATSAPP_VERIFY_TOKEN || 'freddie'
+        this.port = opts.port || 0
+        this.api = opts.api || 'https://graph.facebook.com/v20.0'
+        this._server = null
+    }
+    getRequiredEnv() { return ['WHATSAPP_API_TOKEN', 'WHATSAPP_PHONE_NUMBER_ID'] }
+    async start() {
+        if (!this.token || !this.phoneId) throw new Error('WhatsappAdapter: WHATSAPP_API_TOKEN + WHATSAPP_PHONE_NUMBER_ID required')
+        const app = express()
+        app.use(express.json())
+        app.get('/webhook', (req, res) => {
+            if (req.query['hub.verify_token'] === this.verifyToken) return res.send(req.query['hub.challenge'])
+            res.sendStatus(403)
+        })
+        app.post('/webhook', (req, res) => {
+            const entries = req.body?.entry || []
+            for (const e of entries) for (const c of (e.changes || [])) {
+                const msgs = c.value?.messages || []
+                for (const m of msgs) this.emit('message', { from: m.from, text: m.text?.body || '', raw: m })
+            }
+            res.json({ ok: true })
+        })
+        await new Promise(r => { this._server = app.listen(this.port, () => r()) })
+        this.port = this._server.address().port
+    }
+    async stop() { if (this._server) await new Promise(r => this._server.close(() => r())) }
+    async send(reply) {
+        if (!this.token) throw new Error('WhatsappAdapter: token required')
+        return fetch(`${this.api}/${this.phoneId}/messages`, { method: 'POST', headers: { authorization: `Bearer ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ messaging_product: 'whatsapp', to: reply.to, text: { body: reply.text } }) }).then(r => r.json())
+    }
+}

package/plugins/platform-whatsapp/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-whatsapp', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'whatsapp', module: adapter }) } }

package/plugins/platform-yuanbao/handler.js

@@ -0,0 +1,9 @@
+import { BasePlatformAdapter } from '../../src/gateway/base.js'
+export class YuanbaoAdapter extends BasePlatformAdapter {
+    constructor(opts = {}) { super({ ...opts, platform: 'yuanbao' }); this.token = opts.token || process.env.YUANBAO_API_KEY; this.api = opts.api || 'https://api.hunyuan.cloud.tencent.com/v1' }
+    getRequiredEnv() { return ['YUANBAO_API_KEY'] }
+    async send(reply) {
+        const r = await fetch(this.api + '/chat/completions', { method: 'POST', headers: { authorization: 'Bearer ' + this.token, 'content-type': 'application/json' }, body: JSON.stringify({ model: 'hunyuan-pro', messages: [{ role: 'user', content: reply.text }] }) })
+        return await r.json()
+    }
+}

package/plugins/platform-yuanbao/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-yuanbao', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'yuanbao', module: adapter }) } }

package/plugins/platform-yuanbao_media/handler.js

@@ -0,0 +1,5 @@
+export async function uploadMedia({ token, file, mime = 'image/png' }) {
+    if (!token) throw new Error('yuanbao token required')
+    const r = await fetch('https://api.hunyuan.cloud.tencent.com/v1/files', { method: 'POST', headers: { authorization: 'Bearer ' + token, 'content-type': mime }, body: file })
+    return await r.json()
+}

package/plugins/platform-yuanbao_media/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-yuanbao_media', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'yuanbao_media', module: adapter }) } }

package/plugins/platform-yuanbao_proto/handler.js

@@ -0,0 +1,9 @@
+export function buildChatPayload({ model = 'hunyuan-pro', messages, stream = false, tools = [] }) {
+    return { model, messages, stream, ...(tools.length ? { tools: tools.map(t => ({ type: 'function', function: t })) } : {}) }
+}
+export function parseChatResponse(json) {
+    const choice = json?.choices?.[0]
+    if (!choice) return { content: '', tool_calls: [] }
+    const tc = (choice.message?.tool_calls || []).map(c => ({ id: c.id, name: c.function?.name, arguments: c.function?.arguments ? JSON.parse(c.function.arguments) : {} }))
+    return { content: choice.message?.content || '', tool_calls: tc }
+}

package/plugins/platform-yuanbao_proto/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-yuanbao_proto', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'yuanbao_proto', module: adapter }) } }

package/plugins/platform-yuanbao_sticker/handler.js

@@ -0,0 +1,6 @@
+export const STICKER_PACK = ['cute', 'work', 'celebration', 'thinking', 'thumbs-up']
+export function buildStickerMessage({ to, sticker }) {
+    if (!STICKER_PACK.includes(sticker)) throw new Error('unknown sticker: ' + sticker)
+    return { to, type: 'sticker', sticker }
+}
+export function listStickers() { return STICKER_PACK }

package/plugins/platform-yuanbao_sticker/plugin.js

@@ -0,0 +1,2 @@
+import * as adapter from './handler.js'
+export default { name: 'platform-yuanbao_sticker', surfaces: 'pi', register({ pi }) { pi.platforms.register({ name: 'yuanbao_sticker', module: adapter }) } }

package/plugins/process_registry/handler.js

@@ -0,0 +1,15 @@
+const _processes = new Map()
+export function registerProcess(id, child, meta = {}) { _processes.set(id, { id, pid: child.pid, started: Date.now(), ...meta }); child.on?.('exit', () => _processes.delete(id)) }
+export function listProcesses() { return [..._processes.values()] }
+export function killProcess(id) { const p = _processes.get(id); if (p) try { process.kill(p.pid, 'SIGTERM') } catch {} return p ? { killed: id } : { error: 'unknown id' } }
+
+export const _tool = ({
+    name: 'process_registry',
+    toolset: 'core',
+    schema: { name: 'process_registry', description: 'List/kill spawned background processes tracked by freddie.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['list', 'kill'] }, id: { type: 'string' } }, required: ['action'] } },
+    handler: async ({ action, id }) => {
+        if (action === 'list') return { processes: listProcesses() }
+        if (action === 'kill') return killProcess(id)
+        return { error: 'unknown action' }
+    },
+})

package/plugins/process_registry/plugin.js

@@ -0,0 +1,2 @@
+import { _tool } from './handler.js'
+export default { name: 'tool-process_registry', surfaces: 'pi', register({ pi }) { pi.tools.register(_tool) } }