413 lines
16 KiB
TypeScript
413 lines
16 KiB
TypeScript
/**
|
|
* rAgents module — agent-to-agent exchange within spaces.
|
|
*
|
|
* Each space member's MI agent can register, post to topic channels,
|
|
* reply in threads, share structured data packages, and vote.
|
|
* Real-time sync via Automerge CRDTs.
|
|
*/
|
|
|
|
import { Hono } from "hono";
|
|
import * as Automerge from "@automerge/automerge";
|
|
import { renderShell } from "../../server/shell";
|
|
import { getModuleInfoList } from "../../shared/module";
|
|
import type { RSpaceModule } from "../../shared/module";
|
|
import { verifyToken, extractToken } from "../../server/auth";
|
|
import { renderLanding } from "./landing";
|
|
import type { SyncServer } from '../../server/local-first/sync-server';
|
|
import {
|
|
agentsDirectorySchema, agentChannelSchema,
|
|
agentsDirectoryDocId, agentChannelDocId,
|
|
} from './schemas';
|
|
import type {
|
|
AgentsDirectoryDoc, AgentChannelDoc,
|
|
AgentInfo, AgentPost,
|
|
} from './schemas';
|
|
|
|
let _syncServer: SyncServer | null = null;
|
|
|
|
const routes = new Hono();
|
|
|
|
// ── Default channels seeded on first access ──
|
|
|
|
const DEFAULT_CHANNELS = [
|
|
{ id: 'general', name: 'General', description: 'Open discussion between agents' },
|
|
{ id: 'packages', name: 'Packages', description: 'Share structured data packages and query results' },
|
|
];
|
|
|
|
// ── Local-first helpers ──
|
|
|
|
function ensureDirectoryDoc(space: string): AgentsDirectoryDoc {
|
|
const docId = agentsDirectoryDocId(space);
|
|
let doc = _syncServer!.getDoc<AgentsDirectoryDoc>(docId);
|
|
if (!doc) {
|
|
doc = Automerge.change(Automerge.init<AgentsDirectoryDoc>(), 'init agents directory', (d) => {
|
|
const init = agentsDirectorySchema.init();
|
|
Object.assign(d, init);
|
|
d.meta.spaceSlug = space;
|
|
for (const ch of DEFAULT_CHANNELS) {
|
|
d.channels[ch.id] = { id: ch.id, name: ch.name, description: ch.description, createdBy: null, createdAt: Date.now() };
|
|
}
|
|
});
|
|
_syncServer!.setDoc(docId, doc);
|
|
}
|
|
return doc;
|
|
}
|
|
|
|
function ensureChannelDoc(space: string, channelId: string): AgentChannelDoc {
|
|
const docId = agentChannelDocId(space, channelId);
|
|
let doc = _syncServer!.getDoc<AgentChannelDoc>(docId);
|
|
if (!doc) {
|
|
doc = Automerge.change(Automerge.init<AgentChannelDoc>(), 'init agent channel', (d) => {
|
|
const init = agentChannelSchema.init();
|
|
Object.assign(d, init);
|
|
d.meta.spaceSlug = space;
|
|
d.channelId = channelId;
|
|
});
|
|
_syncServer!.setDoc(docId, doc);
|
|
}
|
|
return doc;
|
|
}
|
|
|
|
function findAgentByOwner(doc: AgentsDirectoryDoc, ownerDID: string): AgentInfo | undefined {
|
|
return Object.values(doc.agents || {}).find(a => a.ownerDID === ownerDID);
|
|
}
|
|
|
|
// ── CRUD: Agents ──
|
|
|
|
routes.get("/api/agents", (c) => {
|
|
if (!_syncServer) return c.json({ agents: [] });
|
|
const space = c.req.param("space") || "demo";
|
|
const doc = ensureDirectoryDoc(space);
|
|
return c.json({ agents: Object.values(doc.agents || {}) });
|
|
});
|
|
|
|
routes.post("/api/agents", async (c) => {
|
|
const token = extractToken(c.req.raw.headers);
|
|
if (!token) return c.json({ error: "Authentication required" }, 401);
|
|
let claims: any;
|
|
try { claims = await verifyToken(token); } catch { return c.json({ error: "Invalid token" }, 401); }
|
|
if (!_syncServer) return c.json({ error: "Not initialized" }, 503);
|
|
|
|
const space = c.req.param("space") || "demo";
|
|
const { name, description = "", capabilities = [], avatarEmoji = "🤖" } = await c.req.json();
|
|
if (!name) return c.json({ error: "name required" }, 400);
|
|
|
|
const ownerDID = claims.did || claims.sub || '';
|
|
const ownerName = claims.displayName || claims.username || 'Anonymous';
|
|
const docId = agentsDirectoryDocId(space);
|
|
const dir = ensureDirectoryDoc(space);
|
|
|
|
// One agent per member per space
|
|
const existing = findAgentByOwner(dir, ownerDID);
|
|
if (existing) {
|
|
// Update existing agent
|
|
_syncServer.changeDoc<AgentsDirectoryDoc>(docId, `update agent ${existing.id}`, (d) => {
|
|
d.agents[existing.id].name = name;
|
|
d.agents[existing.id].description = description;
|
|
d.agents[existing.id].capabilities = capabilities;
|
|
d.agents[existing.id].avatarEmoji = avatarEmoji;
|
|
d.agents[existing.id].lastActiveAt = Date.now();
|
|
});
|
|
const updated = _syncServer.getDoc<AgentsDirectoryDoc>(docId)!;
|
|
return c.json(updated.agents[existing.id]);
|
|
}
|
|
|
|
const id = crypto.randomUUID();
|
|
_syncServer.changeDoc<AgentsDirectoryDoc>(docId, `register agent ${id}`, (d) => {
|
|
d.agents[id] = {
|
|
id, ownerDID, ownerName, name, description, capabilities, avatarEmoji,
|
|
registeredAt: Date.now(), lastActiveAt: Date.now(),
|
|
} as any;
|
|
});
|
|
const updated = _syncServer.getDoc<AgentsDirectoryDoc>(docId)!;
|
|
return c.json(updated.agents[id], 201);
|
|
});
|
|
|
|
routes.delete("/api/agents/:agentId", async (c) => {
|
|
const token = extractToken(c.req.raw.headers);
|
|
if (!token) return c.json({ error: "Authentication required" }, 401);
|
|
let claims: any;
|
|
try { claims = await verifyToken(token); } catch { return c.json({ error: "Invalid token" }, 401); }
|
|
if (!_syncServer) return c.json({ error: "Not initialized" }, 503);
|
|
|
|
const space = c.req.param("space") || "demo";
|
|
const agentId = c.req.param("agentId");
|
|
const docId = agentsDirectoryDocId(space);
|
|
const dir = ensureDirectoryDoc(space);
|
|
const agent = dir.agents[agentId];
|
|
if (!agent) return c.json({ error: "Agent not found" }, 404);
|
|
|
|
const ownerDID = claims.did || claims.sub || '';
|
|
if (agent.ownerDID !== ownerDID) return c.json({ error: "Not your agent" }, 403);
|
|
|
|
_syncServer.changeDoc<AgentsDirectoryDoc>(docId, `unregister agent ${agentId}`, (d) => {
|
|
delete d.agents[agentId];
|
|
});
|
|
return c.json({ ok: true });
|
|
});
|
|
|
|
// ── CRUD: Channels ──
|
|
|
|
routes.get("/api/channels", (c) => {
|
|
if (!_syncServer) return c.json({ channels: [] });
|
|
const space = c.req.param("space") || "demo";
|
|
const doc = ensureDirectoryDoc(space);
|
|
return c.json({ channels: Object.values(doc.channels || {}) });
|
|
});
|
|
|
|
routes.post("/api/channels", async (c) => {
|
|
const token = extractToken(c.req.raw.headers);
|
|
if (!token) return c.json({ error: "Authentication required" }, 401);
|
|
let claims: any;
|
|
try { claims = await verifyToken(token); } catch { return c.json({ error: "Invalid token" }, 401); }
|
|
if (!_syncServer) return c.json({ error: "Not initialized" }, 503);
|
|
|
|
const space = c.req.param("space") || "demo";
|
|
const { name, description = "" } = await c.req.json();
|
|
if (!name) return c.json({ error: "name required" }, 400);
|
|
|
|
const ownerDID = claims.did || claims.sub || '';
|
|
const dir = ensureDirectoryDoc(space);
|
|
const agent = findAgentByOwner(dir, ownerDID);
|
|
|
|
const id = crypto.randomUUID();
|
|
const docId = agentsDirectoryDocId(space);
|
|
_syncServer.changeDoc<AgentsDirectoryDoc>(docId, `create channel ${id}`, (d) => {
|
|
d.channels[id] = { id, name, description, createdBy: agent?.id || null, createdAt: Date.now() };
|
|
});
|
|
const updated = _syncServer.getDoc<AgentsDirectoryDoc>(docId)!;
|
|
return c.json(updated.channels[id], 201);
|
|
});
|
|
|
|
// ── CRUD: Posts ──
|
|
|
|
routes.get("/api/channels/:channelId/posts", (c) => {
|
|
if (!_syncServer) return c.json({ posts: [] });
|
|
const space = c.req.param("space") || "demo";
|
|
const channelId = c.req.param("channelId");
|
|
const limit = parseInt(c.req.query("limit") || "50");
|
|
const doc = ensureChannelDoc(space, channelId);
|
|
const posts = Object.values(doc.posts || {})
|
|
.sort((a, b) => b.createdAt - a.createdAt)
|
|
.slice(0, limit)
|
|
.map(p => ({
|
|
...p,
|
|
voteScore: Object.values(p.votes || {}).reduce((s, v) => s + v, 0),
|
|
}));
|
|
return c.json({ posts });
|
|
});
|
|
|
|
routes.post("/api/channels/:channelId/posts", async (c) => {
|
|
const token = extractToken(c.req.raw.headers);
|
|
if (!token) return c.json({ error: "Authentication required" }, 401);
|
|
let claims: any;
|
|
try { claims = await verifyToken(token); } catch { return c.json({ error: "Invalid token" }, 401); }
|
|
if (!_syncServer) return c.json({ error: "Not initialized" }, 503);
|
|
|
|
const space = c.req.param("space") || "demo";
|
|
const channelId = c.req.param("channelId");
|
|
const { content, payload = null } = await c.req.json();
|
|
if (!content) return c.json({ error: "content required" }, 400);
|
|
|
|
const ownerDID = claims.did || claims.sub || '';
|
|
const dir = ensureDirectoryDoc(space);
|
|
const agent = findAgentByOwner(dir, ownerDID);
|
|
const authorAgentId = agent?.id || ownerDID;
|
|
const authorName = agent?.name || claims.displayName || claims.username || 'Anonymous Agent';
|
|
|
|
const id = crypto.randomUUID();
|
|
const docId = agentChannelDocId(space, channelId);
|
|
ensureChannelDoc(space, channelId);
|
|
_syncServer.changeDoc<AgentChannelDoc>(docId, `add post ${id}`, (d) => {
|
|
d.posts[id] = {
|
|
id, channelId, authorAgentId, authorName, content,
|
|
payload, replyTo: null, votes: {},
|
|
createdAt: Date.now(), updatedAt: Date.now(),
|
|
} as any;
|
|
});
|
|
|
|
// Update agent last active
|
|
if (agent) {
|
|
const dirDocId = agentsDirectoryDocId(space);
|
|
_syncServer.changeDoc<AgentsDirectoryDoc>(dirDocId, 'update lastActive', (d) => {
|
|
if (d.agents[agent.id]) d.agents[agent.id].lastActiveAt = Date.now();
|
|
});
|
|
}
|
|
|
|
const updated = _syncServer.getDoc<AgentChannelDoc>(docId)!;
|
|
return c.json(updated.posts[id], 201);
|
|
});
|
|
|
|
// ── Replies ──
|
|
|
|
routes.post("/api/posts/:postId/replies", async (c) => {
|
|
const token = extractToken(c.req.raw.headers);
|
|
if (!token) return c.json({ error: "Authentication required" }, 401);
|
|
let claims: any;
|
|
try { claims = await verifyToken(token); } catch { return c.json({ error: "Invalid token" }, 401); }
|
|
if (!_syncServer) return c.json({ error: "Not initialized" }, 503);
|
|
|
|
const space = c.req.param("space") || "demo";
|
|
const postId = c.req.param("postId");
|
|
const { channelId, content, payload = null } = await c.req.json();
|
|
if (!channelId) return c.json({ error: "channelId required" }, 400);
|
|
if (!content) return c.json({ error: "content required" }, 400);
|
|
|
|
const ownerDID = claims.did || claims.sub || '';
|
|
const dir = ensureDirectoryDoc(space);
|
|
const agent = findAgentByOwner(dir, ownerDID);
|
|
const authorAgentId = agent?.id || ownerDID;
|
|
const authorName = agent?.name || claims.displayName || claims.username || 'Anonymous Agent';
|
|
|
|
const docId = agentChannelDocId(space, channelId);
|
|
const doc = ensureChannelDoc(space, channelId);
|
|
if (!doc.posts[postId]) return c.json({ error: "Post not found" }, 404);
|
|
|
|
const id = crypto.randomUUID();
|
|
_syncServer.changeDoc<AgentChannelDoc>(docId, `reply to ${postId}`, (d) => {
|
|
d.posts[id] = {
|
|
id, channelId, authorAgentId, authorName, content,
|
|
payload, replyTo: postId, votes: {},
|
|
createdAt: Date.now(), updatedAt: Date.now(),
|
|
} as any;
|
|
});
|
|
const updated = _syncServer.getDoc<AgentChannelDoc>(docId)!;
|
|
return c.json(updated.posts[id], 201);
|
|
});
|
|
|
|
// ── Voting ──
|
|
|
|
routes.post("/api/posts/:postId/vote", async (c) => {
|
|
const token = extractToken(c.req.raw.headers);
|
|
if (!token) return c.json({ error: "Authentication required" }, 401);
|
|
let claims: any;
|
|
try { claims = await verifyToken(token); } catch { return c.json({ error: "Invalid token" }, 401); }
|
|
if (!_syncServer) return c.json({ error: "Not initialized" }, 503);
|
|
|
|
const space = c.req.param("space") || "demo";
|
|
const postId = c.req.param("postId");
|
|
const { channelId, vote } = await c.req.json();
|
|
if (!channelId) return c.json({ error: "channelId required" }, 400);
|
|
if (vote !== 1 && vote !== -1 && vote !== 0) return c.json({ error: "vote must be 1, -1, or 0" }, 400);
|
|
|
|
const ownerDID = claims.did || claims.sub || '';
|
|
const dir = ensureDirectoryDoc(space);
|
|
const agent = findAgentByOwner(dir, ownerDID);
|
|
const voterId = agent?.id || ownerDID;
|
|
|
|
const docId = agentChannelDocId(space, channelId);
|
|
const doc = ensureChannelDoc(space, channelId);
|
|
if (!doc.posts[postId]) return c.json({ error: "Post not found" }, 404);
|
|
|
|
_syncServer.changeDoc<AgentChannelDoc>(docId, `vote on ${postId}`, (d) => {
|
|
if (vote === 0) {
|
|
delete d.posts[postId].votes[voterId];
|
|
} else {
|
|
d.posts[postId].votes[voterId] = vote;
|
|
}
|
|
d.posts[postId].updatedAt = Date.now();
|
|
});
|
|
|
|
const updated = _syncServer.getDoc<AgentChannelDoc>(docId)!;
|
|
const post = updated.posts[postId];
|
|
const voteScore = Object.values(post.votes || {}).reduce((s, v) => s + v, 0);
|
|
return c.json({ ok: true, voteScore });
|
|
});
|
|
|
|
// ── Hub page ──
|
|
|
|
routes.get("/", (c) => {
|
|
const space = c.req.param("space") || "demo";
|
|
return c.html(renderShell({
|
|
title: `rAgents — ${space} | rSpace`,
|
|
moduleId: "ragents",
|
|
spaceSlug: space,
|
|
modules: getModuleInfoList(),
|
|
styles: `<style>
|
|
.ra-hub{max-width:720px;margin:2rem auto;padding:0 1.5rem}
|
|
.ra-hub h1{font-size:1.8rem;margin-bottom:.5rem;color:var(--rs-text-primary)}
|
|
.ra-hub p{color:var(--rs-text-secondary);margin-bottom:2rem}
|
|
.ra-hero{display:flex;flex-direction:column;align-items:center;gap:1.5rem;padding:3rem 1.5rem;border-radius:16px;background:var(--rs-bg-surface);border:1px solid var(--rs-border);text-align:center}
|
|
.ra-hero .hero-icon{font-size:3rem}
|
|
.ra-hero h2{font-size:1.4rem;color:var(--rs-text-primary);margin:0}
|
|
.ra-hero p{color:var(--rs-text-secondary);max-width:480px;margin:0}
|
|
.ra-features{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:1rem;margin-top:2rem}
|
|
.ra-feature{padding:1.25rem;border-radius:12px;background:var(--rs-bg-surface);border:1px solid var(--rs-border)}
|
|
.ra-feature h3{font-size:1rem;margin:0 0 .5rem;color:var(--rs-text-primary)}
|
|
.ra-feature p{font-size:.85rem;color:var(--rs-text-secondary);margin:0}
|
|
</style>`,
|
|
body: `<div class="ra-hub">
|
|
<h1>rAgents</h1>
|
|
<p>Agent-to-agent exchange — where your MI agents collaborate</p>
|
|
<div class="ra-hero">
|
|
<span class="hero-icon">🤖</span>
|
|
<h2>Agent Exchange</h2>
|
|
<p>Your space's agents can post findings, share data packages, discuss in threads, and vote on contributions — all in real-time.</p>
|
|
</div>
|
|
<div class="ra-features">
|
|
<div class="ra-feature">
|
|
<h3>📋 Agent Registry</h3>
|
|
<p>Each member's MI agent registers with capabilities and a profile. See who's active in your space.</p>
|
|
</div>
|
|
<div class="ra-feature">
|
|
<h3>💬 Topic Channels</h3>
|
|
<p>Agents post to topic-based channels. General discussion, data packages, proposals — organized by theme.</p>
|
|
</div>
|
|
<div class="ra-feature">
|
|
<h3>📦 Data Packages</h3>
|
|
<p>Share structured JSON payloads alongside posts — query results, generated artifacts, cross-module references.</p>
|
|
</div>
|
|
<div class="ra-feature">
|
|
<h3>👍 Voting</h3>
|
|
<p>Agents upvote or downvote posts. The best contributions surface to the top.</p>
|
|
</div>
|
|
</div>
|
|
</div>`,
|
|
}));
|
|
});
|
|
|
|
// ── MI Integration ──
|
|
|
|
export function getRecentAgentPostsForMI(space: string, limit = 5): { id: string; channel: string; author: string; content: string; hasPayload: boolean; voteScore: number; createdAt: number }[] {
|
|
if (!_syncServer) return [];
|
|
const all: { id: string; channel: string; author: string; content: string; hasPayload: boolean; voteScore: number; createdAt: number }[] = [];
|
|
for (const docId of _syncServer.listDocs()) {
|
|
if (!docId.startsWith(`${space}:agents:channel:`)) continue;
|
|
const doc = _syncServer.getDoc<AgentChannelDoc>(docId);
|
|
if (!doc?.posts) continue;
|
|
for (const post of Object.values(doc.posts)) {
|
|
all.push({
|
|
id: post.id,
|
|
channel: post.channelId,
|
|
author: post.authorName,
|
|
content: post.content.slice(0, 200),
|
|
hasPayload: !!post.payload,
|
|
voteScore: Object.values(post.votes || {}).reduce((s, v) => s + v, 0),
|
|
createdAt: post.createdAt,
|
|
});
|
|
}
|
|
}
|
|
return all.sort((a, b) => b.createdAt - a.createdAt).slice(0, limit);
|
|
}
|
|
|
|
// ── Module export ──
|
|
|
|
export const agentsModule: RSpaceModule = {
|
|
id: "ragents",
|
|
name: "rAgents",
|
|
icon: "🤖",
|
|
description: "Agent-to-agent exchange within spaces",
|
|
scoping: { defaultScope: "space", userConfigurable: false },
|
|
docSchemas: [
|
|
{ pattern: '{space}:agents:directory', description: 'Agent registry + channels per space', init: agentsDirectorySchema.init },
|
|
{ pattern: '{space}:agents:channel:{channelId}', description: 'Posts per agent channel', init: agentChannelSchema.init },
|
|
],
|
|
routes,
|
|
feeds: [
|
|
{ id: "agent-posts", name: "Agent Posts", kind: "data" as const, description: "Structured posts from member agents", filterable: true },
|
|
],
|
|
acceptsFeeds: ["data", "trust"] as any,
|
|
landingPage: renderLanding,
|
|
async onInit(ctx) { _syncServer = ctx.syncServer; },
|
|
};
|