@passioncode-ai/fabric-agent-adapter 0.34.0 → 0.35.0

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/host_hooks.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+# #region native-host-context — docs: plugins/fabric-agent-adapter/skills/working-with-fabric/references/native-host-hooks.md
+"""Install bounded native context bridges. Dry-run by default; no model/service calls.
+
+OpenCode/Pi load a managed shim. Hermes loads a managed plugin wrapper and needs
+its native `hermes plugins enable fabric-agent-adapter` opt-in separately.
+OpenClaw loads the bundled plugin through its native configuration. Removal
+keeps unrelated settings and disables only this entry; existing allow/deny policy
+is never loosened. JSON5 configuration is refused, not rewritten as guessed JSON.
+"""
+import argparse
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+
+BASE = Path(__file__).resolve().parent
+spec = importlib.util.spec_from_file_location('_fabric_hook_install_common', BASE / 'fabric_session.py')
+fs = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(fs)
+MARKER = 'fabric-agent-adapter managed host hook v1'
+IDENTITY = 'fabric-agent-adapter'
+
+
+def destination(host, env):
+    home = fs._home(env)
+    if host == 'opencode':
+        return Path(env.get('XDG_CONFIG_HOME') or home / '.config') / 'opencode/plugins/fabric-agent-adapter.js'
+    if host == 'pi':
+        return Path(env.get('PI_CODING_AGENT_DIR') or home / '.pi/agent') / 'extensions/fabric-agent-adapter.js'
+    if host == 'hermes':
+        return Path(env.get('HERMES_HOME') or home / '.hermes') / 'plugins/fabric-agent-adapter'
+    return Path(env.get('OPENCLAW_CONFIG_PATH') or Path(env.get('OPENCLAW_STATE_DIR') or home / '.openclaw') / 'openclaw.json')
+
+
+def _object(parent, key):
+    if key not in parent: parent[key] = {}
+    if not isinstance(parent[key], dict): raise fs.Refused('unexpected object shape at ' + key)
+    return parent[key]
+
+
+def _list(parent, key):
+    if key not in parent: parent[key] = []
+    if not isinstance(parent[key], list) or not all(isinstance(x, str) for x in parent[key]):
+        raise fs.Refused('unexpected string-list shape at ' + key)
+    return parent[key]
+
+
+def openclaw_edit(data, script, remove):
+    try:
+        doc = json.loads(data.decode('utf-8')) if data else {}
+    except (ValueError, UnicodeError):
+        raise fs.Refused('OpenClaw config is not strict JSON; use the native config CLI for JSON5')
+    if not isinstance(doc, dict): raise fs.Refused('OpenClaw config must be an object')
+    target = str(script.parent / 'hosts/openclaw')
+    def ours(value):
+        if value == target:
+            return True
+        if not value.replace('\\', '/').endswith('/working-with-fabric/scripts/hosts/openclaw'):
+            return False
+        try:
+            manifest = fs.read_small(Path(value) / 'openclaw.plugin.json')
+            return isinstance(manifest, str) and json.loads(manifest).get('id') == IDENTITY
+        except (ValueError, AttributeError):
+            return False
+    if remove:
+        existing = doc.get('plugins', {})
+        if isinstance(existing, dict):
+            existing_entries = existing.get('entries', {})
+            existing_load = existing.get('load', {})
+            existing_paths = existing_load.get('paths', []) if isinstance(existing_load, dict) else []
+            has_entry = isinstance(existing_entries, dict) and IDENTITY in existing_entries
+            has_path = isinstance(existing_paths, list) and any(isinstance(p, str) and ours(p) for p in existing_paths)
+            if not has_entry and not has_path:
+                return data
+    plugins = _object(doc, 'plugins')
+    if not remove and (plugins.get('enabled') is False or IDENTITY in _list(plugins, 'deny')):
+        raise fs.Refused('existing OpenClaw plugin policy disables this adapter; policy was preserved')
+    entries = _object(plugins, 'entries')
+    entry = _object(entries, IDENTITY)
+    hooks = _object(entry, 'hooks')
+    if not remove and (entry.get('enabled') is False or any(hooks.get(k) is False for k in ('allowConversationAccess','allowPromptInjection'))):
+        raise fs.Refused('existing OpenClaw entry denies this hook; policy was preserved')
+    load = _object(plugins, 'load')
+    paths = _list(load, 'paths')
+    kept = [p for p in paths if not ours(p)]
+    load['paths'] = kept if remove else kept + [target]
+    entry['enabled'] = not remove
+    if remove and set(entry) <= {'enabled','hooks'} and hooks == {'allowConversationAccess':True,'allowPromptInjection':True}:
+        del entries[IDENTITY]
+    if not remove:
+        hooks.update(allowConversationAccess=True, allowPromptInjection=True)
+        if 'allow' in plugins:
+            allow = _list(plugins, 'allow')
+            if IDENTITY not in allow: allow.append(IDENTITY)
+    return (json.dumps(doc, indent=2) + '\n').encode()
+
+
+def plan(host, path, script, remove):
+    """Return [(path, expected bytes, desired bytes|None)] before any mutation."""
+    if host == 'openclaw':
+        old = fs._read_bytes(path)
+        if remove and old is None: return []
+        return [(path, old, openclaw_edit(old, script, remove))]
+    if host == 'hermes':
+        if path.is_symlink(): raise fs.Refused('plugin directory is a symlink; nothing was changed')
+        module = str(script.parent / 'hosts/hermes/__init__.py')
+        loader = ('# ' + MARKER + '\nimport importlib.util\n'
+                  '_spec = importlib.util.spec_from_file_location("_fabric_native_hermes", ' + repr(module) + ')\n'
+                  '_module = importlib.util.module_from_spec(_spec)\n_spec.loader.exec_module(_module)\nregister = _module.register\n')
+        manifest = '# ' + MARKER + '\n' + (script.parent / 'hosts/hermes/plugin.yaml').read_text()
+        desired = {path/'__init__.py':loader, path/'plugin.yaml':manifest}
+    else:
+        module = (script.parent / ('hosts/' + host + '/fabric.mjs')).as_uri()
+        desired = {path: '// ' + MARKER + '\nexport { default } from ' + json.dumps(module) + ';\n'}
+    changes = []
+    for target, text in desired.items():
+        old = fs._read_bytes(target)
+        if old is not None and MARKER.encode() not in old.split(b'\n', 1)[0]:
+            raise fs.Refused('destination is not an adapter-managed file: ' + str(target))
+        changes.append((target, old, None if remove else text.encode()))
+    return changes
+
+
+def plan_digest(changes):
+    return hashlib.sha256(json.dumps([(str(p),fs._digest(old)) for p,old,_ in changes]).encode()).hexdigest()
+
+
+def main(argv=None, env=None, out=print, err=print):
+    env = os.environ if env is None else env
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--host', choices=['hermes','opencode','openclaw','pi'], required=True)
+    mode=parser.add_mutually_exclusive_group()
+    mode.add_argument('--apply',action='store_true');mode.add_argument('--remove',action='store_true');mode.add_argument('--dry-run',action='store_true')
+    parser.add_argument('--config');parser.add_argument('--script');parser.add_argument('--expect-sha256')
+    args=parser.parse_args(argv)
+    try:
+        script=Path(args.script).expanduser().absolute() if args.script else BASE/'fabric_session.py'
+        if not script.is_file(): raise fs.Refused('shared helper is missing')
+        if not args.remove:
+            required = {'hermes':['hosts/hermes/__init__.py','hosts/hermes/plugin.yaml'],
+                        'opencode':['hosts/context.mjs','hosts/opencode/fabric.mjs'],
+                        'pi':['hosts/context.mjs','hosts/pi/fabric.mjs'],
+                        'openclaw':['hosts/context.mjs','hosts/openclaw/index.mjs','hosts/openclaw/package.json','hosts/openclaw/openclaw.plugin.json']}[args.host]
+            if any(not (script.parent/p).is_file() for p in required):
+                raise fs.Refused('native adapter source is missing; update the complete skill before installing hooks')
+        path=Path(args.config).expanduser().absolute() if args.config else destination(args.host,env)
+        changes=plan(args.host,path,script,args.remove)
+        digest=plan_digest(changes)
+        if args.expect_sha256 and digest != args.expect_sha256: raise fs.Refused('configuration changed since the plan')
+        out('host=%s sha256=%s action=%s' % (args.host,digest,'remove' if args.remove else 'install'))
+        for p,old,new in changes: out('%s %s' % ('unchanged' if old==new else 'would change',p))
+        if args.apply or args.remove:
+            # Preflight every destination before changing even the first one.
+            if any(fs._read_bytes(p) != old for p,old,_ in changes): raise fs.Refused('destination changed during planning')
+            for p,old,new in changes:
+                if old==new: continue
+                if new is None:
+                    if fs._read_bytes(p) != old: raise fs.Refused('destination changed during removal')
+                    if old is not None: p.unlink()
+                else: fs._replace_file(p,new,old)
+            if args.host=='hermes' and args.remove:
+                # A foreign addition in this directory is preserved.
+                try:path.rmdir()
+                except OSError:pass
+            out('native loader files updated; existing sessions must reload to use them')
+        else: out('dry run; no files changed. Apply with --apply --expect-sha256 ' + digest)
+        if args.host=='hermes':
+            out('native activation: hermes plugins %s fabric-agent-adapter' % ('disable' if args.remove else 'enable'))
+        return 0
+    except (fs.Refused,OSError,ValueError) as exc:
+        # Refused has only our shape diagnostics; parser failures never echo config bytes.
+        err('host-hooks: refused: ' + (str(exc) if isinstance(exc,fs.Refused) else type(exc).__name__))
+        return 1
+
+if __name__=='__main__':raise SystemExit(main())
+# #endregion native-host-context

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/hosts/context.mjs

