freddie 0.0.47 → 0.0.49

package/plugins/memory/handler.js

@@ -0,0 +1,66 @@
+import { db } from '../../src/db.js'
+import { getConfigValue } from '../../src/config.js'
+import { createMemoryProvider } from '../../src/plugins/memory/provider.js'
+
+async function init() {
+    const d = await db()
+    await d.exec(`CREATE TABLE IF NOT EXISTS memory_local (id INTEGER PRIMARY KEY AUTOINCREMENT, content TEXT NOT NULL, ts INTEGER NOT NULL)`)
+    if (!d._fts5_unavailable) {
+        try { await d.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS memory_local_fts USING fts5(content, content='memory_local', content_rowid='id')`) } catch (e) { d._fts5_unavailable = true }
+        try { await d.exec(`CREATE TRIGGER IF NOT EXISTS memory_local_ai AFTER INSERT ON memory_local BEGIN INSERT INTO memory_local_fts(rowid, content) VALUES (new.id, new.content); END`) } catch (e) { d._fts5_unavailable = true }
+    }
+    return d
+}
+
+function provider() {
+    const name = getConfigValue('memory.provider')
+    if (!name) return null
+    try { return createMemoryProvider(name, {}) } catch { return null }
+}
+
+const ACTIONS = {
+    add: async ({ content }) => {
+        if (!content) return { error: 'content required' }
+        const p = provider()
+        if (p) { await p.syncTurn([{ role: 'note', content }]); return { stored: 'remote' } }
+        const d = await init()
+        const info = await d.prepare(`INSERT INTO memory_local (content, ts) VALUES (?, ?)`).run(content, Date.now())
+        return { id: Number(info.lastInsertRowid), stored: 'local' }
+    },
+    search: async ({ query, limit = 10 }) => {
+        const p = provider()
+        if (p) return await p.prefetch(query)
+        const d = await init()
+        const likePattern = `%${query}%`
+        if (d._fts5_unavailable) {
+            const rows = await d.prepare(`SELECT id, content, ts FROM memory_local WHERE content LIKE ? ORDER BY ts DESC LIMIT ?`).all(likePattern, limit)
+            return { items: rows }
+        }
+        try {
+            const rows = await d.prepare(`SELECT m.id, m.content, m.ts FROM memory_local_fts f JOIN memory_local m ON m.id = f.rowid WHERE memory_local_fts MATCH ? ORDER BY rank LIMIT ?`).all(query, limit)
+            return { items: rows }
+        } catch {
+            const rows = await d.prepare(`SELECT id, content, ts FROM memory_local WHERE content LIKE ? ORDER BY ts DESC LIMIT ?`).all(likePattern, limit)
+            return { items: rows }
+        }
+    },
+    list: async () => {
+        const d = await init()
+        return { items: await d.prepare(`SELECT id, content, ts FROM memory_local ORDER BY id DESC LIMIT 50`).all() }
+    },
+}
+
+export const _tool = ({
+    name: 'memory',
+    toolset: 'core',
+    schema: {
+        name: 'memory',
+        description: 'Add/search/list memory. Routes to configured provider or local SQLite fallback.',
+        parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, content: { type: 'string' }, query: { type: 'string' }, limit: { type: 'number' } }, required: ['action'] },
+    },
+    handler: async (args) => {
+        const fn = ACTIONS[args.action]
+        if (!fn) return { error: 'unknown action: ' + args.action }
+        return await fn(args)
+    },
+})

package/plugins/memory/plugin.js

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

package/plugins/memory-byterover/handler.js

@@ -0,0 +1,25 @@
+export class ByteroverMemory {
+    constructor(opts = {}) {
+        this.name = 'byterover'
+        this.apiKey = opts.apiKey || process.env.BYTEROVER_API_KEY
+        this.base = opts.base || "https://api.byterover.com"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["BYTEROVER_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('ByteroverMemory: BYTEROVER_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/plugins/memory-byterover/plugin.js

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

package/plugins/memory-hindsight/handler.js

@@ -0,0 +1,25 @@
+export class HindsightMemory {
+    constructor(opts = {}) {
+        this.name = 'hindsight'
+        this.apiKey = opts.apiKey || process.env.HINDSIGHT_API_KEY
+        this.base = opts.base || "https://api.hindsightai.com"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["HINDSIGHT_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('HindsightMemory: HINDSIGHT_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/plugins/memory-hindsight/plugin.js

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

package/plugins/memory-holographic/handler.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFreddieHome } from '../../src/plugins/../home.js'
+
+export class HolographicMemory {
+    constructor(opts = {}) {
+        this.name = 'holographic'
+        this.dir = opts.dir || path.join(getFreddieHome(), 'memory', 'holographic')
+        fs.mkdirSync(this.dir, { recursive: true })
+    }
+    getRequiredEnv() { return [] }
+    async syncTurn(messages) {
+        const file = path.join(this.dir, Date.now() + '.json')
+        fs.writeFileSync(file, JSON.stringify({ ts: Date.now(), messages }), 'utf8')
+        return { stored: file }
+    }
+    async prefetch(query) {
+        const files = fs.readdirSync(this.dir).filter(f => f.endsWith('.json')).sort().slice(-20)
+        const items = []
+        for (const f of files) {
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(this.dir, f), 'utf8'))
+                const last = data.messages?.slice(-2).map(m => m.content).join(' ') || ''
+                if (!query || last.toLowerCase().includes(String(query).toLowerCase())) items.push({ file: f, summary: last.slice(0, 200) })
+            } catch {}
+        }
+        return { items }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/plugins/memory-holographic/plugin.js

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

package/plugins/memory-honcho/handler.js

@@ -0,0 +1,25 @@
+export class HonchoMemory {
+    constructor(opts = {}) {
+        this.name = 'honcho'
+        this.apiKey = opts.apiKey || process.env.HONCHO_API_KEY
+        this.base = opts.base || "https://api.honcho.dev"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["HONCHO_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('HonchoMemory: HONCHO_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/plugins/memory-honcho/plugin.js

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

package/plugins/memory-mem0/handler.js

@@ -0,0 +1,25 @@
+export class Mem0Memory {
+    constructor(opts = {}) {
+        this.name = 'mem0'
+        this.apiKey = opts.apiKey || process.env.MEM0_API_KEY
+        this.base = opts.base || "https://api.mem0.ai/v1"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["MEM0_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('Mem0Memory: MEM0_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/plugins/memory-mem0/plugin.js

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

package/plugins/memory-openviking/handler.js

@@ -0,0 +1,25 @@
+export class OpenvikingMemory {
+    constructor(opts = {}) {
+        this.name = 'openviking'
+        this.apiKey = opts.apiKey || process.env.OPENVIKING_API_KEY
+        this.base = opts.base || "https://api.openviking.com"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["OPENVIKING_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('OpenvikingMemory: OPENVIKING_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/plugins/memory-openviking/plugin.js

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

package/plugins/memory-retaindb/handler.js

@@ -0,0 +1,25 @@
+export class RetaindbMemory {
+    constructor(opts = {}) {
+        this.name = 'retaindb'
+        this.apiKey = opts.apiKey || process.env.RETAINDB_API_KEY
+        this.base = opts.base || "https://api.retaindb.com"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["RETAINDB_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('RetaindbMemory: RETAINDB_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/plugins/memory-retaindb/plugin.js

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

package/plugins/memory-supermemory/handler.js

@@ -0,0 +1,25 @@
+export class SupermemoryMemory {
+    constructor(opts = {}) {
+        this.name = 'supermemory'
+        this.apiKey = opts.apiKey || process.env.SUPERMEMORY_API_KEY
+        this.base = opts.base || "https://api.supermemory.ai/v3"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["SUPERMEMORY_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('SupermemoryMemory: SUPERMEMORY_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/plugins/memory-supermemory/plugin.js

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

package/plugins/mixture_of_agents/handler.js

@@ -0,0 +1,13 @@
+import { runTurn } from '../../src/agent/machine.js'
+
+export const _tool = ({
+    name: 'mixture_of_agents',
+    toolset: 'core',
+    schema: { name: 'mixture_of_agents', description: 'Run the same prompt through N sub-agents (different models or seeds), then synthesize the results. Reduces variance.', parameters: { type: 'object', properties: { prompt: { type: 'string' }, models: { type: 'array', items: { type: 'string' } }, callLLM: {} }, required: ['prompt'] } },
+    handler: async ({ prompt, models = ['default'] }, ctx = {}) => {
+        const llm = ctx.callLLM || null
+        const runs = await Promise.all(models.map(m => runTurn({ prompt, model: m, callLLM: llm, timeoutMs: 30000 }).catch(e => ({ error: String(e.message || e) }))))
+        const synthesized = runs.map(r => r.result || r.error || '').join('\n---\n')
+        return { runs: runs.length, synthesized }
+    },
+})

package/plugins/mixture_of_agents/plugin.js

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

package/plugins/neutts_synth/handler.js

@@ -0,0 +1,12 @@
+export const _tool = ({
+    name: 'neutts_synth',
+    toolset: 'creative',
+    schema: { name: 'neutts_synth', description: 'Local NeuTTS synth (alternate TTS backend).', parameters: { type: 'object', properties: { text: { type: 'string' }, voice: { type: 'string', default: 'default' } }, required: ['text'] } },
+    requiresEnv: ['NEUTTS_URL'],
+    checkFn: () => Boolean(process.env.NEUTTS_URL),
+    handler: async ({ text, voice = 'default' }) => {
+        if (!process.env.NEUTTS_URL) return { error: 'NEUTTS_URL required' }
+        const r = await fetch(process.env.NEUTTS_URL + '/synthesize', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ text, voice }) })
+        return { status: r.status, bytes: (await r.arrayBuffer()).byteLength }
+    },
+})

package/plugins/neutts_synth/plugin.js

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

package/plugins/openrouter_client/handler.js

@@ -0,0 +1,12 @@
+export const _tool = ({
+    name: 'openrouter',
+    toolset: 'core',
+    schema: { name: 'openrouter', description: 'Chat completion via OpenRouter (any model).', parameters: { type: 'object', properties: { prompt: { type: 'string' }, model: { type: 'string', default: 'anthropic/claude-sonnet-4' } }, required: ['prompt'] } },
+    requiresEnv: ['OPENROUTER_API_KEY'],
+    checkFn: () => Boolean(process.env.OPENROUTER_API_KEY),
+    handler: async ({ prompt, model = 'anthropic/claude-sonnet-4' }) => {
+        if (!process.env.OPENROUTER_API_KEY) return { error: 'OPENROUTER_API_KEY required' }
+        const r = await fetch('https://openrouter.ai/api/v1/chat/completions', { method: 'POST', headers: { authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`, 'content-type': 'application/json' }, body: JSON.stringify({ model, messages: [{ role: 'user', content: prompt }] }) })
+        return await r.json()
+    },
+})

