Initial commit: Elydora Node SDK

TypeScript SDK for Elydora agent operations, cryptographic signing, and audit trail integration.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/plugins/augment.ts

@@ -0,0 +1,145 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { AgentPlugin, InstallConfig, PluginStatus } from './base.js';
+import { SUPPORTED_AGENTS } from './registry.js';
+
+const AGENT_KEY = 'augment';
+const entry = SUPPORTED_AGENTS.get(AGENT_KEY)!;
+
+function resolveConfigDir(): string {
+  return entry.configDir.replace(/^~/, os.homedir());
+}
+
+function resolveConfigPath(): string {
+  return path.join(resolveConfigDir(), entry.configFile);
+}
+
+function buildHookCommand(scriptPath: string): string {
+  return `node "${scriptPath}"`;
+}
+
+function filterElydoraEntries(arr: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
+  return arr.filter((entry) => {
+    if (Array.isArray(entry.hooks)) {
+      const cmds = entry.hooks as Array<Record<string, unknown>>;
+      return !cmds.some((h) => typeof h.command === 'string' && h.command.includes('elydora'));
+    }
+    if (typeof entry.command === 'string') return !entry.command.includes('elydora');
+    return true;
+  });
+}
+
+export const augmentPlugin: AgentPlugin = {
+  async install(config: InstallConfig): Promise<void> {
+    const configDir = resolveConfigDir();
+    await fsp.mkdir(configDir, { recursive: true });
+
+    const configPath = resolveConfigPath();
+    let settings: Record<string, unknown> = {};
+
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      settings = JSON.parse(raw);
+    } catch {
+      // Start fresh
+    }
+
+    if (!settings.hooks || typeof settings.hooks !== 'object') {
+      settings.hooks = {};
+    }
+    const hooks = settings.hooks as Record<string, unknown>;
+
+    // --- PreToolUse (guard — freeze enforcement) ---
+    if (!Array.isArray(hooks.PreToolUse)) {
+      hooks.PreToolUse = [];
+    }
+    const preFiltered = filterElydoraEntries(hooks.PreToolUse as Array<Record<string, unknown>>);
+    preFiltered.push({
+      hooks: [{ type: 'command', command: buildHookCommand(config.guardScriptPath) }],
+    });
+    hooks.PreToolUse = preFiltered;
+
+    // --- PostToolUse (audit logging) ---
+    if (!Array.isArray(hooks.PostToolUse)) {
+      hooks.PostToolUse = [];
+    }
+    const postFiltered = filterElydoraEntries(hooks.PostToolUse as Array<Record<string, unknown>>);
+    postFiltered.push({
+      hooks: [{ type: 'command', command: buildHookCommand(config.hookScriptPath) }],
+    });
+    hooks.PostToolUse = postFiltered;
+
+    settings.hooks = hooks;
+    await fsp.writeFile(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  },
+
+  async uninstall(): Promise<void> {
+    const configPath = resolveConfigPath();
+
+    let settings: Record<string, unknown>;
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      settings = JSON.parse(raw);
+    } catch {
+      return;
+    }
+
+    const hooks = settings.hooks as Record<string, unknown> | undefined;
+    if (!hooks) return;
+
+    if (Array.isArray(hooks.PreToolUse)) {
+      hooks.PreToolUse = filterElydoraEntries(hooks.PreToolUse as Array<Record<string, unknown>>);
+    }
+    if (Array.isArray(hooks.PostToolUse)) {
+      hooks.PostToolUse = filterElydoraEntries(hooks.PostToolUse as Array<Record<string, unknown>>);
+    }
+
+    await fsp.writeFile(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  },
+
+  async status(): Promise<PluginStatus> {
+    const configPath = resolveConfigPath();
+    const hookScriptPath = path.join(os.homedir(), '.elydora', 'hooks', `${AGENT_KEY}-hook.js`);
+
+    let hookConfigured = false;
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      const settings = JSON.parse(raw);
+      const hooks = settings.hooks as Record<string, unknown> | undefined;
+      if (hooks) {
+        const checkArr = (arr: unknown) => {
+          if (!Array.isArray(arr)) return false;
+          return (arr as Array<Record<string, unknown>>).some((entry) => {
+            if (Array.isArray(entry.hooks)) {
+              return (entry.hooks as Array<Record<string, unknown>>).some(
+                (h) => typeof h.command === 'string' && h.command.includes('elydora'),
+              );
+            }
+            return typeof entry.command === 'string' && entry.command.includes('elydora');
+          });
+        };
+        hookConfigured = checkArr(hooks.PreToolUse) && checkArr(hooks.PostToolUse);
+      }
+    } catch {
+      // Config not readable
+    }
+
+    let hookScriptExists = false;
+    try {
+      await fsp.access(hookScriptPath);
+      hookScriptExists = true;
+    } catch {
+      // File doesn't exist
+    }
+
+    return {
+      installed: hookConfigured && hookScriptExists,
+      agentName: AGENT_KEY,
+      displayName: entry.name,
+      hookConfigured,
+      hookScriptExists,
+      configPath,
+    };
+  },
+};

src/plugins/base.ts

