freddie 0.0.41 → 0.0.42

package/src/plugins/memory/provider.js

@@ -1,35 +1,35 @@
-import { HonchoMemory, Mem0Memory, SupermemoryMemory, ByteroverMemory, HindsightMemory, HolographicMemory, OpenvikingMemory, RetaindbMemory } from './_index.js'
+import { host, bootHost } from '../../host/index.js'
 
-const _registered = new Map()
+const _custom = new Map()
 
-export class MemoryProvider {
-    constructor(opts = {}) { this.opts = opts; this.name = 'base' }
-    async syncTurn(_messages) { throw new Error('syncTurn not implemented') }
-    async prefetch(_query) { throw new Error('prefetch not implemented') }
-    async shutdown() {}
-    async postSetup(_home, _config) {}
-    getRequiredEnv() { return [] }
+function ensureBoot() {
+    const h = host()
+    return h.pi && h.pi.memory.size() > 0 ? h : bootHost()
 }
 
-export function registerMemoryProvider(name, factory) { _registered.set(name, factory) }
-export function listMemoryProviders() { return [..._registered.keys()] }
-export function createMemoryProvider(name, opts) {
-    const factory = _registered.get(name)
-    if (!factory) throw new Error(`unknown memory provider: ${name}. Available: ${[..._registered.keys()].join(',') || 'none'}`)
-    return factory(opts)
+export function listMemoryProviders() {
+    const h = host()
+    const names = (h.pi && h.pi.memory) ? h.pi.memory.list().map(m => m.name) : []
+    return [...new Set([...names, ..._custom.keys()])]
 }
 
-const PROVIDERS = {
-    honcho: HonchoMemory,
-    mem0: Mem0Memory,
-    supermemory: SupermemoryMemory,
-    byterover: ByteroverMemory,
-    hindsight: HindsightMemory,
-    holographic: HolographicMemory,
-    openviking: OpenvikingMemory,
-    retaindb: RetaindbMemory,
+export function createMemoryProvider(name, opts = {}) {
+    if (_custom.has(name)) return new (_custom.get(name))(opts)
+    const h = host()
+    const rec = h.pi?.memory.get(name)
+    if (!rec) throw new Error(`memory provider not found: ${name}. Boot host first or register a provider class.`)
+    const mod = rec.module || {}
+    const cls = Object.values(mod).find(v => typeof v === 'function' && /Memory$/.test(v.name)) || Object.values(mod).find(v => typeof v === 'function')
+    if (!cls) throw new Error(`memory provider ${name}: no class exported`)
+    return new cls(opts)
 }
 
-for (const [name, Cls] of Object.entries(PROVIDERS)) {
-    registerMemoryProvider(name, (opts) => new Cls(opts))
+export function registerMemoryProvider(name, cls) { _custom.set(name, cls) }
+
+export class MemoryProvider {
+    constructor(opts = {}) { Object.assign(this, opts) }
+    async syncTurn() {}
+    async prefetch() { return { items: [] } }
 }
+
+export async function ensureProvidersLoaded() { await ensureBoot() }

package/src/plugins/observability/index.js

@@ -4,9 +4,9 @@ const _counters = new Map()
 export function inc(name, delta = 1) { _counters.set(name, (_counters.get(name) || 0) + delta) }
 export function counters() { return Object.fromEntries(_counters) }
 export function metricsText() {
-    const lines = ['# HELP foph_counter generic counter', '# TYPE foph_counter counter']
-    for (const [name, value] of _counters) lines.push(`foph_counter{name="${name}"} ${value}`)
-    for (const sub of listDebug()) lines.push(`foph_subsystem{name="${sub}"} 1`)
+    const lines = ['# HELP freddie_counter generic counter', '# TYPE freddie_counter counter']
+    for (const [name, value] of _counters) lines.push(`freddie_counter{name="${name}"} ${value}`)
+    for (const sub of listDebug()) lines.push(`freddie_subsystem{name="${sub}"} 1`)
     return lines.join('\n') + '\n'
 }
 export const plugin = {

package/src/skills/index.js

@@ -2,12 +2,12 @@ import fs from 'node:fs'
 import path from 'node:path'
 import yaml from 'js-yaml'
 import os from 'node:os'
-import { getFophHome } from '../home.js'
+import { getFreddieHome } from '../home.js'
 
 const FRONTMATTER = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/
 
 export function listSkills(extraDirs = []) {
-    const dirs = [path.join(getFophHome(), 'skills'), path.join(process.cwd(), 'skills'), ...extraDirs]
+    const dirs = [path.join(getFreddieHome(), 'skills'), path.join(process.cwd(), 'skills'), ...extraDirs]
     const out = []
     for (const d of dirs) {
         if (!fs.existsSync(d)) continue

package/src/skin/engine.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import yaml from 'js-yaml'
-import { getFophHome } from '../home.js'
+import { getFreddieHome } from '../home.js'
 import { getConfigValue, saveConfigValue } from '../config.js'
 
 const _BUILTIN_SKINS = {
@@ -38,7 +38,7 @@ const _BUILTIN_SKINS = {
 let _active = null
 
 export function loadSkin(name) {
-    const userPath = path.join(getFophHome(), 'skins', `${name}.yaml`)
+    const userPath = path.join(getFreddieHome(), 'skins', `${name}.yaml`)
     if (fs.existsSync(userPath)) {
         const fromYaml = yaml.load(fs.readFileSync(userPath, 'utf8')) || {}
         return mergeWithDefault(fromYaml)

package/src/toolsets.js

@@ -1,26 +1,24 @@
-import { registry, discoverBuiltinTools } from './tools/registry.js'
+import { bootHost } from './host/index.js'
 
 export const _FREDDIE_CORE_TOOLS = ['bash', 'read', 'write', 'edit', 'grep']
 
+function available(host) {
+    return host.pi.tools.list().filter(t => !t.checkFn || t.checkFn(t) !== false)
+}
+
 export async function getEnabledToolSchemas(enabled = ['core'], disabled = []) {
-    await discoverBuiltinTools()
-    const all = registry.available()
-    const enabledSet = new Set(enabled)
-    const disabledSet = new Set(disabled)
-    return all.filter(t => enabledSet.has(t.toolset) && !disabledSet.has(t.name)).map(t => t.schema)
+    const h = await bootHost()
+    const enabledSet = new Set(enabled); const disabledSet = new Set(disabled)
+    return available(h).filter(t => enabledSet.has(t.toolset || 'core') && !disabledSet.has(t.name)).map(t => t.schema)
 }
 
 export async function getEnabledToolNames(enabled = ['core'], disabled = []) {
-    await discoverBuiltinTools()
-    const all = registry.available()
-    const enabledSet = new Set(enabled)
-    const disabledSet = new Set(disabled)
-    return all.filter(t => enabledSet.has(t.toolset) && !disabledSet.has(t.name)).map(t => t.name)
+    const h = await bootHost()
+    const enabledSet = new Set(enabled); const disabledSet = new Set(disabled)
+    return available(h).filter(t => enabledSet.has(t.toolset || 'core') && !disabledSet.has(t.name)).map(t => t.name)
 }
 
 export async function getAvailableToolsets() {
-    await discoverBuiltinTools()
-    const ts = new Set()
-    for (const t of registry.list()) ts.add(t.toolset)
-    return [...ts]
+    const h = await bootHost()
+    return [...new Set(h.pi.tools.list().map(t => t.toolset || 'core'))]
 }

package/src/web/index.html

@@ -3,7 +3,7 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>Foph Dashboard</title>
+<title>Freddie Dashboard</title>
 <link rel="preconnect" href="https://fonts.googleapis.com" crossorigin>
 <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Nunito:wght@400;600&family=Archivo+Black&family=JetBrains+Mono:wght@400;500&display=swap">
 <script type="importmap">

package/src/web/server.js

@@ -1,108 +1,22 @@
 import express from 'express'
 import path from 'node:path'
-import fs from 'node:fs'
 import { fileURLToPath } from 'node:url'
-import { listSessions, search, getMessages } from '../sessions.js'
-import { registry, discoverBuiltinTools } from '../tools/registry.js'
-import { listDebug, snapshot, snapshotAll, attachDebugRoutes } from '../observability/debug.js'
-import { loadConfig, saveConfigValue } from '../config.js'
-import { listJobs, createJob, deleteJob } from '../cron/scheduler.js'
-import { listSkills } from '../skills/index.js'
-import { listAllProfiles } from '../commands/profile.js'
-import { COMMAND_REGISTRY } from '../commands/registry.js'
-import { getFophHome } from '../home.js'
-import { runTurn } from '../agent/machine.js'
-import { runBatch } from '../batch.js'
+import { bootHost } from '../host/index.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
-const ENV_KEYS = [
-    'ANTHROPIC_API_KEY','OPENAI_API_KEY','GROQ_API_KEY','OPENROUTER_API_KEY',
-    'TELEGRAM_BOT_TOKEN','DISCORD_BOT_TOKEN','SLACK_BOT_TOKEN','SLACK_SIGNING_SECRET',
-    'WHATSAPP_API_TOKEN','SIGNAL_CLI_URL','MATRIX_HOMESERVER','MATTERMOST_URL',
-    'HONCHO_API_KEY','MEM0_API_KEY','SUPERMEMORY_API_KEY','BYTEROVER_API_KEY',
-    'HINDSIGHT_API_KEY','OPENVIKING_API_KEY','RETAINDB_API_KEY','SERPAPI_KEY',
-    'REPLICATE_API_TOKEN','SMTP_HOST','TWILIO_SID','HASS_TOKEN',
-]
-
-function readLogs(subsystem, max = 200) {
-    const file = path.join(getFophHome(), 'logs', `${subsystem}.log`)
-    if (!fs.existsSync(file)) return []
-    const lines = fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean).slice(-max)
-    return lines.map(l => { try { return JSON.parse(l) } catch { return { raw: l } } })
-}
-
 export async function createDashboard({ port = 0 } = {}) {
-    await discoverBuiltinTools()
+    const host = await bootHost()
     const app = express()
     app.use(express.json())
     app.use(express.static(__dirname))
     app.use('/vendor/anentrypoint-design', express.static(path.join(__dirname, '..', '..', 'node_modules', 'anentrypoint-design', 'dist')))
-    app.get('/api/sessions', (_, res) => res.json(listSessions()))
-    app.get('/api/sessions/:id/messages', (req, res) => res.json(getMessages(req.params.id)))
-    app.get('/api/search', (req, res) => res.json(search(String(req.query.q || ''))))
-    app.get('/api/tools', (_, res) => res.json(registry.list().map(t => ({ name: t.name, toolset: t.toolset, schema: t.schema }))))
-    app.get('/api/debug', (_, res) => res.json(listDebug()))
-    app.get('/api/debug-all', (_, res) => res.json(snapshotAll()))
-    app.get('/api/config', (_, res) => res.json(loadConfig()))
-    app.get('/api/cron', (_, res) => res.json(listJobs()))
-    app.get('/api/skills', (_, res) => {
-        const home = listSkills()
-        const bundled = listSkills([path.resolve('skills')])
-        res.json({ home, bundled })
-    })
-    app.get('/api/profiles', (_, res) => res.json(listAllProfiles()))
-    app.get('/api/commands', (_, res) => res.json(COMMAND_REGISTRY))
-    app.get('/api/env', (_, res) => res.json(ENV_KEYS.map(k => ({ key: k, set: !!process.env[k] }))))
-    app.get('/api/logs/:subsystem', (req, res) => res.json(readLogs(req.params.subsystem, Number(req.query.max) || 200)))
-    app.get('/api/logs', (_, res) => {
-        const dir = path.join(getFophHome(), 'logs')
-        if (!fs.existsSync(dir)) return res.json([])
-        res.json(fs.readdirSync(dir).filter(f => f.endsWith('.log')).map(f => f.replace(/\.log$/, '')))
-    })
-    app.get('/api/health', (_, res) => res.json({ ok: true, ts: Date.now(), foph_home: getFophHome() }))
-    app.get('/api/tools/detail', (_, res) => res.json(registry.list().map(t => ({ name: t.name, toolset: t.toolset, description: t.schema?.description || '' }))))
-    app.get('/api/gateway', (_, res) => {
-        const platforms = ['webhook', 'api_server', 'telegram', 'discord', 'slack', 'whatsapp', 'signal', 'matrix',
-            'mattermost', 'email', 'sms', 'mqtt', 'feishu', 'line', 'viber', 'teams', 'wechat', 'rss']
-        res.json({ platforms: platforms.map(p => ({ name: p, enabled: false, note: 'start with freddie gateway --port <port>' })) })
-    })
-    app.post('/api/batch', async (req, res) => {
-        const { prompts = [], concurrency = 4, model = '' } = req.body || {}
-        if (!prompts.length) return res.status(400).json({ error: 'prompts required' })
-        try { res.json(await runBatch({ prompts, concurrency, model })) } catch (e) { res.status(500).json({ error: String(e.message || e) }) }
-    })
-
-    app.post('/api/cron', (req, res) => {
-        const { cron, prompt, model = null } = req.body || {}
-        if (!cron || !prompt) return res.status(400).json({ error: 'cron and prompt required' })
-        try { res.json({ id: createJob({ cron, prompt, model }) }) } catch (e) { res.status(400).json({ error: String(e.message || e) }) }
-    })
-    app.delete('/api/cron/:id', (req, res) => { deleteJob(Number(req.params.id)); res.json({ ok: true }) })
-
-    app.post('/api/config', (req, res) => {
-        const { key, value } = req.body || {}
-        if (!key) return res.status(400).json({ error: 'key required' })
-        try { res.json(saveConfigValue(key, value)) } catch (e) { res.status(400).json({ error: String(e.message || e) }) }
-    })
-
-    app.post('/api/chat', async (req, res) => {
-        const { prompt, sessionId = null } = req.body || {}
-        if (!prompt) return res.status(400).json({ error: 'prompt required' })
-        res.setHeader('Content-Type', 'text/event-stream')
-        res.setHeader('Cache-Control', 'no-cache')
-        res.setHeader('Connection', 'keep-alive')
-        const send = (event, data) => res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`)
-        send('start', { ts: Date.now(), sessionId })
-        try {
-            const out = await runTurn({ prompt, timeoutMs: 30000 })
-            for (const m of out.messages) send('message', m)
-            send('done', { result: out.result || '', iterations: out.iterations })
-        } catch (e) { send('error', { error: String(e.message || e) }) }
-        res.end()
-    })
-
-    attachDebugRoutes(app)
+    for (const r of host.gui.routes.list()) {
+        const verb = r.method.toLowerCase()
+        if (typeof app[verb] === 'function') app[verb](r.path, r.handler)
+    }
+    const debugApi = host.gui._state.apis.get('debug')
+    if (debugApi?.attach) debugApi.attach(app)
     const server = await new Promise(r => { const s = app.listen(port, () => r(s)) })
     const actualPort = server.address().port
     return { server, port: actualPort, url: `http://127.0.0.1:${actualPort}/`, stop: () => new Promise(r => server.close(() => r())) }

package/src/gateway/platforms/api_server.js

@@ -1,21 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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/src/gateway/platforms/mattermost.js

@@ -1,29 +0,0 @@
-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())
-    }
-}