package/plugins/openrouter_client/plugin.js

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

package/plugins/osv_check/handler.js

@@ -0,0 +1,10 @@
+export const _tool = ({
+    name: 'osv_check',
+    toolset: 'core',
+    schema: { name: 'osv_check', description: 'Query osv.dev for known vulnerabilities. Pass either {package, version, ecosystem} or {commit_sha, repo}.', parameters: { type: 'object', properties: { package: { type: 'string' }, version: { type: 'string' }, ecosystem: { type: 'string' }, commit_sha: { type: 'string' } } } },
+    handler: async (args) => {
+        const body = args.commit_sha ? { commit: args.commit_sha } : { package: { name: args.package, ecosystem: args.ecosystem || 'npm' }, version: args.version }
+        const r = await fetch('https://api.osv.dev/v1/query', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
+        return await r.json()
+    },
+})

package/plugins/osv_check/plugin.js

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

package/plugins/patch_parser/handler.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs'
+import path from 'node:path'
+export function applyUnifiedDiff(diff, { cwd = process.cwd() } = {}) {
+    const lines = diff.split('\n')
+    const results = []
+    let curFile = null, curHunks = [], curHunk = null
+    const flush = () => {
+        if (!curFile) return
+        const file = path.join(cwd, curFile)
+        if (!fs.existsSync(file)) { results.push({ file: curFile, error: 'not found' }); curFile = null; curHunks = []; return }
+        let src = fs.readFileSync(file, 'utf8').split('\n')
+        for (const h of curHunks) {
+            const before = src.slice(0, h.start)
+            const after = src.slice(h.start + h.removed)
+            src = [...before, ...h.added, ...after]
+        }
+        fs.writeFileSync(file, src.join('\n'), 'utf8')
+        results.push({ file: curFile, applied: curHunks.length })
+        curFile = null; curHunks = []
+    }
+    for (const l of lines) {
+        if (l.startsWith('--- ')) { flush(); curFile = l.slice(6).trim() }
+        else if (l.startsWith('+++ ')) {}
+        else if (l.startsWith('@@ ')) {
+            const m = l.match(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/)
+            if (m) { curHunk = { start: Number(m[1]) - 1, removed: Number(m[2]), added: [] }; curHunks.push(curHunk) }
+        } else if (curHunk) {
+            if (l.startsWith('+')) curHunk.added.push(l.slice(1))
+            else if (l.startsWith(' ')) curHunk.added.push(l.slice(1))
+        }
+    }
+    flush()
+    return results
+}
+export const _tool = ({
+    name: 'patch_parser',
+    toolset: 'core',
+    schema: { name: 'patch_parser', description: 'Apply a unified diff to files in cwd. Returns per-file results.', parameters: { type: 'object', properties: { diff: { type: 'string' }, cwd: { type: 'string' } }, required: ['diff'] } },
+    handler: async ({ diff, cwd }) => ({ results: applyUnifiedDiff(diff, { cwd }) }),
+})

package/plugins/patch_parser/plugin.js

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

package/plugins/path_security/handler.js

@@ -0,0 +1,14 @@
+import path from 'node:path'
+const FORBIDDEN = ['/etc/passwd', '/etc/shadow', '/.ssh/', '/.aws/', 'C:\\Windows\\System32']
+export function isPathSafe(p, { cwd = process.cwd() } = {}) {
+    const abs = path.resolve(cwd, p)
+    for (const bad of FORBIDDEN) if (abs.includes(bad)) return { safe: false, reason: 'forbidden: ' + bad }
+    if (abs.includes('..')) return { safe: false, reason: 'parent reference in resolved path' }
+    return { safe: true, abs }
+}
+export const _tool = ({
+    name: 'path_security',
+    toolset: 'core',
+    schema: { name: 'path_security', description: 'Check whether a path is allowed (no /etc/passwd, no .ssh/, etc).', parameters: { type: 'object', properties: { path: { type: 'string' }, cwd: { type: 'string' } }, required: ['path'] } },
+    handler: async ({ path: p, cwd }) => isPathSafe(p, { cwd }),
+})

package/plugins/path_security/plugin.js

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

package/plugins/platform-api_server/handler.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/plugins/platform-api_server/plugin.js

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

package/plugins/platform-bluebubbles/handler.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/plugins/platform-bluebubbles/plugin.js

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

package/plugins/platform-dingtalk/handler.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/plugins/platform-dingtalk/plugin.js

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

package/plugins/platform-discord/handler.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/plugins/platform-discord/plugin.js

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