@@ -0,0 +1,26 @@
+export interface InstallConfig {
+  readonly agentName: string;
+  readonly orgId: string;
+  readonly agentId: string;
+  readonly privateKey: string;
+  readonly kid: string;
+  readonly token?: string;
+  readonly baseUrl: string;
+  readonly hookScriptPath: string;
+  readonly guardScriptPath: string;
+}
+
+export interface PluginStatus {
+  readonly installed: boolean;
+  readonly agentName: string;
+  readonly displayName: string;
+  readonly hookConfigured: boolean;
+  readonly hookScriptExists: boolean;
+  readonly configPath: string;
+}
+
+export interface AgentPlugin {
+  install(config: InstallConfig): Promise<void>;
+  uninstall(): Promise<void>;
+  status(): Promise<PluginStatus>;
+}

src/plugins/claudecode.ts

@@ -0,0 +1,147 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { AgentPlugin, InstallConfig, PluginStatus } from './base.js';
+import { SUPPORTED_AGENTS } from './registry.js';
+
+const AGENT_KEY = 'claudecode';
+const entry = SUPPORTED_AGENTS.get(AGENT_KEY)!;
+
+function resolveConfigDir(): string {
+  return entry.configDir.replace(/^~/, os.homedir());
+}
+
+function resolveConfigPath(): string {
+  return path.join(resolveConfigDir(), entry.configFile);
+}
+
+function buildHookCommand(scriptPath: string): string {
+  return `node "${scriptPath}"`;
+}
+
+function filterElydoraEntries(arr: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
+  return arr.filter((entry) => {
+    if (Array.isArray(entry.hooks)) {
+      const cmds = entry.hooks as Array<Record<string, unknown>>;
+      return !cmds.some((h) => typeof h.command === 'string' && h.command.includes('elydora'));
+    }
+    if (typeof entry.command === 'string') {
+      return !entry.command.includes('elydora');
+    }
+    return true;
+  });
+}
+
+export const claudecodePlugin: AgentPlugin = {
+  async install(config: InstallConfig): Promise<void> {
+    const configDir = resolveConfigDir();
+    await fsp.mkdir(configDir, { recursive: true });
+
+    const configPath = resolveConfigPath();
+    let settings: Record<string, unknown> = {};
+
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      settings = JSON.parse(raw);
+    } catch {
+      // File doesn't exist or isn't valid JSON — start fresh
+    }
+
+    if (!settings.hooks || typeof settings.hooks !== 'object') {
+      settings.hooks = {};
+    }
+    const hooks = settings.hooks as Record<string, unknown>;
+
+    // --- PreToolUse (guard — freeze enforcement) ---
+    if (!Array.isArray(hooks.PreToolUse)) {
+      hooks.PreToolUse = [];
+    }
+    const preFiltered = filterElydoraEntries(hooks.PreToolUse as Array<Record<string, unknown>>);
+    preFiltered.push({
+      hooks: [{ type: 'command', command: buildHookCommand(config.guardScriptPath) }],
+    });
+    hooks.PreToolUse = preFiltered;
+
+    // --- PostToolUse (audit logging) ---
+    if (!Array.isArray(hooks.PostToolUse)) {
+      hooks.PostToolUse = [];
+    }
+    const postFiltered = filterElydoraEntries(hooks.PostToolUse as Array<Record<string, unknown>>);
+    postFiltered.push({
+      hooks: [{ type: 'command', command: buildHookCommand(config.hookScriptPath) }],
+    });
+    hooks.PostToolUse = postFiltered;
+
+    settings.hooks = hooks;
+    await fsp.writeFile(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  },
+
+  async uninstall(): Promise<void> {
+    const configPath = resolveConfigPath();
+
+    let settings: Record<string, unknown>;
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      settings = JSON.parse(raw);
+    } catch {
+      return; // Nothing to uninstall
+    }
+
+    const hooks = settings.hooks as Record<string, unknown> | undefined;
+    if (!hooks) return;
+
+    if (Array.isArray(hooks.PreToolUse)) {
+      hooks.PreToolUse = filterElydoraEntries(hooks.PreToolUse as Array<Record<string, unknown>>);
+    }
+    if (Array.isArray(hooks.PostToolUse)) {
+      hooks.PostToolUse = filterElydoraEntries(hooks.PostToolUse as Array<Record<string, unknown>>);
+    }
+
+    await fsp.writeFile(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  },
+
+  async status(): Promise<PluginStatus> {
+    const configPath = resolveConfigPath();
+    const hookScriptPath = path.join(os.homedir(), '.elydora', 'hooks', `${AGENT_KEY}-hook.js`);
+
+    let hookConfigured = false;
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      const settings = JSON.parse(raw);
+      const hooks = settings.hooks as Record<string, unknown> | undefined;
+      if (hooks) {
+        const checkArr = (arr: unknown) => {
+          if (!Array.isArray(arr)) return false;
+          return (arr as Array<Record<string, unknown>>).some((entry) => {
+            if (Array.isArray(entry.hooks)) {
+              return (entry.hooks as Array<Record<string, unknown>>).some(
+                (h) => typeof h.command === 'string' && h.command.includes('elydora'),
+              );
+            }
+            return typeof entry.command === 'string' && entry.command.includes('elydora');
+          });
+        };
+        hookConfigured = checkArr(hooks.PreToolUse) && checkArr(hooks.PostToolUse);
+      }
+    } catch {
+      // Config not readable
+    }
+
+    let hookScriptExists = false;
+    try {
+      await fsp.access(hookScriptPath);
+      hookScriptExists = true;
+    } catch {
+      // File doesn't exist
+    }
+
+    return {
+      installed: hookConfigured && hookScriptExists,
+      agentName: AGENT_KEY,
+      displayName: entry.name,
+      hookConfigured,
+      hookScriptExists,
+      configPath,
+    };
+  },
+};

