freddie 0.0.47 → 0.0.49

package/plugins/edit/plugin.js

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

package/plugins/env_passthrough/handler.js

@@ -0,0 +1,14 @@
+import { getConfigValue } from '../../src/config.js'
+
+export function buildBashEnv() {
+    const allow = getConfigValue('terminal.env_passthrough', ['HOME', 'USER', 'LANG', 'PATH', 'SHELL']) || []
+    const out = {}
+    for (const k of allow) if (process.env[k]) out[k] = process.env[k]
+    return out
+}
+export const _tool = ({
+    name: 'env_passthrough',
+    toolset: 'core',
+    schema: { name: 'env_passthrough', description: 'Compute the env-var subset that should be passed through to spawned shells.', parameters: { type: 'object', properties: {} } },
+    handler: async () => ({ env: buildBashEnv() }),
+})

package/plugins/env_passthrough/plugin.js

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

package/plugins/feishu_doc/handler.js

@@ -0,0 +1,14 @@
+export const _tool = ({
+    name: 'feishu_doc',
+    toolset: 'core',
+    schema: { name: 'feishu_doc', description: 'Read or update a Feishu doc by token.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['get', 'patch'] }, doc_token: { type: 'string' }, content: {} }, required: ['action', 'doc_token'] } },
+    requiresEnv: ['FEISHU_APP_TOKEN'],
+    checkFn: () => Boolean(process.env.FEISHU_APP_TOKEN),
+    handler: async ({ action, doc_token, content }) => {
+        const auth = { authorization: `Bearer ${process.env.FEISHU_APP_TOKEN}` }
+        const base = 'https://open.feishu.cn/open-apis/docx/v1/documents/' + doc_token
+        if (action === 'get') return await (await fetch(base, { headers: auth })).json()
+        if (action === 'patch') return await (await fetch(base + '/blocks', { method: 'PATCH', headers: { ...auth, 'content-type': 'application/json' }, body: JSON.stringify(content) })).json()
+        return { error: 'unknown action' }
+    },
+})

package/plugins/feishu_doc/plugin.js

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

package/plugins/feishu_drive/handler.js

@@ -0,0 +1,13 @@
+export const _tool = ({
+    name: 'feishu_drive',
+    toolset: 'core',
+    schema: { name: 'feishu_drive', description: 'List or download Feishu Drive files.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['list', 'download'] }, folder_token: { type: 'string' }, file_token: { type: 'string' } }, required: ['action'] } },
+    requiresEnv: ['FEISHU_APP_TOKEN'],
+    checkFn: () => Boolean(process.env.FEISHU_APP_TOKEN),
+    handler: async ({ action, folder_token, file_token }) => {
+        const auth = { authorization: `Bearer ${process.env.FEISHU_APP_TOKEN}` }
+        if (action === 'list') return await (await fetch('https://open.feishu.cn/open-apis/drive/v1/files?folder_token=' + (folder_token || ''), { headers: auth })).json()
+        if (action === 'download') return await (await fetch(`https://open.feishu.cn/open-apis/drive/v1/files/${file_token}/download`, { headers: auth })).json()
+        return { error: 'unknown action' }
+    },
+})

package/plugins/feishu_drive/plugin.js

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

package/plugins/file_operations/handler.js

@@ -0,0 +1,15 @@
+import fs from 'node:fs'
+import path from 'node:path'
+const ACTIONS = {
+    move: ({ src, dest }) => { fs.mkdirSync(path.dirname(dest), { recursive: true }); fs.renameSync(src, dest); return { moved: dest } },
+    copy: ({ src, dest }) => { fs.mkdirSync(path.dirname(dest), { recursive: true }); fs.copyFileSync(src, dest); return { copied: dest } },
+    delete: ({ path: p }) => { if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true }); return { deleted: p } },
+    mkdir: ({ path: p }) => { fs.mkdirSync(p, { recursive: true }); return { created: p } },
+    stat: ({ path: p }) => { const s = fs.statSync(p); return { size: s.size, mtime: s.mtimeMs, isDir: s.isDirectory() } },
+}
+export const _tool = ({
+    name: 'file_operations',
+    toolset: 'core',
+    schema: { name: 'file_operations', description: 'move/copy/delete/mkdir/stat — atomic file ops.', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, src: { type: 'string' }, dest: { type: 'string' }, path: { type: 'string' } }, required: ['action'] } },
+    handler: async (a) => { const fn = ACTIONS[a.action]; try { return fn ? fn(a) : { error: 'unknown action' } } catch (e) { return { error: String(e.message || e) } } },
+})

