freddie 0.0.41

package/src/cron/scheduler.js

@@ -0,0 +1,63 @@
+import { db } from '../db.js'
+import { parseCron, matches } from './cron-parse.js'
+import { runTurn } from '../agent/machine.js'
+import { logger } from '../observability/log.js'
+
+const log = logger('cron')
+
+let _interval = null
+
+async function init() {
+    const d = await db()
+    await d.exec(`CREATE TABLE IF NOT EXISTS cron_jobs (id INTEGER PRIMARY KEY AUTOINCREMENT, cron TEXT NOT NULL, prompt TEXT NOT NULL, model TEXT, last_run INTEGER, created INTEGER NOT NULL, enabled INTEGER NOT NULL DEFAULT 1)`)
+    return d
+}
+
+export async function createJob({ cron, prompt, model = null }) {
+    parseCron(cron)
+    const d = await init()
+    const info = await d.prepare(`INSERT INTO cron_jobs (cron, prompt, model, created, enabled) VALUES (?, ?, ?, ?, 1)`).run(cron, prompt, model, Date.now())
+    const id = Number(info.lastInsertRowid)
+    log.info('job created', { id, cron })
+    return id
+}
+
+export async function listJobs() {
+    return await (await init()).prepare(`SELECT * FROM cron_jobs ORDER BY id DESC`).all()
+}
+
+export async function cancelJob(id) {
+    await (await init()).prepare(`UPDATE cron_jobs SET enabled = 0 WHERE id = ?`).run(id)
+}
+
+export async function deleteJob(id) {
+    await (await init()).prepare(`DELETE FROM cron_jobs WHERE id = ?`).run(id)
+}
+
+export async function tick(now = new Date(), { callLLM = null } = {}) {
+    const d = await init()
+    const jobs = await d.prepare(`SELECT * FROM cron_jobs WHERE enabled = 1`).all()
+    const fired = []
+    for (const j of jobs) {
+        try {
+            const parsed = parseCron(j.cron)
+            if (!matches(parsed, now)) continue
+            const minuteKey = Math.floor(now.getTime() / 60000)
+            if (j.last_run && Math.floor(j.last_run / 60000) === minuteKey) continue
+            await d.prepare(`UPDATE cron_jobs SET last_run = ? WHERE id = ?`).run(now.getTime(), j.id)
+            fired.push(j)
+            runTurn({ prompt: j.prompt, callLLM }).catch(e => log.error('cron run failed', { id: j.id, err: String(e) }))
+        } catch (e) { log.error('cron tick failed', { id: j.id, err: String(e) }) }
+    }
+    return fired
+}
+
+export function startScheduler({ callLLM = null, intervalMs = 30000 } = {}) {
+    stopScheduler()
+    _interval = setInterval(() => { tick(new Date(), { callLLM }) }, intervalMs)
+    return _interval
+}
+
+export function stopScheduler() {
+    if (_interval) { clearInterval(_interval); _interval = null }
+}

package/src/db.js