src/plugins/cursor.ts

@@ -0,0 +1,130 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { AgentPlugin, InstallConfig, PluginStatus } from './base.js';
+import { SUPPORTED_AGENTS } from './registry.js';
+
+const AGENT_KEY = 'cursor';
+const entry = SUPPORTED_AGENTS.get(AGENT_KEY)!;
+
+function resolveConfigDir(): string {
+  // .cursor is project-relative, but for global install use home dir
+  return path.join(os.homedir(), entry.configDir);
+}
+
+function resolveConfigPath(): string {
+  return path.join(resolveConfigDir(), entry.configFile);
+}
+
+function buildHookCommand(scriptPath: string): string {
+  return `node "${scriptPath}"`;
+}
+
+function filterElydoraEntries(arr: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
+  return arr.filter(
+    (h) => typeof h.command === 'string' && !h.command.includes('elydora'),
+  );
+}
+
+export const cursorPlugin: AgentPlugin = {
+  async install(config: InstallConfig): Promise<void> {
+    const configDir = resolveConfigDir();
+    await fsp.mkdir(configDir, { recursive: true });
+
+    const configPath = resolveConfigPath();
+    let settings: Record<string, unknown> = {};
+
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      settings = JSON.parse(raw);
+    } catch {
+      // Start fresh
+    }
+
+    if (!settings.hooks || typeof settings.hooks !== 'object') {
+      settings.hooks = {};
+    }
+    const hooks = settings.hooks as Record<string, unknown>;
+
+    // --- preToolUse (guard — freeze enforcement) ---
+    if (!Array.isArray(hooks.preToolUse)) {
+      hooks.preToolUse = [];
+    }
+    const preFiltered = filterElydoraEntries(hooks.preToolUse as Array<Record<string, unknown>>);
+    preFiltered.push({ command: buildHookCommand(config.guardScriptPath) });
+    hooks.preToolUse = preFiltered;
+
+    // --- postToolUse (audit logging) ---
+    if (!Array.isArray(hooks.postToolUse)) {
+      hooks.postToolUse = [];
+    }
+    const postFiltered = filterElydoraEntries(hooks.postToolUse as Array<Record<string, unknown>>);
+    postFiltered.push({ command: buildHookCommand(config.hookScriptPath) });
+    hooks.postToolUse = postFiltered;
+
+    settings.hooks = hooks;
+    await fsp.writeFile(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  },
+
+  async uninstall(): Promise<void> {
+    const configPath = resolveConfigPath();
+
+    let settings: Record<string, unknown>;
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      settings = JSON.parse(raw);
+    } catch {
+      return;
+    }
+
+    const hooks = settings.hooks as Record<string, unknown> | undefined;
+    if (!hooks) return;
+
+    if (Array.isArray(hooks.preToolUse)) {
+      hooks.preToolUse = filterElydoraEntries(hooks.preToolUse as Array<Record<string, unknown>>);
+    }
+    if (Array.isArray(hooks.postToolUse)) {
+      hooks.postToolUse = filterElydoraEntries(hooks.postToolUse as Array<Record<string, unknown>>);
+    }
+
+    await fsp.writeFile(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  },
+
+  async status(): Promise<PluginStatus> {
+    const configPath = resolveConfigPath();
+    const hookScriptPath = path.join(os.homedir(), '.elydora', 'hooks', `${AGENT_KEY}-hook.js`);
+
+    let hookConfigured = false;
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      const settings = JSON.parse(raw);
+      const hooks = settings.hooks as Record<string, unknown> | undefined;
+      if (hooks) {
+        const check = (arr: unknown) =>
+          Array.isArray(arr) && (arr as Array<Record<string, unknown>>).some(
+            (h) => typeof h.command === 'string' && h.command.includes('elydora'),
+          );
+        hookConfigured = check(hooks.preToolUse) && check(hooks.postToolUse);
+      }
+    } catch {
+      // Config not readable
+    }
+
+    let hookScriptExists = false;
+    try {
+      await fsp.access(hookScriptPath);
+      hookScriptExists = true;
+    } catch {
+      // File doesn't exist
+    }
+
+    return {
+      installed: hookConfigured && hookScriptExists,
+      agentName: AGENT_KEY,
+      displayName: entry.name,
+      hookConfigured,
+      hookScriptExists,
+      configPath,
+    };
+  },
+};

src/plugins/gemini.ts