package/plugins/file_operations/plugin.js

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

package/plugins/file_state/handler.js

@@ -0,0 +1,14 @@
+import { db } from '../../src/db.js'
+async function init() { const d = await db(); await d.exec(`CREATE TABLE IF NOT EXISTS file_state (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, file_path TEXT NOT NULL, action TEXT NOT NULL, ts INTEGER NOT NULL)`); return d }
+export const _tool = ({
+    name: 'file_state',
+    toolset: 'core',
+    schema: { name: 'file_state', description: 'Track files modified in this session (read|write|edit|delete) for diff-summary purposes.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['record', 'list', 'changed_in_session'] }, session_id: { type: 'string' }, file_path: { type: 'string' }, op: { type: 'string' } }, required: ['action'] } },
+    handler: async ({ action, session_id, file_path, op }) => {
+        const d = await init()
+        if (action === 'record') { await d.prepare('INSERT INTO file_state (session_id, file_path, action, ts) VALUES (?, ?, ?, ?)').run(session_id, file_path, op, Date.now()); return { recorded: true } }
+        if (action === 'list') return { items: await d.prepare('SELECT * FROM file_state WHERE session_id = ? ORDER BY id DESC').all(session_id) }
+        if (action === 'changed_in_session') return { files: [...new Set((await d.prepare('SELECT file_path FROM file_state WHERE session_id = ?').all(session_id)).map(r => r.file_path))] }
+        return { error: 'unknown action' }
+    },
+})

package/plugins/file_state/plugin.js

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

package/plugins/file_tools/handler.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs'
+import path from 'node:path'
+function walk(dir, out, skip) {
+    let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch { return }
+    for (const e of entries) {
+        if (skip.has(e.name)) continue
+        const full = path.join(dir, e.name)
+        if (e.isDirectory()) walk(full, out, skip)
+        else out.push(full)
+    }
+}
+export const _tool = ({
+    name: 'file_tools',
+    toolset: 'core',
+    schema: { name: 'file_tools', description: 'list/glob files (recursive walk skipping node_modules, .git, dist).', parameters: { type: 'object', properties: { dir: { type: 'string', default: '.' }, ext: { type: 'string' }, limit: { type: 'number', default: 1000 } } } },
+    handler: async ({ dir = '.', ext, limit = 1000 }) => {
+        const out = []; walk(dir, out, new Set(['node_modules', '.git', 'dist', '.cache', 'build']))
+        const filtered = ext ? out.filter(f => f.endsWith(ext)) : out
+        return { files: filtered.slice(0, limit), total: filtered.length, truncated: filtered.length > limit }
+    },
+})

package/plugins/file_tools/plugin.js

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

package/plugins/fuzzy_match/handler.js

@@ -0,0 +1,7 @@
+import { fuzzyMatch as helper } from '../../src/utils.js'
+export const _tool = ({
+    name: 'fuzzy_match',
+    toolset: 'core',
+    schema: { name: 'fuzzy_match', description: 'Score a candidate string against a needle. Returns 0 for no match, higher for better match.', parameters: { type: 'object', properties: { needle: { type: 'string' }, haystack: { type: 'string' } }, required: ['needle', 'haystack'] } },
+    handler: async ({ needle, haystack }) => ({ score: helper(needle, haystack) }),
+})

package/plugins/fuzzy_match/plugin.js

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

package/plugins/gm-cc/plugin.js

@@ -0,0 +1,28 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+
+const _require = createRequire(import.meta.url);
+const gmCcBase = path.dirname(_require.resolve('gm-cc/package.json'));
+
+export default {
+    name: 'gm-cc',
+    surfaces: 'pi',
+    register({ pi }) {
+        const skillsDir = path.join(gmCcBase, 'skills');
+        if (!fs.existsSync(skillsDir)) return;
+        for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+            const skillMd = entry.isDirectory()
+                ? path.join(skillsDir, entry.name, 'SKILL.md')
+                : entry.name.endsWith('.md') ? path.join(skillsDir, entry.name) : null;
+            if (!skillMd || !fs.existsSync(skillMd)) continue;
+            const raw = fs.readFileSync(skillMd, 'utf8');
+            const nameMatch = raw.match(/^name:\s*(.+)$/m);
+            const descMatch = raw.match(/^description:\s*(.+)$/m);
+            const name = nameMatch ? nameMatch[1].trim() : entry.name.replace(/\.md$/, '');
+            const description = descMatch ? descMatch[1].trim() : '';
+            pi.skills.register({ name: 'gm:' + name, description, content: raw, source: 'gm-cc' });
+        }
+    },
+};