@@ -0,0 +1,178 @@
+import path from 'node:path'
+import fs from 'node:fs'
+import { createClient } from '@libsql/client'
+import { getFophHome } from './home.js'
+
+let _db = null
+let _dbPromise = null
+const DB_PATH = () => path.join(getFophHome(), 'state', 'sessions.db')
+const USE_MEMORY_DB = () => process.env.FREDDIE_TEST_DB === 'memory'
+
+export async function db() {
+    if (_db) return _db
+    if (_dbPromise) return await _dbPromise
+
+    _dbPromise = (async () => {
+        let client
+        let dbPath = null
+
+        if (USE_MEMORY_DB()) {
+            // In-memory mode for tests: no file persistence
+            client = createClient({ url: 'file::memory:' })
+        } else {
+            const dir = path.join(getFophHome(), 'state')
+            fs.mkdirSync(dir, { recursive: true })
+            dbPath = DB_PATH()
+            client = createClient({ url: `file:${dbPath}` })
+        }
+
+        _db = new DbAdapter(client, dbPath)
+        _dbPromise = null
+        return _db
+    })()
+
+    return await _dbPromise
+}
+
+class DbAdapter {
+    constructor(client, dbPath) {
+        this.client = client
+        this.dbPath = dbPath
+        this._fts5_unavailable = false
+    }
+
+    prepare(sql) {
+        return new PreparedStatement(this.client, sql)
+    }
+
+    async exec(sql) {
+        try {
+            const statements = sql.split(';').filter(s => s.trim())
+            const results = []
+            for (const stmt of statements) {
+                if (stmt.trim()) {
+                    const result = await this.client.execute({ sql: stmt.trim() })
+                    results.push(result)
+                }
+            }
+            return results
+        } catch (e) {
+            throw e
+        }
+    }
+
+    async run(...args) {
+        const [sql, ...params] = args
+        const result = await this.client.execute({ sql, args: params })
+        return {
+            changes: result.rowsAffected,
+            lastInsertRowid: result.lastInsertRowid ? BigInt(result.lastInsertRowid) : 0n
+        }
+    }
+
+    transaction(fn) {
+        return async (...args) => {
+            try {
+                await this.client.execute('BEGIN TRANSACTION')
+                const result = await fn(...args)
+                await this.client.execute('COMMIT')
+                return result
+            } catch (e) {
+                try {
+                    await this.client.execute('ROLLBACK')
+                } catch (_) {}
+                throw e
+            }
+        }
+    }
+
+    async close() {
+        if (this.client) {
+            await this.client.close()
+            this.client = null
+        }
+    }
+
+    async clearAll() {
+        try {
+            const result = await this.client.execute("SELECT name FROM sqlite_master WHERE type='table'")
+            if (result.rows && result.rows.length > 0) {
+                for (const [tableName] of result.rows) {
+                    try {
+                        await this.client.execute(`DROP TABLE IF EXISTS ${tableName}`)
+                    } catch (e) {
+                        // Ignore drop errors
+                    }
+                }
+            }
+        } catch (e) {
+            // Ignore errors
+        }
+    }
+}
+
+class PreparedStatement {
+    constructor(client, sql) {
+        this.client = client
+        this.sql = sql
+    }
+
+    bind(params = []) {
+        this.params = params
+        return this
+    }
+
+    async run(...params) {
+        const p = Array.isArray(params[0]) ? params[0] : params
+        const result = await this.client.execute({ sql: this.sql, args: p })
+        return {
+            changes: result.rowsAffected,
+            lastInsertRowid: result.lastInsertRowid ? BigInt(result.lastInsertRowid) : 0n
+        }
+    }
+
+    async get(...params) {
+        const p = Array.isArray(params[0]) ? params[0] : params
+        const result = await this.client.execute({ sql: this.sql, args: p })
+        if (!result.rows || result.rows.length === 0) return null
+        const row = result.rows[0]
+        const obj = {}
+        result.columns.forEach((col, i) => {
+            obj[col] = row[i]
+        })
+        return obj
+    }
+
+    async all(...params) {
+        const p = Array.isArray(params[0]) ? params[0] : params
+        const result = await this.client.execute({ sql: this.sql, args: p })
+        if (!result.rows || result.rows.length === 0) return []
+        return result.rows.map(row => {
+            const obj = {}
+            result.columns.forEach((col, i) => {
+                obj[col] = row[i]
+            })
+            return obj
+        })
+    }
+}
+
+export async function closeDb() {
+    if (_db) {
+        await _db.close()
+        _db = null
+    }
+    _dbPromise = null
+}
+
+export async function resetForTests() {
+    // Clear all tables from current db (if open) to clean state
+    if (_db) {
+        await _db.clearAll()
+    }
+    await closeDb()
+
+    // Reset module state for fresh in-memory init
+    _db = null
+    _dbPromise = null
+}

package/src/gateway/base.js

@@ -0,0 +1,13 @@
+import { EventEmitter } from 'node:events'
+export class BasePlatformAdapter extends EventEmitter {
+    constructor(opts = {}) { super(); this.opts = opts; this.platform = opts.platform || 'unknown'; this._running = false }
+    getRequiredEnv() { return [] }
+    isReady() {
+        const need = this.getRequiredEnv()
+        return need.every(e => process.env[e] || this.opts[e.toLowerCase()])
+    }
+    async start() { if (!this.isReady()) throw new Error(this.constructor.name + ': missing env: ' + this.getRequiredEnv().join(', ')); this._running = true }
+    async stop() { this._running = false }
+    async send(_reply) { throw new Error(this.constructor.name + '.send must be overridden') }
+    isRunning() { return this._running }
+}