@@ -0,0 +1,145 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { AgentPlugin, InstallConfig, PluginStatus } from './base.js';
+import { SUPPORTED_AGENTS } from './registry.js';
+
+const AGENT_KEY = 'gemini';
+const entry = SUPPORTED_AGENTS.get(AGENT_KEY)!;
+
+function resolveConfigDir(): string {
+  return entry.configDir.replace(/^~/, os.homedir());
+}
+
+function resolveConfigPath(): string {
+  return path.join(resolveConfigDir(), entry.configFile);
+}
+
+function buildHookCommand(scriptPath: string): string {
+  return `node "${scriptPath}"`;
+}
+
+function filterElydoraEntries(arr: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
+  return arr.filter((entry) => {
+    if (Array.isArray(entry.hooks)) {
+      const cmds = entry.hooks as Array<Record<string, unknown>>;
+      return !cmds.some((h) => typeof h.command === 'string' && h.command.includes('elydora'));
+    }
+    if (typeof entry.command === 'string') return !entry.command.includes('elydora');
+    return true;
+  });
+}
+
+export const geminiPlugin: AgentPlugin = {
+  async install(config: InstallConfig): Promise<void> {
+    const configDir = resolveConfigDir();
+    await fsp.mkdir(configDir, { recursive: true });
+
+    const configPath = resolveConfigPath();
+    let settings: Record<string, unknown> = {};
+
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      settings = JSON.parse(raw);
+    } catch {
+      // Start fresh
+    }
+
+    if (!settings.hooks || typeof settings.hooks !== 'object') {
+      settings.hooks = {};
+    }
+    const hooks = settings.hooks as Record<string, unknown>;
+
+    // --- BeforeTool (guard — freeze enforcement) ---
+    if (!Array.isArray(hooks.BeforeTool)) {
+      hooks.BeforeTool = [];
+    }
+    const preFiltered = filterElydoraEntries(hooks.BeforeTool as Array<Record<string, unknown>>);
+    preFiltered.push({
+      hooks: [{ type: 'command', command: buildHookCommand(config.guardScriptPath) }],
+    });
+    hooks.BeforeTool = preFiltered;
+
+    // --- AfterTool (audit logging) ---
+    if (!Array.isArray(hooks.AfterTool)) {
+      hooks.AfterTool = [];
+    }
+    const postFiltered = filterElydoraEntries(hooks.AfterTool as Array<Record<string, unknown>>);
+    postFiltered.push({
+      hooks: [{ type: 'command', command: buildHookCommand(config.hookScriptPath) }],
+    });
+    hooks.AfterTool = postFiltered;
+
+    settings.hooks = hooks;
+    await fsp.writeFile(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  },
+
+  async uninstall(): Promise<void> {
+    const configPath = resolveConfigPath();
+
+    let settings: Record<string, unknown>;
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      settings = JSON.parse(raw);
+    } catch {
+      return;
+    }
+
+    const hooks = settings.hooks as Record<string, unknown> | undefined;
+    if (!hooks) return;
+
+    if (Array.isArray(hooks.BeforeTool)) {
+      hooks.BeforeTool = filterElydoraEntries(hooks.BeforeTool as Array<Record<string, unknown>>);
+    }
+    if (Array.isArray(hooks.AfterTool)) {
+      hooks.AfterTool = filterElydoraEntries(hooks.AfterTool as Array<Record<string, unknown>>);
+    }
+
+    await fsp.writeFile(configPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  },
+
+  async status(): Promise<PluginStatus> {
+    const configPath = resolveConfigPath();
+    const hookScriptPath = path.join(os.homedir(), '.elydora', 'hooks', `${AGENT_KEY}-hook.js`);
+
+    let hookConfigured = false;
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      const settings = JSON.parse(raw);
+      const hooks = settings.hooks as Record<string, unknown> | undefined;
+      if (hooks) {
+        const checkArr = (arr: unknown) => {
+          if (!Array.isArray(arr)) return false;
+          return (arr as Array<Record<string, unknown>>).some((entry) => {
+            if (Array.isArray(entry.hooks)) {
+              return (entry.hooks as Array<Record<string, unknown>>).some(
+                (h) => typeof h.command === 'string' && h.command.includes('elydora'),
+              );
+            }
+            return typeof entry.command === 'string' && entry.command.includes('elydora');
+          });
+        };
+        hookConfigured = checkArr(hooks.BeforeTool) && checkArr(hooks.AfterTool);
+      }
+    } catch {
+      // Config not readable
+    }
+
+    let hookScriptExists = false;
+    try {
+      await fsp.access(hookScriptPath);
+      hookScriptExists = true;
+    } catch {
+      // File doesn't exist
+    }
+
+    return {
+      installed: hookConfigured && hookScriptExists,
+      agentName: AGENT_KEY,
+      displayName: entry.name,
+      hookConfigured,
+      hookScriptExists,
+      configPath,
+    };
+  },
+};

src/plugins/hook-template.ts

