openfused 0.2.0 → 0.3.0

package/dist/crypto.js

@@ -1,55 +1,116 @@
-import { generateKeyPairSync, sign, verify, createPrivateKey, createPublicKey } from "node:crypto";
+import { generateKeyPairSync, sign, verify, createPrivateKey, createPublicKey, createHash } from "node:crypto";
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
+import { Encrypter, Decrypter, generateIdentity, identityToRecipient } from "age-encryption";
 const KEY_DIR = ".keys";
+// --- Key generation ---
 export async function generateKeys(storeRoot) {
     const keyDir = join(storeRoot, KEY_DIR);
     await mkdir(keyDir, { recursive: true });
-    const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
-        publicKeyEncoding: { type: "spki", format: "pem" },
-        privateKeyEncoding: { type: "pkcs8", format: "pem" },
-    });
-    await writeFile(join(keyDir, "public.pem"), publicKey, { mode: 0o644 });
-    await writeFile(join(keyDir, "private.pem"), privateKey, { mode: 0o600 });
-    return { publicKey, privateKey };
+    // Ed25519 signing keypair
+    const { publicKey: pubObj, privateKey: privObj } = generateKeyPairSync("ed25519");
+    const pubJwk = pubObj.export({ format: "jwk" });
+    const privJwk = privObj.export({ format: "jwk" });
+    const publicHex = Buffer.from(pubJwk.x, "base64url").toString("hex");
+    const privateHex = Buffer.from(privJwk.d, "base64url").toString("hex");
+    await writeFile(join(keyDir, "public.key"), publicHex, { mode: 0o644 });
+    await writeFile(join(keyDir, "private.key"), privateHex, { mode: 0o600 });
+    // age encryption keypair
+    const ageIdentity = await generateIdentity();
+    const ageRecipient = await identityToRecipient(ageIdentity);
+    await writeFile(join(keyDir, "age.key"), ageIdentity, { mode: 0o600 });
+    await writeFile(join(keyDir, "age.pub"), ageRecipient, { mode: 0o644 });
+    return { publicKey: publicHex, encryptionKey: ageRecipient };
 }
 export async function hasKeys(storeRoot) {
-    return existsSync(join(storeRoot, KEY_DIR, "private.pem"));
+    return existsSync(join(storeRoot, KEY_DIR, "private.key"));
 }
+// --- Fingerprint ---
+export function fingerprint(publicKey) {
+    const hash = createHash("sha256").update(publicKey).digest();
+    const pairs = [];
+    for (let i = 0; i < 16; i++) {
+        pairs.push(hash[i].toString(16).toUpperCase().padStart(2, "0"));
+    }
+    const groups = [];
+    for (let i = 0; i < pairs.length; i += 2) {
+        groups.push(pairs[i] + pairs[i + 1]);
+    }
+    return groups.join(":");
+}
+// --- Signing ---
 async function loadPrivateKey(storeRoot) {
-    const pem = await readFile(join(storeRoot, KEY_DIR, "private.pem"), "utf-8");
-    return createPrivateKey(pem);
+    const privHex = (await readFile(join(storeRoot, KEY_DIR, "private.key"), "utf-8")).trim();
+    const pubHex = (await readFile(join(storeRoot, KEY_DIR, "public.key"), "utf-8")).trim();
+    const d = Buffer.from(privHex, "hex").toString("base64url");
+    const x = Buffer.from(pubHex, "hex").toString("base64url");
+    return createPrivateKey({ key: { kty: "OKP", crv: "Ed25519", d, x }, format: "jwk" });
 }