@@ -0,0 +1,33 @@
+// #region native-host-context — docs: plugins/fabric-agent-adapter/skills/working-with-fabric/references/native-host-hooks.md
+// Shared, non-resident bridge. A context hook never enrolls or calls a model.
+import { execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const scriptPath = fileURLToPath(new URL('../fabric_session.py', import.meta.url));
+const hosts = new Set(['opencode', 'pi', 'openclaw']);
+const cap = 64 * 1024;
+
+export async function readContext(host, cwd, options = {}) {
+  if (!hosts.has(host) || typeof cwd !== 'string' || !cwd || cwd.includes('\0')) return '';
+  const payload = {cwd};
+  if (options.fabricRegistered === true) payload.fabric_registered = true;
+  const input = JSON.stringify(payload);
+  if (Buffer.byteLength(input) > cap) return '';
+  const timeout = Number.isFinite(options.timeoutMs)
+    ? Math.max(1, Math.min(4000, options.timeoutMs)) : 4000;
+  return new Promise(resolve => {
+    try {
+      const child = execFile(options.python || 'python3',
+        ['-S', options.script || scriptPath, 'hook', 'session-start', '--host', host],
+        {timeout, killSignal:'SIGKILL', maxBuffer:cap, encoding:'utf8', windowsHide:true},
+        (error, stdout) => {
+          if (error || typeof stdout !== 'string' || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(stdout)) return resolve('');
+          resolve(stdout.trim());
+        });
+      // A missing executable or early exit may close stdin before it is written.
+      child.stdin?.on('error', () => {});
+      child.stdin?.end(input);
+    } catch { resolve(''); }
+  });
+}
+// #endregion native-host-context

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/hosts/hermes/__init__.py

@@ -0,0 +1,135 @@
+# #region native-host-context — docs: plugins/fabric-agent-adapter/skills/working-with-fabric/references/native-host-hooks.md
+"""Hermes native, session-frozen Fabric context; no model or lifecycle worker."""
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import signal
+import threading
+import time
+from collections.abc import Mapping
+
+MAX_CONTEXT_CHARS = 4000
+TIMEOUT_SECONDS = 4
+MAX_OUTPUT_BYTES = 16000
+MAX_INPUT_BYTES = 4096
+
+
+def _kill_owned(process):
+    try:
+        if os.name == "posix":
+            os.killpg(process.pid, signal.SIGKILL)
+        else:
+            process.kill()
+    except (OSError, ProcessLookupError):
+        pass
+
+
+def _capture(command, payload):
+    """Bound output while reading, not after buffering a noisy helper's entire stdout."""
+    if len(payload) > MAX_INPUT_BYTES:
+        return None
+    process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                               stderr=subprocess.DEVNULL, start_new_session=os.name == "posix")
+    output = bytearray()
+    invalid = threading.Event()
+    deadline = time.monotonic() + TIMEOUT_SECONDS
+
+    def read_output():
+        try:
+            while True:
+                chunk = process.stdout.read(min(1024, MAX_OUTPUT_BYTES + 1 - len(output)))
+                if not chunk:
+                    return
+                output.extend(chunk)
+                if len(output) > MAX_OUTPUT_BYTES:
+                    invalid.set()
+                    _kill_owned(process)
+                    return
+        except (OSError, ValueError):
+            invalid.set()
+
+    reader = threading.Thread(target=read_output, daemon=True)
+    reader.start()
+    try:
+        process.stdin.write(payload)
+        process.stdin.close()
+        process.wait(timeout=max(0.001, deadline - time.monotonic()))
+        reader.join(timeout=max(0, deadline - time.monotonic()))
+        if reader.is_alive() or invalid.is_set() or process.returncode != 0:
+            return None
+        return bytes(output)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    finally:
+        # Own process group only: also close a pipe inherited by an owned child.
+        _kill_owned(process)
+        process.wait()
+        reader.join(timeout=0.2)
+        if not reader.is_alive():
+            process.stdout.close()
+        process.stdin.close()
+
+
+def fabric_registered(config=None):
+    """Read only the native registration flag; never forward server config or credentials."""
+    try:
+        if config is None:
+            from hermes_cli.config import load_config_readonly
+            config = load_config_readonly()
+        servers = config.get("mcp_servers") if isinstance(config, Mapping) else None
+        server = servers.get("fabric") if isinstance(servers, Mapping) else None
+        if not isinstance(server, Mapping):
+            return False
+        enabled = server.get("enabled", True)
+        return enabled is True or isinstance(enabled, str) and enabled.lower().strip() in ("true", "1", "yes", "on")
+    except (ImportError, OSError, TypeError, ValueError):
+        return False
+
+
+def context_for_session(session_info, session_script=None):
+    """Read the shared preamble through its bounded plain-text host protocol."""
+    if not isinstance(session_info, Mapping):
+        return ""
+    cwd = session_info.get("cwd", "")
+    if not isinstance(cwd, str) or len(cwd) > MAX_INPUT_BYTES // 2 or "\x00" in cwd:
+        return ""
+    try:
+        if session_script is None:
+            script = Path(__file__).resolve().parents[2] / "fabric_session.py"
+        elif isinstance(session_script, str) and Path(session_script).is_absolute():
+            script = Path(session_script)
+        else:
+            return ""
+        if not script.is_file():
+            return ""
+        result = _capture(
+            [sys.executable, "-S", str(script), "hook", "session-start", "--host", "hermes"],
+            json.dumps({"cwd": cwd or os.getcwd(), "fabric_registered": fabric_registered()},
+                       ensure_ascii=False).encode("utf-8"),
+        )
+        if result is None:
+            return ""
+        text = result.decode("utf-8").strip()
+        if len(text) > MAX_CONTEXT_CHARS or any(ord(char) < 32 and char not in "\n\r\t" for char in text):
+            return ""
+        return text
+    except (OSError, ValueError, subprocess.TimeoutExpired):
+        # Context is best effort; never leak configuration, diagnostics or hook input.
+        return ""
+
+
+def register(ctx):
+    """Use Hermes' cache-safe prompt section API, not observer hook returns."""
+    if not callable(getattr(ctx, "register_system_prompt_section", None)):
+        return
+    try:
+        script = ctx.get_config("session_script", None)
+    except (AttributeError, OSError, TypeError, ValueError):
+        return
+    ctx.register_system_prompt_section(
+        "fabric.context", lambda info: context_for_session(info, script),
+        position="after_memory", max_chars=MAX_CONTEXT_CHARS,
+    )
+# #endregion native-host-context

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/hosts/hermes/plugin.yaml