@@ -0,0 +1,399 @@
+/**
+ * Generates a self-contained Node.js hook script that embeds all crypto logic
+ * inline so it has zero runtime dependency on the SDK.
+ */
+
+export function generateHookScript(agentName: string): string {
+  return `#!/usr/bin/env node
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Self-contained Elydora audit hook for: ${agentName}
+// Generated by @elydora/sdk — DO NOT EDIT
+// ---------------------------------------------------------------------------
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const AGENT_NAME = ${JSON.stringify(agentName)};
+const ELYDORA_DIR = path.join(os.homedir(), '.elydora');
+const CONFIG_PATH = path.join(ELYDORA_DIR, 'agents', AGENT_NAME + '.json');
+const KEY_PATH = path.join(ELYDORA_DIR, 'agents', AGENT_NAME + '.key');
+const CHAIN_STATE_PATH = path.join(ELYDORA_DIR, 'chain-state.json');
+const ERROR_LOG_PATH = path.join(ELYDORA_DIR, 'error.log');
+
+// ---------------------------------------------------------------------------
+// Embedded crypto (from @elydora/sdk src/crypto.ts + src/utils.ts)
+// ---------------------------------------------------------------------------
+
+function base64urlEncode(data) {
+  const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  return buf.toString('base64url');
+}
+
+function jcsCanonicalise(value) {
+  if (value === null || value === undefined) return 'null';
+  if (typeof value === 'boolean' || typeof value === 'number') return JSON.stringify(value);
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return '[' + value.map(v => jcsCanonicalise(v)).join(',') + ']';
+  }
+  if (typeof value === 'object') {
+    const keys = Object.keys(value).sort();
+    const pairs = [];
+    for (const key of keys) {
+      if (value[key] !== undefined) {
+        pairs.push(JSON.stringify(key) + ':' + jcsCanonicalise(value[key]));
+      }
+    }
+    return '{' + pairs.join(',') + '}';
+  }
+  return JSON.stringify(value);
+}
+
+function sha256Base64url(data) {
+  const input = typeof data === 'string' ? Buffer.from(data, 'utf-8') : data;
+  return base64urlEncode(crypto.createHash('sha256').update(input).digest());
+}
+
+function computePayloadHash(payload) {
+  return sha256Base64url(jcsCanonicalise(payload));
+}
+
+function computeChainHash(prevChainHash, payloadHash, operationId, issuedAt) {
+  const input = prevChainHash + '|' + payloadHash + '|' + operationId + '|' + issuedAt;
+  return sha256Base64url(input);
+}
+
+const PKCS8_ED25519_PREFIX = Buffer.from([
+  0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05,
+  0x06, 0x03, 0x2b, 0x65, 0x70, 0x04, 0x22, 0x04, 0x20,
+]);
+
+function signEd25519(privateKeyBase64url, data) {
+  const seed = Buffer.from(privateKeyBase64url, 'base64url');
+  const pkcs8 = Buffer.concat([PKCS8_ED25519_PREFIX, seed]);
+  const keyObject = crypto.createPrivateKey({ key: pkcs8, format: 'der', type: 'pkcs8' });
+  const signature = crypto.sign(null, data, keyObject);
+  return base64urlEncode(signature);
+}
+
+const ZERO_CHAIN_HASH = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA';
+
+function uuidv7() {
+  const now = Date.now();
+  const random = crypto.randomBytes(10);
+  const bytes = Buffer.alloc(16);
+  bytes[0] = (now / 2 ** 40) & 0xff;
+  bytes[1] = (now / 2 ** 32) & 0xff;
+  bytes[2] = (now / 2 ** 24) & 0xff;
+  bytes[3] = (now / 2 ** 16) & 0xff;
+  bytes[4] = (now / 2 ** 8) & 0xff;
+  bytes[5] = now & 0xff;
+  bytes[6] = 0x70 | (random[0] & 0x0f);
+  bytes[7] = random[1];
+  bytes[8] = 0x80 | (random[2] & 0x3f);
+  bytes[9] = random[3];
+  bytes[10] = random[4];
+  bytes[11] = random[5];
+  bytes[12] = random[6];
+  bytes[13] = random[7];
+  bytes[14] = random[8];
+  bytes[15] = random[9];
+  const hex = bytes.toString('hex');
+  return (
+    hex.slice(0, 8) + '-' +
+    hex.slice(8, 12) + '-' +
+    hex.slice(12, 16) + '-' +
+    hex.slice(16, 20) + '-' +
+    hex.slice(20, 32)
+  );
+}
+
+function generateNonce() {
+  return base64urlEncode(crypto.randomBytes(16));
+}
+
+// ---------------------------------------------------------------------------
+// Chain state persistence (atomic writes)
+// ---------------------------------------------------------------------------
+
+function readChainState() {
+  try {
+    const raw = fs.readFileSync(CHAIN_STATE_PATH, 'utf-8');
+    const state = JSON.parse(raw);
+    return state.prev_chain_hash || ZERO_CHAIN_HASH;
+  } catch {
+    return ZERO_CHAIN_HASH;
+  }
+}
+
+function writeChainState(chainHash) {
+  const tmpPath = CHAIN_STATE_PATH + '.tmp';
+  fs.writeFileSync(tmpPath, JSON.stringify({ prev_chain_hash: chainHash }), 'utf-8');
+  try {
+    fs.renameSync(tmpPath, CHAIN_STATE_PATH);
+  } catch (err) {
+    if (err.code === 'EPERM' || err.code === 'EEXIST') {
+      try { fs.unlinkSync(CHAIN_STATE_PATH); } catch { /* ignore */ }
+      fs.renameSync(tmpPath, CHAIN_STATE_PATH);
+    } else {
+      throw err;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Error logging
+// ---------------------------------------------------------------------------
+
+function logError(err) {
+  try {
+    const ts = new Date().toISOString();
+    const msg = ts + ' [' + AGENT_NAME + '] ' + (err.stack || err.message || String(err)) + '\\n';
+    fs.appendFileSync(ERROR_LOG_PATH, msg, 'utf-8');
+  } catch {
+    // Silently ignore logging failures
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main hook logic
+// ---------------------------------------------------------------------------
+
+async function main() {
+  try {
+    // Read JSON from stdin
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    const rawInput = Buffer.concat(chunks).toString('utf-8').trim();
+    if (!rawInput) return;
+
+    let hookData;
+    try {
+      hookData = JSON.parse(rawInput);
+    } catch {
+      return;
+    }
+
+    // Extract tool_name and tool_input from hook data
+    // Different agents may pass data in different shapes
+    const toolName = hookData.tool_name || hookData.toolName || hookData.name || 'unknown';
+    const toolInput = hookData.tool_input || hookData.toolInput || hookData.input || hookData.parameters || {};
+    const sessionId = hookData.session_id || hookData.sessionId || hookData.session || 'unknown';
+
+    // Read agent config and private key
+    let config;
+    let privateKey;
+    try {
+      config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+      privateKey = fs.readFileSync(KEY_PATH, 'utf-8').trim();
+    } catch (err) {
+      logError(new Error('Failed to read agent config/key: ' + err.message));
+      return;
+    }
+
+    const orgId = config.org_id;
+    const agentId = config.agent_id;
+    const kid = config.kid;
+    const baseUrl = (config.base_url || 'https://api.elydora.com').replace(/\\/+$/, '');
+    const token = config.token || '';
+
+    // Read chain state
+    const prevChainHash = readChainState();
+
+    // Build EOR
+    const operationId = uuidv7();
+    const issuedAt = Date.now();
+    const nonce = generateNonce();
+
+    const payload = {
+      tool_name: toolName,
+      tool_input: toolInput,
+      session_id: sessionId,
+    };
+
+    const payloadHash = computePayloadHash(payload);
+    const chainHash = computeChainHash(prevChainHash, payloadHash, operationId, issuedAt);
+
+    const eorWithoutSig = {
+      op_version: '1.0',
+      operation_id: operationId,
+      org_id: orgId,
+      agent_id: agentId,
+      issued_at: issuedAt,
+      ttl_ms: 30000,
+      nonce: nonce,
+      operation_type: 'ai.tool_use',
+      subject: { session_id: sessionId },
+      action: { tool: toolName },
+      payload: payload,
+      payload_hash: payloadHash,
+      prev_chain_hash: prevChainHash,
+      agent_pubkey_kid: kid,
+    };
+
+    const canonical = jcsCanonicalise(eorWithoutSig);
+    const signature = signEd25519(privateKey, Buffer.from(canonical, 'utf-8'));
+
+    const eor = Object.assign({}, eorWithoutSig, { chain_hash: chainHash, signature: signature });
+
+    // POST to /v1/operations (5s timeout)
+    // Only update local chain state on success to prevent desync
+    const url = baseUrl + '/v1/operations';
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+
+    try {
+      const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      };
+      if (token) {
+        headers['Authorization'] = 'Bearer ' + token;
+      }
+
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: headers,
+        body: JSON.stringify(eor),
+        signal: controller.signal,
+      });
+
+      if (res.ok) {
+        // Server accepted — safe to advance local chain state
+        writeChainState(chainHash);
+      } else if (res.status === 400) {
+        // Possible chain hash mismatch — try to resync from server response
+        try {
+          const errBody = await res.json();
+          if (errBody.error && errBody.error.code === 'PREV_HASH_MISMATCH') {
+            // Extract the expected hash from the error message
+            const match = (errBody.error.message || '').match(/Expected prev_chain_hash "([^"]+)"/);
+            if (match) {
+              writeChainState(match[1]);
+              logError(new Error('Chain hash resynced to server: ' + match[1]));
+            }
+          }
+        } catch { /* ignore parse errors */ }
+      }
+    } catch {
+      // Network error — don't advance chain state, will retry with same prev_chain_hash
+    } finally {
+      clearTimeout(timeout);
+    }
+  } catch (err) {
+    logError(err);
+  }
+}
+
+main();
+`;
+}
+
+/**
+ * Generates a lightweight PreToolUse guard script that checks if the agent
+ * is frozen and blocks tool execution if so.
+ *
+ * - Caches the agent status locally (60s TTL) to avoid hitting the API on every tool call
+ * - Fails open: if the API is unreachable, tool execution is allowed
+ * - If frozen: exits with code 1 to block the tool
+ */
+export function generateGuardScript(agentName: string): string {
+  return `#!/usr/bin/env node
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Elydora agent guard (PreToolUse) for: ${agentName}
+// Generated by @elydora/sdk — DO NOT EDIT
+// ---------------------------------------------------------------------------
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const AGENT_NAME = ${JSON.stringify(agentName)};
+const ELYDORA_DIR = path.join(os.homedir(), '.elydora');
+const CONFIG_PATH = path.join(ELYDORA_DIR, 'agents', AGENT_NAME + '.json');
+const STATUS_CACHE_PATH = path.join(ELYDORA_DIR, 'agents', AGENT_NAME + '.status.json');
+const CACHE_TTL_MS = 60000; // 60 seconds
+
+// Discard stdin immediately so the process can exit cleanly
+process.stdin.destroy();
+
+async function main() {
+  // Read agent config
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch {
+    return; // Can't read config — fail-open (allow)
+  }
+
+  // Check cached status
+  try {
+    const raw = fs.readFileSync(STATUS_CACHE_PATH, 'utf-8');
+    const cache = JSON.parse(raw);
+    const age = Date.now() - (cache.cached_at || 0);
+
+    if (age < CACHE_TTL_MS) {
+      if (cache.status === 'frozen') {
+        process.stderr.write('Agent "' + AGENT_NAME + '" is frozen by Elydora. Tool execution blocked.\\n');
+        process.exitCode = 2;
+      }
+      return; // Cache is fresh — use cached result
+    }
+  } catch {
+    // No cache or invalid — need to check API
+  }
+
+  // Fetch agent status from API
+  const baseUrl = (config.base_url || 'https://api.elydora.com').replace(/\\/+$/, '');
+  const token = config.token || '';
+  const agentId = config.agent_id;
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3000);
+
+    const headers = { 'Accept': 'application/json' };
+    if (token) {
+      headers['Authorization'] = 'Bearer ' + token;
+    }
+
+    const res = await fetch(baseUrl + '/v1/agents/' + encodeURIComponent(agentId), {
+      headers: headers,
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
+
+    if (res.ok) {
+      const data = await res.json();
+      const agentStatus = (data.agent && data.agent.status) || 'active';
+
+      // Update cache
+      try {
+        fs.writeFileSync(STATUS_CACHE_PATH, JSON.stringify({
+          status: agentStatus,
+          cached_at: Date.now(),
+        }), 'utf-8');
+      } catch {
+        // Ignore cache write failures
+      }
+
+      if (agentStatus === 'frozen') {
+        process.stderr.write('Agent "' + AGENT_NAME + '" is frozen by Elydora. Tool execution blocked.\\n');
+        process.exitCode = 2;
+      }
+    }
+  } catch {
+    // API unreachable — fail-open (allow)
+  }
+}
+
+main();
+`;
+}

