freddie 0.0.57 → 0.0.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -23,7 +23,7 @@
     "floosie": "^0.6.14",
     "gm-cc": "^2.0.727",
     "js-yaml": "^4.1.0",
-    "plugsdk": "^1.0.12",
+    "plugsdk": "^1.0.15",
     "xstate": "^5.31.0",
     "zod": "^4.0.0"
   },

package/src/host/host.js

@@ -1,34 +1,28 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
-import { loadClaudePlugin, createHookDispatcher } from 'plugsdk'
+import { loadClaudePlugin, createHost as createPluginHost } from 'plugsdk'
 import { validatePlugin, topoSort, HOOK_NAMES, PI_VERBS, GUI_VERBS, FREDDIE_TO_NATIVE_HOOK } from './contract.js'
 
-function makePiSurface() {
-    const tools = new Map()
-    const envs = new Map()
-    const commands = new Map()
-    const crons = new Map()
-    const platforms = new Map()
-    const memory = new Map()
-    const skills = new Map()
-    const contexts = new Map()
-    const agentExts = new Map()
-    const cli = new Map()
+function reg(map, kind) {
     return {
-        _state: { tools, envs, commands, crons, platforms, memory, skills, contexts, agentExts, cli },
-        tools: regOf(tools, 'tool'),
-        envs: regOf(envs, 'env'),
-        commands: regOf(commands, 'command'),
-        crons: regOf(crons, 'cron'),
-        platforms: regOf(platforms, 'platform'),
-        memory: regOf(memory, 'memory'),
-        skills: regOf(skills, 'skill'),
-        contexts: regOf(contexts, 'context'),
-        agentExts: regOf(agentExts, 'agentExt'),
-        cli: regOf(cli, 'cli'),
+        register(spec) { if (!spec?.name) throw new Error(`${kind}.name required`); map.set(spec.name, spec) },
+        get: (n) => map.get(n), list: () => [...map.values()], has: (n) => map.has(n), size: () => map.size,
+    }
+}
+
+function makePi() {
+    const m = { tools:new Map(), envs:new Map(), commands:new Map(), crons:new Map(), platforms:new Map(),
+                memory:new Map(), skills:new Map(), contexts:new Map(), agentExts:new Map(), cli:new Map() }
+    return {
+        _state: m,
+        tools: reg(m.tools, 'tool'), envs: reg(m.envs, 'env'),
+        commands: reg(m.commands, 'command'), crons: reg(m.crons, 'cron'),
+        platforms: reg(m.platforms, 'platform'), memory: reg(m.memory, 'memory'),
+        skills: reg(m.skills, 'skill'), contexts: reg(m.contexts, 'context'),
+        agentExts: reg(m.agentExts, 'agentExt'), cli: reg(m.cli, 'cli'),
         async dispatchTool(name, args = {}, ctx = {}) {
-            const t = tools.get(name)
+            const t = m.tools.get(name)
             if (!t) return JSON.stringify({ error: `unknown tool: ${name}` })
             if (t.checkFn && t.checkFn(t) === false) return JSON.stringify({ error: `tool unavailable: ${name}`, requires: t.requiresEnv || [] })
             try { const r = await t.handler(args, ctx); return typeof r === 'string' ? r : JSON.stringify(r) }
@@ -37,60 +31,68 @@ function makePiSurface() {
     }
 }
 
-function regOf(map, kind) {
-    return {
-        register(spec) { if (!spec?.name) throw new Error(`${kind}.name required`); map.set(spec.name, spec) },
-        get(name) { return map.get(name) },
-        list() { return [...map.values()] },
-        has(name) { return map.has(name) },
-        size() { return map.size },
-    }
-}
-
-function makeGuiSurface() {
-    const routes = []
-    const pages = new Map()
-    const nav = []
-    const debugs = new Map()
-    const apis = new Map()
-    const assets = new Map()
+function makeGui() {
+    const r=[], pages=new Map(), nav=[], debugs=new Map(), apis=new Map(), assets=new Map()
     return {
-        _state: { routes, pages, nav, debugs, apis, assets },
-        route(method, path, handler) { routes.push({ method: method.toUpperCase(), path, handler }) },
-        page(slug, def) { pages.set(slug, def) },
-        nav(item) { nav.push(item) },
-        debug(name, snapshotFn) { debugs.set(name, snapshotFn) },
-        api(group, def) { apis.set(group, def) },
-        asset(p, content) { assets.set(p, content) },
-        routes: { list: () => routes },
-        pages: { get: (s) => pages.get(s), list: () => [...pages.values()], has: (s) => pages.has(s) },
-        navItems: { list: () => nav },
-        debugs: { list: () => [...debugs.entries()].map(([name, fn]) => ({ name, snapshot: fn })), get: (n) => debugs.get(n) },
+        _state: { routes:r, pages, nav, debugs, apis, assets },
+        route:(method,p,h)=>r.push({method:method.toUpperCase(),path:p,handler:h}),
+        page:(s,d)=>pages.set(s,d), nav:(i)=>nav.push(i),
+        debug:(n,fn)=>debugs.set(n,fn), api:(g,d)=>apis.set(g,d), asset:(p,c)=>assets.set(p,c),
+        routes:{ list:()=>r }, pages:{ get:(s)=>pages.get(s), list:()=>[...pages.values()], has:(s)=>pages.has(s) },
+        navItems:{ list:()=>nav },
+        debugs:{ list:()=>[...debugs.entries()].map(([n,f])=>({name:n,snapshot:f})), get:(n)=>debugs.get(n) },
     }
 }
 
-function ccPayloadFor(freddieHook, payload) {
-    if (freddieHook === 'preToolCall' || freddieHook === 'postToolCall')
+function ccPayloadFor(name, payload) {
+    if (name === 'preToolCall' || name === 'postToolCall')
         return { tool_name: payload?.name, tool_input: payload?.args || payload?.input, tool_response: payload?.result }
-    if (freddieHook === 'onMessageInbound' || freddieHook === 'onMessageOutbound')
+    if (name === 'onMessageInbound' || name === 'onMessageOutbound')
         return { prompt: payload?.content || payload?.text || '' }
     return payload || {}
 }
 
-function makeHooks(ccPlugins) {
-    const reg = Object.fromEntries(HOOK_NAMES.map(n => [n, []]))
-    const ccDispatch = createHookDispatcher(ccPlugins)
-    return {
-        on(name, fn) {
-            if (!HOOK_NAMES.includes(name)) throw new Error(`unknown hook: ${name}`)
-            reg[name].push(fn)
-        },
+function guard(surface, allowed, name, verbs) {
+    if (allowed) return surface
+    return new Proxy({}, { get(_, key) {
+        if (verbs.includes(String(key))) return () => { throw new Error(`plugin ${name}: surface verb '${String(key)}' not allowed (declared surfaces=${name})`) }
+        return surface[key]
+    } })
+}
+
+function scopedCfg(name, store) {
+    const k = `plugins.${name}`
+    return { get:(kk,d)=>store.get(`${k}.${kk}`,d), set:(kk,v)=>store.set(`${k}.${kk}`,v), all:()=>store.all(k)||{} }
+}
+
+const nullStore = () => { const m=new Map(); return { get:(k,d)=>m.has(k)?m.get(k):d, set:(k,v)=>m.set(k,v), all:(p)=>Object.fromEntries([...m.entries()].filter(([k])=>k.startsWith(p))) } }
+
+export function createHost({ surfaces = ['pi','gui'], configStore = nullStore(), env = process.env } = {}) {
+    const pi = makePi(), gui = makeGui()
+    const binPaths = []
+    const inboundListeners = []
+    const ccHost = createPluginHost({ env, on: {
+        onSkill:        (p, s) => surfaces.includes('pi') && pi.skills.register({ name: p.manifest.name + ':' + s.name, description: s.description, content: s.body, source: 'cc:' + p.manifest.name, frontmatter: s.fields, file: s.file }),
+        onAgent:        (p, a) => surfaces.includes('pi') && pi.agentExts.register({ name: p.manifest.name + ':' + a.name, description: a.description, frontmatter: a.fields, body: a.body, source: 'cc:' + p.manifest.name, file: a.file }),
+        onCommand:      (p, c) => surfaces.includes('pi') && pi.commands.register({ name: p.manifest.name + ':' + c.name, description: c.description, body: c.body, frontmatter: c.fields, source: 'cc:' + p.manifest.name }),
+        onTheme:        (p, t) => surfaces.includes('pi') && pi.contexts.register({ name: 'theme:' + p.manifest.name + ':' + t.slug, description: t.name, theme: t }),
+        onOutputStyle:  (p, o) => surfaces.includes('pi') && pi.contexts.register({ name: 'style:' + p.manifest.name + ':' + o.name, description: o.description, body: o.body, frontmatter: o.fields }),
+        onChannel:      (p, c) => surfaces.includes('pi') && pi.platforms.register({ name: 'cc:' + p.manifest.name + ':' + c.server, server: c.server, userConfig: c.userConfig || {}, source: 'cc:' + p.manifest.name }),
+        onSetting:      (p, s) => { if (s.agent && surfaces.includes('pi') && !pi.agentExts.has('default')) pi.agentExts.register({ name: 'default', target: p.manifest.name + ':' + s.agent }) },
+        onBin:          (_, dir) => binPaths.push(dir),
+        onMcpTool:      (p, server, tool, call) => surfaces.includes('pi') && pi.tools.register({ name: 'cc:' + p.manifest.name + ':' + server + ':' + tool.name, schema: { name: tool.name, description: tool.description || '', parameters: tool.inputSchema || {} }, handler: (args) => call(args) }),
+        onMonitorLine:  (p, mon, line) => { for (const fn of inboundListeners) fn({ source: 'monitor:' + p.manifest.name + ':' + mon.name, text: line }) },
+    } })
+
+    const reg2 = Object.fromEntries(HOOK_NAMES.map(n => [n, []]))
+    const hooks = {
+        on(name, fn) { if (!HOOK_NAMES.includes(name)) throw new Error(`unknown hook: ${name}`); reg2[name].push(fn) },
         async invoke(name, payload) {
             let cur = payload
-            for (const fn of reg[name] || []) cur = (await fn(cur)) ?? cur
+            for (const fn of reg2[name] || []) cur = (await fn(cur)) ?? cur
             const native = FREDDIE_TO_NATIVE_HOOK[name]
-            if (native && ccPlugins.length) {
-                const r = await ccDispatch(native, ccPayloadFor(name, cur))
+            if (native && ccHost.plugins().length) {
+                const r = await ccHost.dispatch(native, ccPayloadFor(name, cur))
                 if (r.decision === 'block') return { ...cur, behavior: 'block', reason: r.reason }
                 const pd = r.hookSpecificOutput?.permissionDecision
                 if (pd === 'deny') return { ...cur, behavior: 'block', reason: r.hookSpecificOutput?.permissionDecisionReason || 'denied' }
@@ -98,91 +100,82 @@ function makeHooks(ccPlugins) {
             }
             return cur
         },
-        names() { return HOOK_NAMES },
-        listeners(name) { return [...(reg[name] || [])] },
+        names: () => HOOK_NAMES, listeners: (n) => [...(reg2[n] || [])],
     }
-}
-
-function guard(surfaceObj, allowed, pluginName, verbs) {
-    if (allowed) return surfaceObj
-    return new Proxy({}, {
-        get(_, key) {
-            if (verbs.includes(String(key))) {
-                return () => { throw new Error(`plugin ${pluginName}: surface verb '${String(key)}' not allowed (declared surfaces=${pluginName})`) }
-            }
-            return surfaceObj[key]
-        },
-    })
-}
-
-function scopedConfig(name, store) {
-    const key = `plugins.${name}`
-    return {
-        get(k, d) { return store.get(`${key}.${k}`, d) },
-        set(k, v) { return store.set(`${key}.${k}`, v) },
-        all() { return store.all(key) || {} },
-    }
-}
 
-function nullStore() {
-    const m = new Map()
-    return { get: (k, d) => m.has(k) ? m.get(k) : d, set: (k, v) => m.set(k, v), all: (prefix) => Object.fromEntries([...m.entries()].filter(([k]) => k.startsWith(prefix))) }
-}
-
-export function createHost({ surfaces = ['pi', 'gui'], configStore = nullStore(), env = process.env } = {}) {
-    const pi = makePiSurface()
-    const gui = makeGuiSurface()
-    const ccPlugins = []
-    const hooks = makeHooks(ccPlugins)
     const loaded = []
     const host = {
         pi: surfaces.includes('pi') ? pi : null,
         gui: surfaces.includes('gui') ? gui : null,
         hooks,
-        ccPlugins: () => ccPlugins.slice(),
+        binPaths: () => binPaths.slice(),
+        ccPlugins: () => ccHost.plugins(),
+        onInbound: (fn) => inboundListeners.push(fn),
         plugins: () => loaded.map(p => ({ name: p.name, version: p.version || null, surfaces: p.surfaces, requires: p.requires || [] })),
-        get: (name) => loaded.find(p => p.name === name) || null,
+        get: (n) => loaded.find(p => p.name === n) || null,
+        shutdown: () => ccHost.shutdown(),
     }
-    async function loadAll(plugins) {
-        const validated = plugins.map(validatePlugin)
-        const sorted = topoSort(validated)
+
+    async function load(plugins) {
+        const sorted = topoSort(plugins.map(validatePlugin))
         for (const p of sorted) {
             const want = p.surfaces
-            const ctxPi = (want === 'pi' || want === 'both') && surfaces.includes('pi') ? pi : guard(pi, false, p.name, PI_VERBS)
+            const ctxPi  = (want === 'pi'  || want === 'both') && surfaces.includes('pi')  ? pi  : guard(pi, false, p.name, PI_VERBS)
             const ctxGui = (want === 'gui' || want === 'both') && surfaces.includes('gui') ? gui : guard(gui, false, p.name, GUI_VERBS)
-            const log = (level, msg, fields) => { const line = JSON.stringify({ ts: Date.now(), plugin: p.name, level, msg, ...(fields || {}) }); if (env.FREDDIE_LOG_STDOUT) console.log(line) }
-            const logger = { info: (m, f) => log('info', m, f), warn: (m, f) => log('warn', m, f), error: (m, f) => log('error', m, f) }
-            const ctx = { pi: ctxPi, gui: ctxGui, hooks, log: logger, config: scopedConfig(p.name, configStore), host, env }
+            const log = (lv, m, f) => { const line = JSON.stringify({ ts: Date.now(), plugin: p.name, level: lv, msg: m, ...(f || {}) }); if (env.FREDDIE_LOG_STDOUT) console.log(line) }
+            const logger = { info:(m,f)=>log('info',m,f), warn:(m,f)=>log('warn',m,f), error:(m,f)=>log('error',m,f) }
+            const ctx = { pi: ctxPi, gui: ctxGui, hooks, log: logger, config: scopedCfg(p.name, configStore), host, env }
             await p.register(ctx)
             loaded.push(p)
         }
         return loaded.length
     }
+    function isCcPluginDir(dir) {
+        if (fs.existsSync(path.join(dir, '.claude-plugin', 'plugin.json'))) return true
+        if (!fs.existsSync(path.join(dir, 'plugin.json'))) return false
+        return fs.existsSync(path.join(dir, 'hooks', 'hooks.json'))
+            || fs.existsSync(path.join(dir, 'skills'))
+            || fs.existsSync(path.join(dir, 'agents'))
+    }
+    async function useCcDir(dir) {
+        try { await ccHost.use(loadClaudePlugin(dir)) }
+        catch (e) { if (env.FREDDIE_LOG_STDOUT) console.error(`cc-plugin ${dir} failed: ${e.message}`) }
+    }
     async function loadCcPlugins(roots) {
         for (const root of roots) {
             if (!root || !fs.existsSync(root)) continue
             for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
                 if (!entry.isDirectory()) continue
                 const dir = path.join(root, entry.name)
-                if (!fs.existsSync(path.join(dir, '.claude-plugin', 'plugin.json'))) continue
-                try {
-                    const cc = loadClaudePlugin(dir)
-                    ccPlugins.push(cc)
-                    if (surfaces.includes('pi')) {
-                        for (const s of cc.skills)
-                            pi.skills.register({ name: cc.manifest.name + ':' + s.name, description: s.fields.description || '', content: s.body, source: 'cc:' + cc.manifest.name, frontmatter: s.fields, file: s.file })
-                        for (const a of cc.agents)
-                            pi.agentExts.register({ name: cc.manifest.name + ':' + a.name, description: a.fields.description || '', frontmatter: a.fields, body: a.body, source: 'cc:' + cc.manifest.name, file: a.file })
-                    }
-                } catch (e) {
-                    if (env.FREDDIE_LOG_STDOUT) console.error(`cc-plugin ${dir} failed: ${e.message}`)
+                if (isCcPluginDir(dir)) await useCcDir(dir)
+            }
+        }
+        return ccHost.plugins().length
+    }
+    async function loadCcFromNodeModules(startDir) {
+        const seen = new Set(ccHost.plugins().map(p => p.root))
+        let cur = path.resolve(startDir)
+        while (true) {
+            const nm = path.join(cur, 'node_modules')
+            if (fs.existsSync(nm)) for (const entry of fs.readdirSync(nm, { withFileTypes: true })) {
+                if (!entry.isDirectory()) continue
+                const dirs = entry.name.startsWith('@')
+                    ? fs.readdirSync(path.join(nm, entry.name), { withFileTypes: true }).filter(e => e.isDirectory()).map(e => path.join(nm, entry.name, e.name))
+                    : [path.join(nm, entry.name)]
+                for (const d of dirs) {
+                    if (seen.has(d) || !isCcPluginDir(d)) continue
+                    seen.add(d); await useCcDir(d)
                 }
             }
+            const parent = path.dirname(cur)
+            if (parent === cur) break
+            cur = parent
         }
-        return ccPlugins.length
+        return ccHost.plugins().length
     }
-    host.load = loadAll
+    host.load = load
     host.loadCcPlugins = loadCcPlugins
+    host.loadCcFromNodeModules = loadCcFromNodeModules
     return host
 }
 

package/src/host/index.js

@@ -23,6 +23,8 @@ export async function bootHost(extraRoots = []) {
     await h.load(plugins)
     const ccRoots = [path.join(getFreddieHome(), 'cc-plugins'), path.join(process.cwd(), '.freddie', 'cc-plugins')]
     await h.loadCcPlugins(ccRoots)
+    await h.loadCcFromNodeModules(__dirname)
+    await h.loadCcFromNodeModules(process.cwd())
     return h
 }