@@ -0,0 +1,5 @@
+name: fabric-agent-adapter
+description: Bounded Fabric context frozen into the Hermes session prompt.
+kind: standalone
+requires_hermes: '>=0.21.4'
+license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/hosts/openclaw/index.mjs

@@ -0,0 +1,45 @@
+// #region native-host-context — docs: plugins/fabric-agent-adapter/skills/working-with-fabric/references/native-host-hooks.md
+// Native OpenClaw prompt hook. Never observes conversation content or sends messages.
+import { readContext } from '../context.mjs';
+
+function fabricRegistered(config) {
+  const servers = config?.mcp?.servers;
+  if (!servers || typeof servers !== 'object' || Array.isArray(servers)) return false;
+  return ['fabric', 'fabric-mcp'].some(name => {
+    const entry = Object.hasOwn(servers, name) ? servers[name] : undefined;
+    return entry && typeof entry === 'object' && !Array.isArray(entry)
+      && entry.enabled !== false
+      && [entry.command, entry.url].some(value => typeof value === 'string' && value.trim());
+  });
+}
+
+export function createPlugin(contextReader = readContext) {
+  return {
+    id: 'fabric-agent-adapter',
+    name: 'Fabric Agent Adapter',
+    description: 'Adds bounded Fabric context through the native prompt hook.',
+    register(api) {
+      api.on('before_prompt_build', async (_event, ctx) => {
+        // workspaceDir is optional in the host contract. Do not substitute the
+        // Gateway process directory, which can belong to a different project.
+        if (typeof ctx?.workspaceDir !== 'string' || !ctx.workspaceDir.trim()) return;
+        try {
+          // Configured is not connected/admitted. Forward only the boolean,
+          // never server configuration, headers, environment or credentials.
+          const options = fabricRegistered(api.config) ? { fabricRegistered: true } : {};
+          const context = await contextReader('openclaw', ctx.workspaceDir, options);
+          ctx.hookInvocation?.assertActive();
+          if (typeof context !== 'string' || !context.trim()) return;
+          return { prependContext: context };
+        } catch {
+          // Missing dependencies, unavailable context and expired invocations
+          // must not stop an unrelated turn or leak diagnostics into its prompt.
+          return;
+        }
+      });
+    },
+  };
+}
+
+export default createPlugin();
+// #endregion native-host-context

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/hosts/openclaw/openclaw.plugin.json