src/plugins/kiro.ts

@@ -0,0 +1,84 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { AgentPlugin, InstallConfig, PluginStatus } from './base.js';
+import { SUPPORTED_AGENTS } from './registry.js';
+
+const AGENT_KEY = 'kiro';
+const entry = SUPPORTED_AGENTS.get(AGENT_KEY)!;
+
+function resolveConfigDir(): string {
+  // .kiro/hooks is project-relative, but for global install use home dir
+  return path.join(os.homedir(), entry.configDir);
+}
+
+function resolveConfigPath(): string {
+  return path.join(resolveConfigDir(), entry.configFile);
+}
+
+export const kiroPlugin: AgentPlugin = {
+  async install(config: InstallConfig): Promise<void> {
+    const configDir = resolveConfigDir();
+    await fsp.mkdir(configDir, { recursive: true });
+
+    const configPath = resolveConfigPath();
+
+    const hookConfig = {
+      name: 'Elydora Audit',
+      description: 'Sends tool-use events to the Elydora tamper-evident audit platform',
+      version: '1.0.0',
+      hooks: {
+        pre_tool_use: {
+          command: `node "${config.guardScriptPath}"`,
+          timeout_ms: 5000,
+        },
+        post_tool_use: {
+          command: `node "${config.hookScriptPath}"`,
+          timeout_ms: 5000,
+        },
+      },
+    };
+
+    await fsp.writeFile(configPath, JSON.stringify(hookConfig, null, 2) + '\n', 'utf-8');
+  },
+
+  async uninstall(): Promise<void> {
+    const configPath = resolveConfigPath();
+    try {
+      await fsp.unlink(configPath);
+    } catch {
+      // Already removed
+    }
+  },
+
+  async status(): Promise<PluginStatus> {
+    const configPath = resolveConfigPath();
+    const hookScriptPath = path.join(os.homedir(), '.elydora', 'hooks', `${AGENT_KEY}-hook.js`);
+
+    let hookConfigured = false;
+    try {
+      const raw = await fsp.readFile(configPath, 'utf-8');
+      const config = JSON.parse(raw);
+      hookConfigured = !!(config.hooks && config.hooks.pre_tool_use && config.hooks.post_tool_use);
+    } catch {
+      // Config not readable
+    }
+
+    let hookScriptExists = false;
+    try {
+      await fsp.access(hookScriptPath);
+      hookScriptExists = true;
+    } catch {
+      // File doesn't exist
+    }
+
+    return {
+      installed: hookConfigured && hookScriptExists,
+      agentName: AGENT_KEY,
+      displayName: entry.name,
+      hookConfigured,
+      hookScriptExists,
+      configPath,
+    };
+  },
+};