package/plugins/grep/handler.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs'
+import path from 'node:path'
+export const _tool = ({
+    name: 'grep',
+    toolset: 'core',
+    schema: {
+        name: 'grep',
+        description: 'Recursive regex search across files. Returns file:line:content matches.',
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string' },
+                path: { type: 'string', default: '.' },
+                glob: { type: 'string' },
+                head_limit: { type: 'number', default: 200 },
+                ignore_case: { type: 'boolean', default: false },
+            },
+            required: ['pattern'],
+        },
+    },
+    handler: async ({ pattern, path: root = '.', head_limit = 200, ignore_case = false, glob }) => {
+        const re = new RegExp(pattern, ignore_case ? 'i' : '')
+        const out = []
+        const skipDirs = new Set(['node_modules', '.git', 'dist', 'build', '.cache'])
+        const walk = (d) => {
+            if (out.length >= head_limit) return
+            let entries
+            try { entries = fs.readdirSync(d, { withFileTypes: true }) } catch { return }
+            for (const e of entries) {
+                if (out.length >= head_limit) return
+                const full = path.join(d, e.name)
+                if (e.isDirectory()) { if (!skipDirs.has(e.name)) walk(full); continue }
+                if (glob && !matchGlob(e.name, glob)) continue
+                let content
+                try { content = fs.readFileSync(full, 'utf8') } catch { continue }
+                content.split('\n').forEach((line, i) => {
+                    if (out.length < head_limit && re.test(line)) out.push(`${full}:${i + 1}:${line.slice(0, 200)}`)
+                })
+            }
+        }
+        walk(root)
+        return { matches: out, total: out.length, truncated: out.length >= head_limit }
+    },
+})
+
+function matchGlob(name, glob) {
+    const re = new RegExp('^' + glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i')
+    return re.test(name)
+}

package/plugins/grep/plugin.js

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

package/plugins/gui-agents/plugin.js

@@ -0,0 +1,26 @@
+import { bootHost } from '../../src/host/index.js'
+
+export default {
+    name: 'gui-agents', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('GET', '/api/agents', async (req, res) => {
+            try {
+                const host = await bootHost()
+                const sessions = await (await import('../../src/sessions.js')).listSessions()
+                const activeSessions = sessions.filter(s => {
+                    const updated = new Date(s.updated_at || 0)
+                    const now = new Date()
+                    return (now - updated) < 300000
+                })
+                res.json({
+                    count: activeSessions.length,
+                    active: activeSessions.length > 0 ? activeSessions[0].id : null,
+                    turns: sessions.reduce((acc, s) => acc + (s.turn_count || 0), 0),
+                    last_activity: activeSessions.length > 0 ? activeSessions[0].updated_at : null,
+                })
+            } catch (e) {
+                res.status(500).json({ error: String(e.message || e) })
+            }
+        })
+    },
+}