@@ -0,0 +1,11 @@
+{
+  "id": "fabric-agent-adapter",
+  "name": "Fabric Agent Adapter",
+  "description": "Bounded Fabric context using the native OpenClaw prompt hook.",
+  "activation": { "onStartup": true },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/hosts/openclaw/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@passioncode-ai/fabric-agent-adapter-openclaw",
+  "private": true,
+  "type": "module",
+  "license": "AGPL-3.0-only OR LicenseRef-PassionCode-Commercial",
+  "openclaw": {
+    "extensions": ["./index.mjs"],
+    "compat": { "pluginApi": ">=2026.10.4" }
+  }
+}

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/hosts/opencode/fabric.mjs

@@ -0,0 +1,24 @@
+// #region native-host-context — docs: plugins/fabric-agent-adapter/skills/working-with-fabric/references/native-host-hooks.md
+import { readContext } from '../context.mjs';
+
+const marker = '[fabric-agent-adapter]';
+
+// OpenCode's legacy loader treats every export as a plugin factory.
+export default async function fabricPlugin({directory} = {}) {
+  let fabricRegistered = false;
+  return {
+    config: async config => {
+      const entry = config?.mcp?.fabric;
+      // Observe the host's resolved configuration; never read or forward secrets.
+      fabricRegistered = !!entry && typeof entry === 'object' && entry.enabled !== false &&
+        ((entry.type === 'local' && Array.isArray(entry.command) && entry.command.length > 0) ||
+         (entry.type === 'remote' && typeof entry.url === 'string' && entry.url.length > 0));
+    },
+    'experimental.chat.system.transform': async (_input, output) => {
+      if (!Array.isArray(output?.system) || output.system.some(part => typeof part === 'string' && part.includes(marker))) return;
+      const context = await readContext('opencode', directory, {fabricRegistered});
+      if (context && !output.system.includes(context)) output.system.push(context);
+    },
+  };
+}
+// #endregion native-host-context