package/src/gateway/builtin_hooks/boot.js

@@ -0,0 +1,5 @@
+export const bootHook = async (msg) => {
+    if (typeof msg?.text !== 'string') return msg
+    if (msg.text.startsWith('/boot')) return { ...msg, text: msg.text.replace(/^\/boot\s*/, '').trim() || 'hello' }
+    return msg
+}

package/src/gateway/builtin_hooks/broadcast.js

@@ -0,0 +1,3 @@
+const _subscribers = new Set()
+export function addSubscriber(handler) { _subscribers.add(handler); return () => _subscribers.delete(handler) }
+export const broadcastHook = async (reply) => { for (const s of _subscribers) try { s(reply) } catch {} return reply }

package/src/gateway/builtin_hooks/deny.js

@@ -0,0 +1,6 @@
+import { getConfigValue } from '../../config.js'
+export const denyHook = async (msg) => {
+    const list = getConfigValue('gateway.deny_list', []) || []
+    if (msg?.from && list.includes(msg.from)) return { ...msg, denied: true, text: '' }
+    return msg
+}

package/src/gateway/builtin_hooks/index.js

@@ -0,0 +1,17 @@
+export { bootHook } from './boot.js'
+export { presenceInboundHook, isOnline, presenceMap } from './presence.js'
+export { broadcastHook, addSubscriber } from './broadcast.js'
+export { routingHook } from './routing.js'
+export { denyHook } from './deny.js'
+import { bootHook } from './boot.js'
+import { presenceInboundHook } from './presence.js'
+import { broadcastHook } from './broadcast.js'
+import { routingHook } from './routing.js'
+import { denyHook } from './deny.js'
+export function registerBuiltinHooks(gateway) {
+    gateway.addHook('inbound', presenceInboundHook)
+    gateway.addHook('inbound', denyHook)
+    gateway.addHook('inbound', bootHook)
+    gateway.addHook('inbound', routingHook)
+    gateway.addHook('outbound', broadcastHook)
+}

package/src/gateway/builtin_hooks/presence.js

@@ -0,0 +1,4 @@
+const _presence = new Map()
+export const presenceInboundHook = async (msg) => { if (msg?.from) _presence.set(msg.from, Date.now()); return msg }
+export function isOnline(from, withinMs = 5 * 60_000) { const ts = _presence.get(from) || 0; return Date.now() - ts < withinMs }
+export function presenceMap() { return Object.fromEntries(_presence) }

package/src/gateway/builtin_hooks/routing.js

@@ -0,0 +1,7 @@
+import { resolveCommand, getCommand } from '../../commands/registry.js'
+export const routingHook = async (msg) => {
+    if (typeof msg?.text !== 'string' || !msg.text.startsWith('/')) return msg
+    const name = resolveCommand(msg.text)
+    if (!name) return msg
+    return { ...msg, slashCommand: name, slashArgs: msg.text.split(/\s+/).slice(1).join(' '), description: getCommand(name)?.description }
+}

package/src/gateway/helpers.js

@@ -0,0 +1,27 @@
+import crypto from 'node:crypto'
+export function hmacSign(secret, body) { return crypto.createHmac('sha256', secret).update(body).digest('hex') }
+export function hmacVerify(secret, body, signature) {
+    const expected = hmacSign(secret, body)
+    try { return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(String(signature))) } catch { return false }
+}
+export function aesEncrypt(key, plaintext) {
+    const iv = crypto.randomBytes(16)
+    const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key, 'hex').slice(0, 32), iv)
+    return iv.toString('hex') + ':' + cipher.update(plaintext, 'utf8', 'hex') + cipher.final('hex')
+}
+export function aesDecrypt(key, ciphertext) {
+    const [iv, data] = String(ciphertext).split(':')
+    const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(key, 'hex').slice(0, 32), Buffer.from(iv, 'hex'))
+    return decipher.update(data, 'hex', 'utf8') + decipher.final('utf8')
+}
+export function parseSignedQuery(query, secret, sigParam = 'signature') {
+    const sig = query[sigParam]
+    if (!sig) return { valid: false, reason: 'no signature' }
+    const sorted = Object.keys(query).filter(k => k !== sigParam).sort().map(k => k + '=' + query[k]).join('&')
+    return { valid: hmacVerify(secret, sorted, sig), payload: query }
+}
+export function rateLimitWindow(map, key, windowMs = 1000) {
+    const last = map.get(key) || 0; const now = Date.now()
+    if (now - last < windowMs) return { allowed: false, retryIn: windowMs - (now - last) }
+    map.set(key, now); return { allowed: true }
+}