package/plugins/gui-batch/plugin.js

@@ -0,0 +1,11 @@
+import { runBatch } from '../../src/batch.js'
+export default {
+    name: 'gui-batch', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('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) }) }
+        })
+    },
+}

package/plugins/gui-chat/plugin.js

@@ -0,0 +1,21 @@
+import { runTurn } from '../../src/agent/machine.js'
+export default {
+    name: 'gui-chat', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('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()
+        })
+    },
+}

package/plugins/gui-config/plugin.js

@@ -0,0 +1,12 @@
+import { loadConfig, saveConfigValue } from '../../src/config.js'
+export default {
+    name: 'gui-config', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('GET', '/api/config', (_, res) => res.json(loadConfig()))
+        gui.route('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) }) }
+        })
+    },
+}

package/plugins/gui-cron/plugin.js

@@ -0,0 +1,13 @@
+import { listJobs, createJob, deleteJob } from '../../src/cron/scheduler.js'
+export default {
+    name: 'gui-cron', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('GET', '/api/cron', async (_, res) => res.json(await listJobs()))
+        gui.route('POST', '/api/cron', async (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: await createJob({ cron, prompt, model }) }) } catch (e) { res.status(400).json({ error: String(e.message || e) }) }
+        })
+        gui.route('DELETE', '/api/cron/:id', async (req, res) => { await deleteJob(Number(req.params.id)); res.json({ ok: true }) })
+    },
+}

package/plugins/gui-debug/plugin.js

@@ -0,0 +1,24 @@
+import path from 'node:path'
+import fs from 'node:fs'
+import { listDebug, snapshotAll, attachDebugRoutes } from '../../src/observability/debug.js'
+import { getFreddieHome } from '../../src/home.js'
+export default {
+    name: 'gui-debug', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('GET', '/api/debug', (_, res) => res.json(listDebug()))
+        gui.route('GET', '/api/debug-all', (_, res) => res.json(snapshotAll()))
+        gui.route('GET', '/api/logs', (_, res) => {
+            const dir = path.join(getFreddieHome(), 'logs')
+            if (!fs.existsSync(dir)) return res.json([])
+            res.json(fs.readdirSync(dir).filter(f => f.endsWith('.log')).map(f => f.replace(/\.log$/, '')))
+        })
+        gui.route('GET', '/api/logs/:subsystem', (req, res) => {
+            const file = path.join(getFreddieHome(), 'logs', req.params.subsystem + '.log')
+            if (!fs.existsSync(file)) return res.json([])
+            const max = Number(req.query.max) || 200
+            const lines = fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean).slice(-max)
+            res.json(lines.map(l => { try { return JSON.parse(l) } catch { return { raw: l } } }))
+        })
+        gui.api('debug', { attach: attachDebugRoutes })
+    },
+}

package/plugins/gui-env/plugin.js

@@ -0,0 +1,7 @@
+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']
+export default {
+    name: 'gui-env', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('GET', '/api/env', (_, res) => res.json(ENV_KEYS.map(k => ({ key: k, set: !!process.env[k] }))))
+    },
+}

package/plugins/gui-gateway/plugin.js

@@ -0,0 +1,9 @@
+export default {
+    name: 'gui-gateway', surfaces: 'gui',
+    register({ gui, host }) {
+        gui.route('GET', '/api/gateway', (_, res) => {
+            const platforms = host.pi.platforms.list().map(p => p.name)
+            res.json({ platforms: platforms.map(p => ({ name: p, enabled: false, note: 'start with freddie gateway --port <port>' })) })
+        })
+    },
+}

package/plugins/gui-profiles-commands-health/plugin.js

@@ -0,0 +1,11 @@
+import { listAllProfiles } from '../../src/commands/profile.js'
+import { COMMAND_REGISTRY } from '../../src/commands/registry.js'
+import { getFreddieHome } from '../../src/home.js'
+export default {
+    name: 'gui-profiles-commands-health', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('GET', '/api/profiles', (_, res) => res.json(listAllProfiles()))
+        gui.route('GET', '/api/commands', (_, res) => res.json(COMMAND_REGISTRY))
+        gui.route('GET', '/api/health', (_, res) => res.json({ ok: true, ts: Date.now(), freddie_home: getFreddieHome() }))
+    },
+}