src/plugins/opencode.ts

@@ -0,0 +1,122 @@
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { AgentPlugin, InstallConfig, PluginStatus } from './base.js';
+import { SUPPORTED_AGENTS } from './registry.js';
+
+const AGENT_KEY = 'opencode';
+const entry = SUPPORTED_AGENTS.get(AGENT_KEY)!;
+
+function resolveConfigDir(): string {
+  // .opencode/plugins is project-relative, but for global install use home dir
+  return path.join(os.homedir(), entry.configDir);
+}
+
+function resolveConfigPath(): string {
+  return path.join(resolveConfigDir(), entry.configFile);
+}
+
+function generatePluginScript(hookScriptPath: string, guardScriptPath: string): string {
+  return `// Elydora Audit Plugin for OpenCode
+// Generated by @elydora/sdk — DO NOT EDIT
+
+const { spawn, spawnSync } = require('node:child_process');
+
+module.exports = {
+  name: 'elydora-audit',
+  version: '1.0.0',
+  description: 'Sends tool-use events to the Elydora tamper-evident audit platform',
+
+  hooks: {
+    preToolUse(context) {
+      // Synchronous guard — blocks tool if agent is frozen
+      try {
+        const result = spawnSync('node', ['__ELYDORA_GUARD_SCRIPT_PATH__'], {
+          timeout: 5000,
+          stdio: ['pipe', 'ignore', 'pipe'],
+        });
+        if (result.status !== 0) {
+          const msg = result.stderr ? result.stderr.toString().trim() : 'Agent is frozen by Elydora.';
+          return { blocked: true, reason: msg };
+        }
+      } catch {
+        // Fail-open — allow if guard can't run
+      }
+    },
+
+    postToolUse(context) {
+      try {
+        const input = JSON.stringify({
+          tool_name: context.toolName || context.tool_name || 'unknown',
+          tool_input: context.toolInput || context.tool_input || {},
+          session_id: context.sessionId || context.session_id || 'unknown',
+        });
+
+        const child = spawn('node', ['__ELYDORA_HOOK_SCRIPT_PATH__'], {
+          detached: true,
+          stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        child.stdin.write(input);
+        child.stdin.end();
+        child.unref();
+      } catch {
+        // Fire-and-forget — never block the developer
+      }
+    },
+  },
+};
+`;
+}
+
+export const opencodePlugin: AgentPlugin = {
+  async install(config: InstallConfig): Promise<void> {
+    const configDir = resolveConfigDir();
+    await fsp.mkdir(configDir, { recursive: true });
+
+    const configPath = resolveConfigPath();
+    const script = generatePluginScript(config.hookScriptPath, config.guardScriptPath)
+      .replace('__ELYDORA_HOOK_SCRIPT_PATH__', config.hookScriptPath.replace(/\\/g, '\\\\'))
+      .replace('__ELYDORA_GUARD_SCRIPT_PATH__', config.guardScriptPath.replace(/\\/g, '\\\\'));
+
+    await fsp.writeFile(configPath, script, 'utf-8');
+  },
+
+  async uninstall(): Promise<void> {
+    const configPath = resolveConfigPath();
+    try {
+      await fsp.unlink(configPath);
+    } catch {
+      // Already removed
+    }
+  },
+
+  async status(): Promise<PluginStatus> {
+    const configPath = resolveConfigPath();
+    const hookScriptPath = path.join(os.homedir(), '.elydora', 'hooks', `${AGENT_KEY}-hook.js`);
+
+    let hookConfigured = false;
+    try {
+      await fsp.access(configPath);
+      hookConfigured = true;
+    } catch {
+      // File doesn't exist
+    }
+
+    let hookScriptExists = false;
+    try {
+      await fsp.access(hookScriptPath);
+      hookScriptExists = true;
+    } catch {
+      // File doesn't exist
+    }
+
+    return {
+      installed: hookConfigured && hookScriptExists,
+      agentName: AGENT_KEY,
+      displayName: entry.name,
+      hookConfigured,
+      hookScriptExists,
+      configPath,
+    };
+  },
+};

src/plugins/registry.ts

@@ -0,0 +1,14 @@
+export interface AgentRegistryEntry {
+  readonly name: string;
+  readonly configDir: string;
+  readonly configFile: string;
+}
+
+export const SUPPORTED_AGENTS: ReadonlyMap<string, AgentRegistryEntry> = new Map([
+  ['claudecode', { name: 'Claude Code', configDir: '~/.claude', configFile: 'settings.json' }],
+  ['cursor', { name: 'Cursor', configDir: '.cursor', configFile: 'hooks.json' }],
+  ['gemini', { name: 'Gemini CLI', configDir: '~/.gemini', configFile: 'settings.json' }],
+  ['augment', { name: 'Augment Code', configDir: '~/.augment', configFile: 'settings.json' }],
+  ['kiro', { name: 'Kiro', configDir: '.kiro/hooks', configFile: 'elydora-audit.kiro.hook' }],
+  ['opencode', { name: 'OpenCode', configDir: '.opencode/plugins', configFile: 'elydora-audit.js' }],
+]);