-async function loadPublicKey(storeRoot) {
-    return readFile(join(storeRoot, KEY_DIR, "public.pem"), "utf-8");
+async function loadPublicKeyHex(storeRoot) {
+    return (await readFile(join(storeRoot, KEY_DIR, "public.key"), "utf-8")).trim();
+}
+export async function loadAgeRecipient(storeRoot) {
+    return (await readFile(join(storeRoot, KEY_DIR, "age.pub"), "utf-8")).trim();
+}
+async function loadAgeIdentity(storeRoot) {
+    return (await readFile(join(storeRoot, KEY_DIR, "age.key"), "utf-8")).trim();
 }
 export async function signMessage(storeRoot, from, message) {
     const privateKey = await loadPrivateKey(storeRoot);
-    const publicKey = await loadPublicKey(storeRoot);
+    const publicKey = await loadPublicKeyHex(storeRoot);
     const timestamp = new Date().toISOString();
     const payload = Buffer.from(`${from}\n${timestamp}\n${message}`);
     const signature = sign(null, payload, privateKey).toString("base64");
-    return { from, timestamp, message, signature, publicKey };
+    return { from, timestamp, message, signature, publicKey, encrypted: false };
+}
+export async function signAndEncrypt(storeRoot, from, plaintext, recipientAgeKey) {
+    const ciphertext = await ageEncrypt(plaintext, recipientAgeKey);
+    const encoded = Buffer.from(ciphertext).toString("base64");
+    const privateKey = await loadPrivateKey(storeRoot);
+    const publicKey = await loadPublicKeyHex(storeRoot);
+    const timestamp = new Date().toISOString();
+    const payload = Buffer.from(`${from}\n${timestamp}\n${encoded}`);
+    const signature = sign(null, payload, privateKey).toString("base64");
+    return { from, timestamp, message: encoded, signature, publicKey, encrypted: true };
 }
 export function verifyMessage(signed) {
     try {
         const payload = Buffer.from(`${signed.from}\n${signed.timestamp}\n${signed.message}`);
-        const pubKey = createPublicKey(signed.publicKey);
+        const x = Buffer.from(signed.publicKey.trim(), "hex").toString("base64url");
+        const pubKey = createPublicKey({ key: { kty: "OKP", crv: "Ed25519", x }, format: "jwk" });
         return verify(null, payload, pubKey, Buffer.from(signed.signature, "base64"));
     }
     catch {
         return false;
     }
 }
-// Wrap a message in security tags for the LLM
+export async function decryptMessage(storeRoot, signed) {
+    if (!signed.encrypted)
+        return signed.message;
+    const ciphertext = Buffer.from(signed.message, "base64");
+    return await ageDecrypt(ciphertext, storeRoot);
+}
+// --- age encryption ---
+async function ageEncrypt(plaintext, recipientKey) {
+    const e = new Encrypter();
+    e.addRecipient(recipientKey);
+    return await e.encrypt(plaintext);
+}
+async function ageDecrypt(ciphertext, storeRoot) {
+    const identity = await loadAgeIdentity(storeRoot);
+    const d = new Decrypter();
+    d.addIdentity(identity);
+    return await d.decrypt(ciphertext, "text");
+}
+// --- Helpers ---
 export function wrapExternalMessage(signed, verified) {
     const status = verified ? "verified" : "UNVERIFIED";
-    return `<external_message from="${signed.from}" verified="${verified}" time="${signed.timestamp}" status="${status}">
-${signed.message}
+    const esc = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    return `<external_message from="${esc(signed.from)}" verified="${verified}" time="${esc(signed.timestamp)}" status="${status}">
+${esc(signed.message)}
 </external_message>`;
 }
-// Format for writing to inbox files
 export function serializeSignedMessage(signed) {
     return JSON.stringify(signed, null, 2);
 }

package/dist/mcp.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { ContextStore } from "./store.js";
+import { resolve } from "node:path";
+/** Reject path traversal in filenames — extract basename, block dangerous patterns */
+function sanitizeFilename(name) {
+    // Extract basename (strip any directory components)
+    const base = name.split("/").pop().split("\\").pop();
+    if (!base || base === "." || base === ".." || base.includes("..")) {
+        throw new Error(`Invalid filename: ${name}`);
+    }
+    return base;
+}
+const storeDir = process.env.OPENFUSE_DIR || process.argv[3] || ".";
+const store = new ContextStore(resolve(storeDir));
+const server = new McpServer({
+    name: "openfuse",
+    version: "0.3.0",
+});
+// --- Context ---
+server.tool("context_read", "Read the agent's CONTEXT.md (working memory)", async () => {
+    const content = await store.readContext();
+    return { content: [{ type: "text", text: content }] };
+});
+server.tool("context_write", "Replace CONTEXT.md contents", { text: z.string().describe("New content for CONTEXT.md") }, async ({ text }) => {
+    await store.writeContext(text);
+    return { content: [{ type: "text", text: "Context updated." }] };
+});
+server.tool("context_append", "Append text to CONTEXT.md", { text: z.string().describe("Text to append") }, async ({ text }) => {
+    const existing = await store.readContext();
+    await store.writeContext(existing + "\n" + text);
+    return { content: [{ type: "text", text: "Context appended." }] };
+});
+// --- Soul ---
+server.tool("soul_read", "Read the agent's SOUL.md (identity & rules)", async () => {
+    const content = await store.readSoul();
+    return { content: [{ type: "text", text: content }] };
+});
+server.tool("soul_write", "Replace SOUL.md contents", { text: z.string().describe("New content for SOUL.md") }, async ({ text }) => {
+    await store.writeSoul(text);
+    return { content: [{ type: "text", text: "Soul updated." }] };
+});
+// --- Inbox ---
+server.tool("inbox_list", "List all inbox messages with verification status", async () => {
+    const messages = await store.readInbox();
+    if (messages.length === 0) {
+        return { content: [{ type: "text", text: "Inbox is empty." }] };
+    }
+    const lines = messages.map((m) => {
+        const badge = m.verified ? "[VERIFIED]" : "[UNVERIFIED]";
+        return `${badge} From: ${m.from} | ${m.time}\n${m.wrappedContent}`;
+    });
+    return { content: [{ type: "text", text: lines.join("\n\n---\n\n") }] };
+});
+server.tool("inbox_send", "Send a signed message to a peer's inbox (auto-encrypts if age key on file)", {
+    peer_id: z.string().describe("Peer name or ID"),
+    message: z.string().describe("Message content"),
+}, async ({ peer_id, message }) => {
+    await store.sendInbox(peer_id, message);
+    return { content: [{ type: "text", text: `Message sent to ${peer_id}'s inbox.` }] };
+});
+// --- Shared ---
+server.tool("shared_list", "List files in the shared/ directory", async () => {
+    const files = await store.listShared();
+    if (files.length === 0) {
+        return { content: [{ type: "text", text: "No shared files." }] };
+    }
+    return { content: [{ type: "text", text: files.join("\n") }] };
+});
+server.tool("shared_read", "Read a file from shared/", { filename: z.string().describe("Filename in shared/") }, async ({ filename }) => {
+    const safeName = sanitizeFilename(filename);
+    const { readFile } = await import("node:fs/promises");
+    const { join } = await import("node:path");
+    const content = await readFile(join(store.root, "shared", safeName), "utf-8");
+    return { content: [{ type: "text", text: content }] };
+});
+server.tool("shared_write", "Write a file to shared/", {
+    filename: z.string().describe("Filename to create in shared/"),
+    content: z.string().describe("File content"),
+}, async ({ filename, content }) => {
+    const safeName = sanitizeFilename(filename);
+    await store.share(safeName, content);
+    return { content: [{ type: "text", text: `Shared: ${safeName}` }] };
+});
+// --- Status ---
+server.tool("status", "Get context store status (agent, peers, inbox count)", async () => {
+    const s = await store.status();
+    const text = [
+        `Agent: ${s.name} (${s.id})`,
+        `Peers: ${s.peers}`,
+        `Inbox: ${s.inboxCount} messages`,
+        `Shared: ${s.sharedCount} files`,
+    ].join("\n");
+    return { content: [{ type: "text", text }] };
+});
+// --- Peers ---
+server.tool("peer_list", "List configured peers", async () => {
+    const config = await store.readConfig();
+    if (config.peers.length === 0) {
+        return { content: [{ type: "text", text: "No peers connected." }] };
+    }
+    const lines = config.peers.map((p) => `${p.name} (${p.id}) — ${p.url} [${p.access}]`);
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+});
+server.tool("peer_add", "Add a peer by URL (http:// for WAN, ssh://host:/path for LAN)", {
+    url: z.string().describe("Peer URL"),
+    name: z.string().describe("Peer name"),
+    access: z.enum(["read", "readwrite"]).default("read").describe("Access mode"),
+}, async ({ url, name, access }) => {
+    const { nanoid } = await import("nanoid");
+    const config = await store.readConfig();
+    const peerId = nanoid(12);
+    config.peers.push({ id: peerId, name, url, access });
+    await store.writeConfig(config);
+    return { content: [{ type: "text", text: `Added peer: ${name} (${url}) [${access}]` }] };
+});
+// --- Start ---
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/registry.d.ts