package/plugins/gui-sessions/plugin.js

@@ -0,0 +1,9 @@
+import { listSessions, search, getMessages } from '../../src/sessions.js'
+export default {
+    name: 'gui-sessions', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('GET', '/api/sessions', async (_, res) => res.json(await listSessions()))
+        gui.route('GET', '/api/sessions/:id/messages', async (req, res) => res.json(await getMessages(req.params.id)))
+        gui.route('GET', '/api/search', async (req, res) => res.json(await search(String(req.query.q || ''))))
+    },
+}

package/plugins/gui-skills/plugin.js

@@ -0,0 +1,8 @@
+import path from 'node:path'
+import { listSkills } from '../../src/skills/index.js'
+export default {
+    name: 'gui-skills', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('GET', '/api/skills', (_, res) => res.json({ home: listSkills(), bundled: listSkills([path.resolve('skills')]) }))
+    },
+}

package/plugins/gui-tools/plugin.js

@@ -0,0 +1,7 @@
+export default {
+    name: 'gui-tools', surfaces: 'gui',
+    register({ gui, host }) {
+        gui.route('GET', '/api/tools', (_, res) => res.json(host.pi.tools.list().map(t => ({ name: t.name, toolset: t.toolset, schema: t.schema }))))
+        gui.route('GET', '/api/tools/detail', (_, res) => res.json(host.pi.tools.list().map(t => ({ name: t.name, toolset: t.toolset, description: t.schema?.description || '' }))))
+    },
+}

package/plugins/homeassistant_tool/handler.js

