freddie 0.0.47 → 0.0.49

package/plugins/platform-email/handler.js

@@ -0,0 +1,51 @@
+import { EventEmitter } from 'node:events'
+import net from 'node:net'
+
+export class EmailAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'email'
+        this.smtpHost = opts.smtpHost || process.env.SMTP_HOST
+        this.smtpPort = opts.smtpPort || Number(process.env.SMTP_PORT || 587)
+        this.smtpUser = opts.smtpUser || process.env.SMTP_USER
+        this.smtpPass = opts.smtpPass || process.env.SMTP_PASS
+        this.imapHost = opts.imapHost || process.env.IMAP_HOST
+        this._running = false
+    }
+    getRequiredEnv() { return ['SMTP_HOST', 'SMTP_USER', 'SMTP_PASS'] }
+    async start() {
+        if (!this.smtpHost || !this.smtpUser || !this.smtpPass) throw new Error('EmailAdapter: SMTP_HOST/USER/PASS required')
+        this._running = true
+    }
+    async stop() { this._running = false }
+    async send(reply) {
+        return new Promise((resolve, reject) => {
+            const sock = net.createConnection(this.smtpPort, this.smtpHost)
+            const lines = []
+            const send = s => sock.write(s + '\r\n')
+            sock.on('data', d => {
+                const text = d.toString()
+                lines.push(text)
+                const code = parseInt(text.slice(0, 3), 10)
+                if (code >= 400) { sock.end(); return reject(new Error('SMTP error: ' + text)) }
+            })
+            sock.on('error', reject)
+            sock.on('connect', () => {
+                send('EHLO freddie')
+                send('AUTH LOGIN')
+                send(Buffer.from(this.smtpUser).toString('base64'))
+                send(Buffer.from(this.smtpPass).toString('base64'))
+                send('MAIL FROM:<' + this.smtpUser + '>')
+                send('RCPT TO:<' + reply.to + '>')
+                send('DATA')
+                send('Subject: ' + (reply.subject || 'freddie'))
+                send('To: ' + reply.to)
+                send('')
+                send(reply.text)
+                send('.')
+                send('QUIT')
+                setTimeout(() => { sock.end(); resolve({ ok: true, log: lines.join('') }) }, 500)
+            })
+        })
+    }
+}

package/plugins/platform-email/plugin.js

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

package/plugins/platform-feishu/handler.js

@@ -0,0 +1,32 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class FeishuAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'feishu'
+        this.token = opts.token || process.env.FEISHU_APP_TOKEN
+        this.port = opts.port || 0
+        this.api = opts.api || "https://open.feishu.cn/open-apis/im/v1/messages"
+        this._server = null
+    }
+    getRequiredEnv() { return ["FEISHU_APP_TOKEN"] }
+    async start() {
+        if (!this.token) throw new Error('FeishuAdapter: ' + 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('FeishuAdapter: 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-feishu/plugin.js

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

package/plugins/platform-feishu_comment/handler.js

@@ -0,0 +1,12 @@
+export async function listComments({ token, docToken }) {
+    const r = await fetch('https://open.feishu.cn/open-apis/comments/v1/files/' + docToken + '/comments', { headers: { authorization: 'Bearer ' + token } })
+    return await r.json()
+}
+export async function postComment({ token, docToken, content }) {
+    const r = await fetch('https://open.feishu.cn/open-apis/comments/v1/files/' + docToken + '/comments', { method: 'POST', headers: { authorization: 'Bearer ' + token, 'content-type': 'application/json' }, body: JSON.stringify({ comment: { content } }) })
+    return await r.json()
+}
+export async function resolveComment({ token, docToken, commentId }) {
+    const r = await fetch('https://open.feishu.cn/open-apis/comments/v1/files/' + docToken + '/comments/' + commentId + '/patch', { method: 'PATCH', headers: { authorization: 'Bearer ' + token, 'content-type': 'application/json' }, body: JSON.stringify({ is_solved: true }) })
+    return await r.json()
+}

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 }) } }