package/plugins/fabric-agent-adapter/skills/working-with-fabric/scripts/hosts/pi/fabric.mjs

@@ -0,0 +1,36 @@
+// #region native-host-context — docs: plugins/fabric-agent-adapter/skills/working-with-fabric/references/native-host-hooks.md
+import { readContext } from '../context.mjs';
+
+const marker = '[fabric-agent-adapter]';
+
+export default function fabricExtension(pi) {
+  pi.on('before_agent_start', async (event, ctx) => {
+    if (!event || !ctx) return;
+    const options = event.systemPromptOptions;
+    if (typeof options?.forceSystemPrompt === 'string' && options.forceSystemPrompt.includes(marker)) return;
+    if (!options && typeof event.systemPrompt === 'string' && event.systemPrompt.includes(marker)) return;
+    if (options?.sections?.fabric_agent_adapter) return;
+    let fabricRegistered = false;
+    try {
+      const tools = pi.getAllTools?.();
+      fabricRegistered = Array.isArray(tools) && tools.some(tool =>
+        tool?.exposure !== 'hidden' &&
+        (tool?.name === 'fabric_whoami' || tool?.name === 'mcp__fabric__fabric_whoami'));
+    } catch { /* Early startup or a disabled tool registry is not registration. */ }
+    const context = await readContext('pi', ctx.cwd, {fabricRegistered});
+    if (!context) return;
+    if (typeof options?.forceSystemPrompt === 'string') {
+      if (options.forceSystemPrompt.includes(context)) return;
+      options.forceSystemPrompt += '\n\n' + context;
+    } else if (options && typeof options === 'object') {
+      options.sections ??= {};
+      if (typeof options.sections !== 'object' || Array.isArray(options.sections)) return;
+      options.sections.fabric_agent_adapter = context;
+    } else if (typeof event.systemPrompt === 'string') {
+      if (event.systemPrompt.includes(context)) return;
+      // Older Pi versions expose only the replacement-prompt return contract.
+      return {systemPrompt:event.systemPrompt + '\n\n' + context};
+    }
+  });
+}
+// #endregion native-host-context