openfused 0.3.7 → 0.3.10

package/dist/cli.js

@@ -6,9 +6,9 @@ import { watchInbox, watchContext, watchSync } from "./watch.js";
 import { syncAll, syncOne, deliverOne } from "./sync.js";
 import * as registry from "./registry.js";
 import { fingerprint } from "./crypto.js";
-import { resolve } from "node:path";
+import { resolve, join } from "node:path";
 import { readFile } from "node:fs/promises";
-const VERSION = "0.3.7";
+const VERSION = "0.3.10";
 const program = new Command();
 program
     .name("openfuse")
@@ -544,8 +544,8 @@ program
     const reg = registry.resolveRegistry(opts.registry);
     try {
         const manifest = await registry.discover(name, reg);
-        const config = await store.readConfig();
-        // Auto-import key (untrusted)
+        // Auto-import key + add as peer so `openfuse sync` works for replies
+        let config = await store.readConfig();
         if (!config.keyring.some((e) => e.signingKey === manifest.publicKey)) {
             config.keyring.push({
                 name: manifest.name,
@@ -556,17 +556,56 @@ program
                 trusted: false,
                 added: new Date().toISOString(),
             });
-            await store.writeConfig(config);
-            console.log(`Imported key for ${manifest.name} from registry [untrusted]`);
-            console.log(`  Run \`openfuse key trust ${manifest.name}\` to trust`);
         }
-        await store.sendInbox(name, message);
-        console.log(`Message queued in outbox for ${name}. Run \`openfuse sync\` to deliver.`);
+        if (manifest.endpoint && !config.peers.some((p) => p.name === manifest.name)) {
+            config.peers.push({
+                id: (await import("nanoid")).nanoid(12),
+                name: manifest.name,
+                url: manifest.endpoint,
+                access: "read",
+            });
+        }
+        await store.writeConfig(config);
+        const filename = await store.sendInbox(name, message);
+        // Try direct HTTP delivery if endpoint is http(s)
+        if (manifest.endpoint.startsWith("http")) {
+            try {
+                const body = await readFile(join(store.root, "outbox", filename), "utf-8");
+                const r = await fetch(`${manifest.endpoint.replace(/\/$/, "")}/inbox`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body,
+                });
+                if (r.ok) {
+                    // Archive to .sent/
+                    const { mkdir, rename } = await import("node:fs/promises");
+                    const sentDir = join(store.root, "outbox", ".sent");
+                    await mkdir(sentDir, { recursive: true });
+                    await rename(join(store.root, "outbox", filename), join(sentDir, filename));
+                    console.log(`Delivered to ${name}.`);
+                }
+                else {
+                    console.log(`Queued for ${name}. Endpoint returned ${r.status}. Will deliver on next sync.`);
+                }
+            }
+            catch {
+                console.log(`Queued for ${name}. Will deliver on next sync.`);
+            }
+        }
+        else {
+            console.log(`Queued for ${name}. Run \`openfuse sync\` to deliver.`);
+        }
     }
     catch {
         // Not in registry — send as a peer message
-        await store.sendInbox(name, message);
-        console.log(`Message sent to ${name}'s outbox.`);
+        const filename = await store.sendInbox(name, message);
+        const delivered = await deliverOne(store, name, filename);
+        if (delivered) {
+            console.log(`Delivered to ${name}.`);
+        }
+        else {
+            console.log(`Queued for ${name}. Run \`openfuse sync\` to deliver.`);
+        }
     }
 });
 program.parse();

package/dist/mcp.js

@@ -23,7 +23,7 @@ const storeDir = process.env.OPENFUSE_DIR || process.argv[3] || ".";
 const store = new ContextStore(resolve(storeDir));
 const server = new McpServer({
     name: "openfuse",
-    version: "0.3.7",
+    version: "0.3.10",
 });
 // --- Context ---
 server.tool("context_read", "Read the agent's CONTEXT.md (working memory)", async () => {

package/dist/registry.d.ts

@@ -1,5 +1,5 @@
 import { ContextStore } from "./store.js";
-export declare const DEFAULT_REGISTRY = "https://registry.openfused.dev";
+export declare const DEFAULT_REGISTRY = "https://openfuse-registry.wzmcghee.workers.dev";
 export interface Manifest {
     name: string;
     endpoint: string;

package/dist/registry.js

@@ -7,7 +7,8 @@
 // This is TOFU (Trust On First Use) done right: the registry distributes keys,
 // but never asserts trust. Trust is a local decision.
 import { signMessage, fingerprint } from "./crypto.js";
-export const DEFAULT_REGISTRY = "https://registry.openfused.dev";
+// Custom domain pending propagation — use Worker URL as fallback
+export const DEFAULT_REGISTRY = "https://openfuse-registry.wzmcghee.workers.dev";
 export function resolveRegistry(flag) {
     return flag || process.env.OPENFUSE_REGISTRY || DEFAULT_REGISTRY;
 }

package/dist/sync.js

@@ -153,6 +153,28 @@ async function syncHttp(store, peer, baseUrl, peerDir) {
             errors.push(`${dir}/: ${e.message}`);
         }
     }
+    // Pull peer's outbox for messages addressed to us (HTTP version)
+    const config = await store.readConfig();
+    const myName = config.name;
+    const inboxDir = join(store.root, "inbox");
+    await mkdir(inboxDir, { recursive: true });
+    try {
+        const resp = await fetch(`${baseUrl}/outbox/${myName}`);
+        if (resp.ok) {
+            const messages = (await resp.json());
+            for (const msg of messages) {
+                const ts = (msg.timestamp || new Date().toISOString()).replace(/[:.]/g, "-");
+                const from = msg.from || "unknown";
+                const fname = `${ts}_from-${from}_to-${myName}.json`;
+                const dest = join(inboxDir, fname);
+                if (!existsSync(dest)) {
+                    await writeFile(dest, JSON.stringify(msg, null, 2));
+                    pulled.push(`outbox→${fname}`);
+                }
+            }
+        }
+    }
+    catch { }
     // Push outbox → peer inbox
     const outboxDir = join(store.root, "outbox");
     if (existsSync(outboxDir)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openfused",
-  "version": "0.3.7",
+  "version": "0.3.10",
   "description": "The file protocol for AI agent context. Encrypted, signed, peer-to-peer.",
   "license": "MIT",
   "type": "module",