@@ -0,0 +1,14 @@
+export const _tool = ({
+    name: 'homeassistant_tool',
+    toolset: 'core',
+    schema: { name: 'homeassistant_tool', description: 'Read state or call a service on Home Assistant.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['state', 'service'] }, entity_id: { type: 'string' }, domain: { type: 'string' }, service: { type: 'string' }, data: {} }, required: ['action'] } },
+    requiresEnv: ['HASS_TOKEN', 'HASS_URL'],
+    checkFn: () => Boolean(process.env.HASS_TOKEN),
+    handler: async ({ action, entity_id, domain, service, data = {} }) => {
+        const url = process.env.HASS_URL || 'http://homeassistant.local:8123'
+        const auth = { authorization: `Bearer ${process.env.HASS_TOKEN}` }
+        if (action === 'state') return await (await fetch(`${url}/api/states/${entity_id}`, { headers: auth })).json()
+        if (action === 'service') return await (await fetch(`${url}/api/services/${domain}/${service}`, { method: 'POST', headers: { ...auth, 'content-type': 'application/json' }, body: JSON.stringify({ entity_id, ...data }) })).json()
+        return { error: 'unknown action' }
+    },
+})

package/plugins/homeassistant_tool/plugin.js

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

package/plugins/image_gen/handler.js

@@ -0,0 +1,31 @@
+export const _tool = ({
+    name: 'image_gen',
+    toolset: 'creative',
+    schema: {
+        name: 'image_gen',
+        description: 'Generate an image from a prompt. Provider via config.image_gen.provider (openai|replicate).',
+        parameters: {
+            type: 'object',
+            properties: {
+                prompt: { type: 'string' },
+                provider: { type: 'string', enum: ['openai', 'replicate'] },
+                size: { type: 'string', default: '1024x1024' },
+                model: { type: 'string' },
+            },
+            required: ['prompt'],
+        },
+    },
+    checkFn: () => Boolean(process.env.OPENAI_API_KEY || process.env.REPLICATE_API_TOKEN),
+    requiresEnv: ['OPENAI_API_KEY or REPLICATE_API_TOKEN'],
+    handler: async ({ prompt, provider, size = '1024x1024', model }) => {
+        const which = provider || (process.env.OPENAI_API_KEY ? 'openai' : 'replicate')
+        if (which === 'openai') {
+            if (!process.env.OPENAI_API_KEY) return { error: 'OPENAI_API_KEY required' }
+            const res = await fetch('https://api.openai.com/v1/images/generations', { method: 'POST', headers: { authorization: `Bearer ${process.env.OPENAI_API_KEY}`, 'content-type': 'application/json' }, body: JSON.stringify({ model: model || 'gpt-image-1', prompt, size }) })
+            return await res.json()
+        }
+        if (!process.env.REPLICATE_API_TOKEN) return { error: 'REPLICATE_API_TOKEN required' }
+        const res = await fetch('https://api.replicate.com/v1/predictions', { method: 'POST', headers: { authorization: `Token ${process.env.REPLICATE_API_TOKEN}`, 'content-type': 'application/json' }, body: JSON.stringify({ version: model || 'black-forest-labs/flux-schnell', input: { prompt } }) })
+        return await res.json()
+    },
+})

package/plugins/image_gen/plugin.js

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

package/plugins/interrupt/handler.js

@@ -0,0 +1,16 @@
+const _flags = new Map()
+export function setInterrupt(sessionId) { _flags.set(sessionId, true) }
+export function isInterrupted(sessionId) { return _flags.get(sessionId) === true }
+export function clearInterrupt(sessionId) { _flags.delete(sessionId) }
+
+export const _tool = ({
+    name: 'interrupt',
+    toolset: 'core',
+    schema: { name: 'interrupt', description: 'Set/clear/check interrupt flag for a session — agent loop polls and exits early.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['set', 'clear', 'check'] }, session_id: { type: 'string' } }, required: ['action', 'session_id'] } },
+    handler: async ({ action, session_id }) => {
+        if (action === 'set') { setInterrupt(session_id); return { interrupted: true } }
+        if (action === 'clear') { clearInterrupt(session_id); return { cleared: true } }
+        if (action === 'check') return { interrupted: isInterrupted(session_id) }
+        return { error: 'unknown action' }
+    },
+})

package/plugins/interrupt/plugin.js

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

package/plugins/managed_tool_gateway/handler.js

@@ -0,0 +1,9 @@
+export const _tool = ({
+    name: 'managed_tool_gateway',
+    toolset: 'core',
+    schema: { name: 'managed_tool_gateway', description: 'Proxy: dispatch any registered tool by name with arguments. Used for tool-level audit and policy interception.', parameters: { type: 'object', properties: { name: { type: 'string' }, arguments: {} }, required: ['name'] } },
+    handler: async ({ name, arguments: args = {} }, ctx = {}) => {
+        if (typeof ctx.audit === 'function') ctx.audit({ name, args })
+        return { result: await registry.dispatch(name, args, ctx) }
+    },
+})

package/plugins/managed_tool_gateway/plugin.js

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

package/plugins/mcp_oauth/handler.js

@@ -0,0 +1,20 @@
+export const _tool = ({
+    name: 'mcp_oauth',
+    toolset: 'core',
+    schema: { name: 'mcp_oauth', description: 'OAuth flow for an MCP server: build authorize URL, exchange code for token.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['authorize_url', 'exchange'] }, server_url: { type: 'string' }, client_id: { type: 'string' }, redirect_uri: { type: 'string' }, code: { type: 'string' }, code_verifier: { type: 'string' } }, required: ['action', 'server_url'] } },
+    handler: async ({ action, server_url, client_id, redirect_uri, code, code_verifier }) => {
+        if (action === 'authorize_url') {
+            const u = new URL(server_url + '/authorize')
+            if (client_id) u.searchParams.set('client_id', client_id)
+            if (redirect_uri) u.searchParams.set('redirect_uri', redirect_uri)
+            u.searchParams.set('response_type', 'code')
+            u.searchParams.set('code_challenge_method', 'S256')
+            return { url: u.toString() }
+        }
+        if (action === 'exchange') {
+            const r = await fetch(server_url + '/token', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ grant_type: 'authorization_code', code, redirect_uri, code_verifier, client_id }).toString() })
+            return await r.json()
+        }
+        return { error: 'unknown action' }
+    },
+})