@@ -0,0 +1,22 @@
+import { ContextStore } from "./store.js";
+export declare const DEFAULT_REGISTRY = "https://openfuse-registry.wzmcghee.workers.dev";
+export interface Manifest {
+    name: string;
+    endpoint: string;
+    publicKey: string;
+    encryptionKey?: string;
+    fingerprint: string;
+    created: string;
+    capabilities: string[];
+    description?: string;
+    signature?: string;
+    signedAt?: string;
+    revoked?: boolean;
+    revokedAt?: string;
+    rotatedFrom?: string;
+}
+export declare function resolveRegistry(flag?: string): string;
+export declare function register(store: ContextStore, endpoint: string, registry: string): Promise<Manifest>;
+export declare function discover(name: string, registry: string): Promise<Manifest>;
+export declare function revoke(store: ContextStore, registry: string): Promise<void>;
+export declare function checkUpdate(currentVersion: string): Promise<string | null>;

package/dist/registry.js

@@ -0,0 +1,78 @@
+import { signMessage, fingerprint } from "./crypto.js";
+export const DEFAULT_REGISTRY = "https://openfuse-registry.wzmcghee.workers.dev";
+export function resolveRegistry(flag) {
+    return flag || process.env.OPENFUSE_REGISTRY || DEFAULT_REGISTRY;
+}
+export async function register(store, endpoint, registry) {
+    const config = await store.readConfig();
+    if (!config.publicKey)
+        throw new Error("No signing key — run `openfuse init` first");
+    const manifest = {
+        name: config.name,
+        endpoint,
+        publicKey: config.publicKey,
+        encryptionKey: config.encryptionKey,
+        fingerprint: fingerprint(config.publicKey),
+        created: new Date().toISOString(),
+        capabilities: ["inbox", "shared", "knowledge"],
+    };
+    const canonical = `${manifest.name}|${manifest.endpoint}|${manifest.publicKey}|${manifest.encryptionKey || ""}`;
+    const signed = await signMessage(store.root, manifest.name, canonical);
+    manifest.signature = signed.signature;
+    manifest.signedAt = signed.timestamp;
+    const resp = await fetch(`${registry.replace(/\/$/, "")}/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(manifest),
+    });
+    if (!resp.ok) {
+        const body = await resp.json().catch(() => ({ error: `HTTP ${resp.status}` }));
+        throw new Error(body.error || `Registry returned ${resp.status}`);
+    }
+    return manifest;
+}
+export async function discover(name, registry) {
+    const resp = await fetch(`${registry.replace(/\/$/, "")}/discover/${name}`);
+    if (!resp.ok) {
+        const body = await resp.json().catch(() => ({ error: `HTTP ${resp.status}` }));
+        throw new Error(body.error || `Agent '${name}' not found`);
+    }
+    return (await resp.json());
+}
+export async function revoke(store, registry) {
+    const config = await store.readConfig();
+    if (!config.publicKey)
+        throw new Error("No signing key");
+    const revokeMsg = `REVOKE:${config.publicKey}`;
+    const signed = await signMessage(store.root, config.name, revokeMsg);
+    const resp = await fetch(`${registry.replace(/\/$/, "")}/revoke`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            name: config.name,
+            signature: signed.signature,
+            signedAt: signed.timestamp,
+        }),
+    });
+    if (!resp.ok) {
+        const body = await resp.json().catch(() => ({ error: `HTTP ${resp.status}` }));
+        throw new Error(body.error || `Revocation failed`);
+    }
+}
+export async function checkUpdate(currentVersion) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+        const resp = await fetch(DEFAULT_REGISTRY, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!resp.ok)
+            return null;
+        const body = (await resp.json());
+        if (body.latest && body.latest !== currentVersion)
+            return body.latest;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/store.d.ts

@@ -1,9 +1,12 @@
+import { type KeyringEntry } from "./crypto.js";
 export interface MeshConfig {
     id: string;
     name: string;
     created: string;
     publicKey?: string;
+    encryptionKey?: string;
     peers: PeerConfig[];
+    keyring: KeyringEntry[];
     trustedKeys?: string[];
 }
 export interface PeerConfig {
@@ -33,6 +36,7 @@ export declare class ContextStore {
         from: string;
         time: string;
         verified: boolean;
+        encrypted: boolean;
     }>>;
     listShared(): Promise<string[]>;
     share(filename: string, content: string): Promise<void>;

package/dist/store.js

@@ -1,8 +1,8 @@
 import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { existsSync } from "node:fs";
-import { generateKeys, signMessage, verifyMessage, deserializeSignedMessage, serializeSignedMessage, wrapExternalMessage } from "./crypto.js";
-const STORE_DIRS = ["history", "knowledge", "inbox", "outbox", "shared"];
+import { generateKeys, signMessage, signAndEncrypt, verifyMessage, decryptMessage, deserializeSignedMessage, serializeSignedMessage, wrapExternalMessage, fingerprint, } from "./crypto.js";
+const STORE_DIRS = ["history", "knowledge", "inbox", "outbox", "shared", ".peers"];
 export class ContextStore {
     root;
     constructor(root) {
@@ -15,7 +15,6 @@ export class ContextStore {
         return existsSync(this.configPath);
     }
     async init(name, id) {
-        // Create directory structure
         await mkdir(this.root, { recursive: true });
         for (const dir of STORE_DIRS) {
             await mkdir(join(this.root, dir), { recursive: true });
@@ -30,22 +29,44 @@ export class ContextStore {
                 await writeFile(destPath, content);
             }
         }
-        // Generate signing keypair
         const keys = await generateKeys(this.root);
-        // Write mesh config
         const config = {
             id,
             name,
             created: new Date().toISOString(),
             publicKey: keys.publicKey,
+            encryptionKey: keys.encryptionKey,
             peers: [],
-            trustedKeys: [],
+            keyring: [],
         };
         await this.writeConfig(config);
     }
     async readConfig() {
         const raw = await readFile(this.configPath, "utf-8");
-        return JSON.parse(raw);
+        const config = JSON.parse(raw);
+        // Migrate legacy trustedKeys → keyring
+        if (config.trustedKeys && config.trustedKeys.length > 0) {
+            if (!config.keyring)
+                config.keyring = [];
+            for (const key of config.trustedKeys) {
+                const k = key.trim();
+                if (!k || config.keyring.some((e) => e.signingKey === k))
+                    continue;
+                config.keyring.push({
+                    name: `migrated-${k.slice(0, 8)}`,
+                    address: "",
+                    signingKey: k,
+                    fingerprint: fingerprint(k),
+                    trusted: true,
+                    added: new Date().toISOString(),
+                });
+            }
+            delete config.trustedKeys;
+            await this.writeConfig(config);
+        }
+        if (!config.keyring)
+            config.keyring = [];
+        return config;
     }
     async writeConfig(config) {
         await writeFile(this.configPath, JSON.stringify(config, null, 2) + "\n");
@@ -62,14 +83,20 @@ export class ContextStore {
     async writeSoul(content) {
         await writeFile(join(this.root, "SOUL.md"), content);
     }
-    // --- Inbox (signed messages) ---
+    // --- Inbox ---
     async sendInbox(peerId, message) {
         const config = await this.readConfig();
-        const signed = await signMessage(this.root, config.id, message);
+        // Look up peer's encryption key in keyring
+        const entry = config.keyring.find((e) => e.name === peerId || e.address.startsWith(`${peerId}@`));
+        let signed;
+        if (entry?.encryptionKey) {
+            signed = await signAndEncrypt(this.root, config.id, message, entry.encryptionKey);
+        }
+        else {
+            signed = await signMessage(this.root, config.id, message);
+        }
         const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
         const filename = `${timestamp}_${peerId}.json`;
-        // Write to inbox (for the recipient) and outbox (our copy)
-        await writeFile(join(this.root, "inbox", filename), serializeSignedMessage(signed));
         await writeFile(join(this.root, "outbox", filename), serializeSignedMessage(signed));
     }
     async readInbox() {
@@ -81,22 +108,34 @@ export class ContextStore {
         const messages = [];
         for (const file of files.filter((f) => f.endsWith(".json") || f.endsWith(".md"))) {
             const raw = await readFile(join(inboxDir, file), "utf-8");
-            // Try parsing as signed message
             const signed = deserializeSignedMessage(raw);
             if (signed) {
-                const verified = verifyMessage(signed);
-                const trusted = config.trustedKeys?.some(k => k.trim() === signed.publicKey.trim()) ?? false;
+                const sigValid = verifyMessage(signed);
+                const trusted = config.keyring.some((k) => k.trusted && k.signingKey.trim() === signed.publicKey.trim());
+                const verified = sigValid && trusted;
+                let content;
+                if (signed.encrypted) {
+                    try {
+                        content = await decryptMessage(this.root, signed);
+                    }
+                    catch {
+                        content = "[encrypted — cannot decrypt]";
+                    }
+                }
+                else {
+                    content = signed.message;
+                }
                 messages.push({
                     file,
-                    content: signed.message,
-                    wrappedContent: wrapExternalMessage(signed, verified && trusted),
+                    content,
+                    wrappedContent: wrapExternalMessage(signed, verified),
                     from: signed.from,
                     time: signed.timestamp,
-                    verified: verified && trusted,
+                    verified,
+                    encrypted: !!signed.encrypted,
                 });
             }
             else {
-                // Unsigned message — mark as unverified
                 const parts = file.replace(/\.(md|json)$/, "").split("_");
                 const from = parts.slice(1).join("_");
                 messages.push({
@@ -106,6 +145,7 @@ export class ContextStore {
                     from,
                     time: parts[0],
                     verified: false,
+                    encrypted: false,
                 });
             }
         }
@@ -119,9 +159,14 @@ export class ContextStore {
         return readdir(sharedDir);
     }
     async share(filename, content) {
+        // Sanitize: extract basename, reject traversal
+        const base = filename.split("/").pop().split("\\").pop();
+        if (!base || base === "." || base === ".." || base.includes("..")) {
+            throw new Error(`Invalid filename: ${filename}`);
+        }
         const sharedDir = join(this.root, "shared");
         await mkdir(sharedDir, { recursive: true });
-        await writeFile(join(sharedDir, filename), content);
+        await writeFile(join(sharedDir, base), content);
     }
     // --- Status ---
     async status() {

package/dist/sync.d.ts

@@ -0,0 +1,9 @@
+import { ContextStore } from "./store.js";
+export interface SyncResult {
+    peerName: string;
+    pulled: string[];
+    pushed: string[];
+    errors: string[];
+}
+export declare function syncAll(store: ContextStore): Promise<SyncResult[]>;
+export declare function syncOne(store: ContextStore, peerName: string): Promise<SyncResult>;