freddie 0.0.53 → 0.0.55

package/package.json

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

package/plugins/gm-cc/plugin.js

@@ -1,28 +1,26 @@
-import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
-import path from 'path';
-import fs from 'fs';
+import { createRequire } from 'module'
+import path from 'path'
+import fs from 'fs'
+import { loadClaudePlugin } from 'plugsdk'
 
-const _require = createRequire(import.meta.url);
-const gmCcBase = path.dirname(_require.resolve('gm-cc/package.json'));
+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' });
+        if (!fs.existsSync(path.join(gmCcBase, 'skills'))) return
+        const cc = loadClaudePlugin(gmCcBase)
+        for (const s of cc.skills) {
+            pi.skills.register({
+                name: 'gm:' + s.name,
+                description: s.fields.description || '',
+                content: s.body,
+                source: 'gm-cc',
+                frontmatter: s.fields,
+                file: s.file,
+            })
         }
     },
-};
+}

package/src/host/contract.js

@@ -1,4 +1,9 @@
-export { definePlugin, HookType, allowResult, blockResult, modifyResult, PluginRunner, PluginRuntime, piAdapter } from 'plugsdk'
+import { HookType } from 'plugsdk'
+
+export { HookType }
+export function definePlugin(p) { return p }
+export class PluginRunner {}
+export class PluginRuntime {}
 
 export const SURFACES = ['pi', 'gui', 'both']
 
@@ -13,15 +18,22 @@ export const HOOK_NAMES = [
     'onMessageInbound', 'onMessageOutbound',
 ]
 
-import { HookType } from 'plugsdk'
-
 export const FREDDIE_TO_SDK_HOOK = {
     preToolCall:        HookType.PRE_TOOL_USE,
     postToolCall:       HookType.POST_TOOL_USE,
     onSessionStart:     HookType.SESSION_START,
     onSessionEnd:       HookType.SESSION_END,
     onMessageInbound:   HookType.PROMPT_SUBMIT,
-    onMessageOutbound:  HookType.AFTER_RESPONSE,
+    onMessageOutbound:  HookType.STOP,
+}
+
+export const FREDDIE_TO_NATIVE_HOOK = {
+    preToolCall:       'PreToolUse',
+    postToolCall:      'PostToolUse',
+    onSessionStart:    'SessionStart',
+    onSessionEnd:      'SessionEnd',
+    onMessageInbound:  'UserPromptSubmit',
+    onMessageOutbound: 'Stop',
 }
 
 export function validatePlugin(p) {

package/src/host/host.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
-import { validatePlugin, topoSort, HOOK_NAMES, PI_VERBS, GUI_VERBS, FREDDIE_TO_SDK_HOOK, piAdapter } from './contract.js'
+import { loadClaudePlugin, createHookDispatcher } from 'plugsdk'
+import { validatePlugin, topoSort, HOOK_NAMES, PI_VERBS, GUI_VERBS, FREDDIE_TO_NATIVE_HOOK } from './contract.js'
 
 function makePiSurface() {
     const tools = new Map()
@@ -68,23 +69,32 @@ function makeGuiSurface() {
     }
 }
 
-function makeHooks() {
+function ccPayloadFor(freddieHook, payload) {
+    if (freddieHook === 'preToolCall' || freddieHook === 'postToolCall')
+        return { tool_name: payload?.name, tool_input: payload?.args || payload?.input, tool_response: payload?.result }
+    if (freddieHook === 'onMessageInbound' || freddieHook === '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)
         },
         async invoke(name, payload) {
-            const sdkHook = FREDDIE_TO_SDK_HOOK[name]
             let cur = payload
-            for (const fn of reg[name] || []) {
-                const raw = await fn(cur)
-                if (raw !== undefined && raw !== null && sdkHook && typeof raw === 'object' && 'behavior' in raw) {
-                    cur = piAdapter.translateHookOutput(sdkHook, raw)
-                } else {
-                    cur = raw ?? cur
-                }
+            for (const fn of reg[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 (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' }
+                if (r.hookSpecificOutput?.updatedInput) return { ...cur, ...r.hookSpecificOutput.updatedInput }
             }
             return cur
         },
@@ -119,44 +129,22 @@ function nullStore() {
     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))) }
 }
 
-const SDK_TO_FREDDIE = Object.fromEntries(Object.entries(FREDDIE_TO_SDK_HOOK).map(([f, s]) => [s, f]))
-
-function wrapPlugsdkPlugin(p) {
-    if (typeof p.register === 'function') return p
-    if (!p.tools && !p.hooks) return p
-    return {
-        name: p.name,
-        surfaces: 'pi',
-        register(ctx) {
-            for (const [id, tool] of Object.entries(p.tools || {})) {
-                ctx.pi.tools.register({
-                    name: id,
-                    schema: { name: id, description: tool.description, parameters: tool.parameters },
-                    handler: (args, rctx) => tool.execute(args, rctx),
-                })
-            }
-            for (const [hookType, fn] of Object.entries(p.hooks || {})) {
-                const freddieName = SDK_TO_FREDDIE[hookType]
-                if (freddieName) ctx.hooks.on(freddieName, fn)
-            }
-        },
-    }
-}
-
 export function createHost({ surfaces = ['pi', 'gui'], configStore = nullStore(), env = process.env } = {}) {
     const pi = makePiSurface()
     const gui = makeGuiSurface()
-    const hooks = makeHooks()
+    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(),
         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,
     }
     async function loadAll(plugins) {
-        const validated = plugins.map(p => wrapPlugsdkPlugin(p)).map(validatePlugin)
+        const validated = plugins.map(validatePlugin)
         const sorted = topoSort(validated)
         for (const p of sorted) {
             const want = p.surfaces
@@ -170,7 +158,31 @@ export function createHost({ surfaces = ['pi', 'gui'], configStore = nullStore()
         }
         return loaded.length
     }
+    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}`)
+                }
+            }
+        }
+        return ccPlugins.length
+    }
     host.load = loadAll
+    host.loadCcPlugins = loadCcPlugins
     return host
 }
 

package/src/host/index.js

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

package/src/skills/index.js

@@ -9,18 +9,15 @@ const FRONTMATTER = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/
 export function listSkills(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
-        walk(d, out)
-    }
-    return out.filter(s => platformOk(s))
+    for (const d of dirs) if (fs.existsSync(d)) walk(d, out)
+    return out.filter(platformOk)
 }
 
 function walk(d, out) {
     for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
         const full = path.join(d, entry.name)
-        if (entry.isDirectory()) { walk(full, out); continue }
-        if (entry.name === 'SKILL.md') out.push(loadSkill(full))
+        if (entry.isDirectory()) walk(full, out)
+        else if (entry.name === 'SKILL.md') out.push(loadSkill(full))
     }
 }
 

package/src/web/server.js

@@ -17,7 +17,7 @@ export async function createDashboard({ port = 0 } = {}) {
     }
     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 server = await new Promise((res, rej) => { const s = app.listen(port, () => res(s)); s.once('error', rej) })
     const actualPort = server.address().port
     return { server, port: actualPort, url: `http://127.0.0.1:${actualPort}/`, stop: () => new Promise(r => server.close(() => r())) }
 }