package/plugins/mcp_oauth/plugin.js

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

package/plugins/mcp_oauth_manager/handler.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFreddieHome } from '../../src/home.js'
+function tokFile(server) { return path.join(getFreddieHome(), 'mcp-tokens', encodeURIComponent(server) + '.json') }
+
+export const _tool = ({
+    name: 'mcp_oauth_manager',
+    toolset: 'core',
+    schema: { name: 'mcp_oauth_manager', description: 'Persist & retrieve MCP OAuth tokens. Actions: store, get, list, delete, refresh.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['store', 'get', 'list', 'delete'] }, server: { type: 'string' }, token: {} }, required: ['action'] } },
+    handler: async ({ action, server, token }) => {
+        const dir = path.join(getFreddieHome(), 'mcp-tokens'); fs.mkdirSync(dir, { recursive: true })
+        if (action === 'store') { fs.writeFileSync(tokFile(server), JSON.stringify({ server, token, ts: Date.now() }), { mode: 0o600 }); return { stored: server } }
+        if (action === 'get') { const f = tokFile(server); return fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, 'utf8')) : { error: 'not found' } }
+        if (action === 'list') return { servers: fs.readdirSync(dir).filter(f => f.endsWith('.json')).map(f => decodeURIComponent(f.replace(/\.json$/, ''))) }
+        if (action === 'delete') { const f = tokFile(server); if (fs.existsSync(f)) fs.unlinkSync(f); return { deleted: server } }
+        return { error: 'unknown action' }
+    },
+})

package/plugins/mcp_oauth_manager/plugin.js

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

package/plugins/mcp_tool/handler.js

@@ -0,0 +1,34 @@
+import { spawn } from 'node:child_process'
+const _clients = new Map()
+
+export const _tool = ({
+    name: 'mcp_tool',
+    toolset: 'core',
+    schema: { name: 'mcp_tool', description: 'Connect to an external MCP server (stdio) and call its tools.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['connect', 'list', 'call', 'disconnect'] }, id: { type: 'string' }, command: { type: 'string' }, args: { type: 'array' }, name: { type: 'string' }, arguments: {} }, required: ['action'] } },
+    handler: async ({ action, id, command, args = [], name, arguments: callArgs = {} }) => {
+        if (action === 'connect') {
+            const cid = id || 'mcp-' + Date.now()
+            const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'pipe'] })
+            _clients.set(cid, { child, nextId: 1, pending: new Map(), buf: '' })
+            const c = _clients.get(cid)
+            child.stdout.on('data', d => {
+                c.buf += d.toString()
+                const lines = c.buf.split('\n'); c.buf = lines.pop()
+                for (const l of lines) { try { const m = JSON.parse(l); const p = c.pending.get(m.id); if (p) { c.pending.delete(m.id); p.resolve(m) } } catch {} }
+            })
+            return { id: cid, connected: true }
+        }
+        const c = _clients.get(id)
+        if (!c) return { error: 'unknown id' }
+        const rpc = (method, params) => new Promise((resolve, reject) => {
+            const rid = c.nextId++
+            c.pending.set(rid, { resolve, reject })
+            c.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: rid, method, params }) + '\n')
+            setTimeout(() => { if (c.pending.has(rid)) { c.pending.delete(rid); reject(new Error('mcp timeout')) } }, 30000)
+        })
+        if (action === 'list') return await rpc('tools/list', {})
+        if (action === 'call') return await rpc('tools/call', { name, arguments: callArgs })
+        if (action === 'disconnect') { try { c.child.kill('SIGTERM') } catch {} _clients.delete(id); return { disconnected: id } }
+        return { error: 'unknown action' }
+    },
+})

package/plugins/mcp_tool/plugin.js

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