package/src/gateway/platforms/api_server.js

@@ -0,0 +1,21 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class ApiServerAdapter extends EventEmitter {
+    constructor({ port = 0 } = {}) { super(); this.port = port; this._server = null; this._messages = [] }
+    async start() {
+        const app = express()
+        app.use(express.json())
+        app.post('/messages', (req, res) => {
+            const m = { from: req.body?.from || 'api', text: req.body?.text || '', raw: req.body }
+            this.emit('message', m)
+            res.json({ ok: true })
+        })
+        app.get('/messages', (_, res) => res.json(this._messages))
+        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._messages.push(reply) }
+    drain() { const out = [...this._messages]; this._messages.length = 0; return out }
+}

package/src/gateway/platforms/bluebubbles.js

@@ -0,0 +1,32 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class BluebubblesAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'bluebubbles'
+        this.token = opts.token || process.env.BLUEBUBBLES_PASSWORD
+        this.port = opts.port || 0
+        this.api = opts.api || "http://localhost:1234/api/v1/message/text"
+        this._server = null
+    }
+    getRequiredEnv() { return ["BLUEBUBBLES_PASSWORD"] }
+    async start() {
+        if (!this.token) throw new Error('BluebubblesAdapter: ' + 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('BluebubblesAdapter: 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/src/gateway/platforms/dingtalk.js

@@ -0,0 +1,32 @@
+import express from 'express'
+import { EventEmitter } from 'node:events'
+
+export class DingtalkAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'dingtalk'
+        this.token = opts.token || process.env.DINGTALK_ACCESS_TOKEN
+        this.port = opts.port || 0
+        this.api = opts.api || "https://oapi.dingtalk.com/robot/send"
+        this._server = null
+    }
+    getRequiredEnv() { return ["DINGTALK_ACCESS_TOKEN"] }
+    async start() {
+        if (!this.token) throw new Error('DingtalkAdapter: ' + 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('DingtalkAdapter: 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/src/gateway/platforms/discord.js

@@ -0,0 +1,24 @@
+import { EventEmitter } from 'node:events'
+
+export class DiscordAdapter extends EventEmitter {
+    constructor(opts = {}) {
+        super()
+        this.platform = 'discord'
+        this.token = opts.token || process.env.DISCORD_BOT_TOKEN
+        this.api = opts.api || 'https://discord.com/api/v10'
+        this._ws = null
+    }
+    getRequiredEnv() { return ['DISCORD_BOT_TOKEN'] }
+    async start() {
+        if (!this.token) throw new Error('DiscordAdapter: DISCORD_BOT_TOKEN required')
+        const gw = await fetch(`${this.api}/gateway/bot`, { headers: { authorization: `Bot ${this.token}` } }).then(r => r.json())
+        if (!gw.url) throw new Error('DiscordAdapter: gateway lookup failed: ' + JSON.stringify(gw))
+        this.gatewayUrl = gw.url + '/?v=10&encoding=json'
+    }
+    async stop() { try { this._ws?.close?.() } catch {} }
+    async send(reply) {
+        if (!this.token) throw new Error('DiscordAdapter: token required')
+        const url = `${this.api}/channels/${reply.to}/messages`
+        return fetch(url, { method: 'POST', headers: { authorization: `Bot ${this.token}`, 'content-type': 'application/json' }, body: JSON.stringify({ content: reply.text }) }).then(r => r.json())
+    }
+}

package/src/gateway/platforms/email.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/src/gateway/platforms/feishu.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/src/gateway/platforms/feishu_comment.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/src/gateway/platforms/feishu_comment_rules.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/src/gateway/platforms/homeassistant.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/src/gateway/platforms/matrix.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())
+    }
+}