u-foo 1.2.16 → 1.4.0

package/src/online/server.js

@@ -45,6 +45,10 @@ class OnlineServer extends EventEmitter {
 
     this.rooms = new Map();
     this.roomPasswords = new Map();
+    this.channelMessageHistory = new Map();
+    this.roomMessageHistory = new Map();
+    this.channelHistoryLimit = options.channelHistoryLimit ?? 200;
+    this.eventSeq = 0;
 
     // Step 2 + 3: Payload limits
     this.maxHttpBodyBytes = options.maxHttpBodyBytes ?? 65536; // 64 KB
@@ -79,6 +83,23 @@ class OnlineServer extends EventEmitter {
     this.tlsKey = options.tlsKey || null;
   }
 
+  parseRequestUrl(rawUrl) {
+    try {
+      return new URL(rawUrl || "/", "http://localhost");
+    } catch {
+      return null;
+    }
+  }
+
+  corsHeaders(extra = {}) {
+    return {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Headers": "Authorization, Content-Type",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      ...extra,
+    };
+  }
+
   loadTokens(options) {
     if (options.tokens) {
       return new Set(Array.isArray(options.tokens) ? options.tokens : Object.keys(options.tokens));
@@ -117,27 +138,68 @@ class OnlineServer extends EventEmitter {
     }
 
     const requestHandler = (req, res) => {
-      if (!req.url) {
-        res.writeHead(404);
+      const parsedUrl = this.parseRequestUrl(req.url);
+      if (!parsedUrl) {
+        res.writeHead(404, this.corsHeaders());
+        res.end();
+        return;
+      }
+
+      const pathname = parsedUrl.pathname || "/";
+      const publicMessagesMatch = pathname.match(/^\/ufoo\/online\/public\/channels\/([^/]+)\/messages$/);
+      const privateMessagesMatch = pathname.match(/^\/ufoo\/online\/channels\/([^/]+)\/messages$/);
+      const roomMessagesMatch = pathname.match(/^\/ufoo\/online\/rooms\/([^/]+)\/messages$/);
+
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, this.corsHeaders());
         res.end();
         return;
       }
 
-      if (req.url.startsWith("/ufoo/online/rooms")) {
+      if (publicMessagesMatch) {
+        const channelRef = decodeURIComponent(publicMessagesMatch[1] || "");
+        this.handleChannelMessagesRequest(req, res, channelRef, parsedUrl);
+        return;
+      }
+
+      if (privateMessagesMatch) {
+        const channelRef = decodeURIComponent(privateMessagesMatch[1] || "");
+        if (!this.authenticateHttp(req, res)) return;
+        this.handleChannelMessagesRequest(req, res, channelRef, parsedUrl);
+        return;
+      }
+
+      if (pathname === "/ufoo/online/public/channels") {
+        this.handlePublicChannelsRequest(req, res, parsedUrl);
+        return;
+      }
+
+      if (pathname === "/ufoo/online/public/rooms") {
+        this.handlePublicRoomsRequest(req, res, parsedUrl);
+        return;
+      }
+
+      if (roomMessagesMatch) {
+        const roomId = decodeURIComponent(roomMessagesMatch[1] || "");
+        this.handleRoomMessagesRequest(req, res, roomId, parsedUrl);
+        return;
+      }
+
+      if (pathname.startsWith("/ufoo/online/rooms")) {
         // Step 4: HTTP auth
         if (!this.authenticateHttp(req, res)) return;
         this.handleRoomsRequest(req, res);
         return;
       }
 
-      if (req.url.startsWith("/ufoo/online/channels")) {
+      if (pathname.startsWith("/ufoo/online/channels")) {
         // Step 4: HTTP auth
         if (!this.authenticateHttp(req, res)) return;
         this.handleChannelsRequest(req, res);
         return;
       }
 
-      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.writeHead(200, this.corsHeaders({ "Content-Type": "text/plain" }));
       res.end("ufoo-online: running\n");
     };
 
@@ -258,7 +320,7 @@ class OnlineServer extends EventEmitter {
   }
 
   sendJson(res, statusCode, payload) {
-    res.writeHead(statusCode, { "Content-Type": "application/json" });
+    res.writeHead(statusCode, this.corsHeaders({ "Content-Type": "application/json" }));
     res.end(JSON.stringify(payload));
   }
 
@@ -286,17 +348,195 @@ class OnlineServer extends EventEmitter {
       type: room.type,
       members: room.members.size,
       created_at: room.created_at,
+      created_by: room.created_by || "",
+      password_required: room.type === "private",
     }));
   }
 
   listChannels() {
-    return Array.from(this.channels.entries()).map(([channelId, channel]) => ({
+    return Array.from(this.channels.entries()).map(([channelId, channel]) => {
+      const history = this.channelMessageHistory.get(channelId) || [];
+      const last = history.length > 0 ? history[history.length - 1] : null;
+      return {
+        channel_id: channelId,
+        name: channel.name || "",
+        type: channel.type || "public",
+        members: channel.members.size,
+        created_at: channel.created_at,
+        created_by: channel.created_by || "",
+        message_count: history.length,
+        last_message_at: channel.last_message_at || (last ? last.ts : null),
+      };
+    });
+  }
+
+  listPublicRooms(type = "") {
+    return this.listRooms()
+      .filter((room) => !type || room.type === type)
+      .map((room) => ({
+        room_id: room.room_id,
+        name: room.name || "",
+        type: room.type,
+        created_at: room.created_at,
+        created_by: room.created_by || "",
+        password_required: room.password_required !== false,
+      }));
+  }
+
+  listChannelMessages(channelRef, limit = 80) {
+    const resolved = this.resolveChannel(channelRef);
+    if (!resolved) return null;
+    const history = this.channelMessageHistory.get(resolved.channelId) || [];
+    const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(limit, 500)) : 80;
+    const start = Math.max(0, history.length - safeLimit);
+    return {
+      channel_id: resolved.channelId,
+      name: resolved.channel.name || "",
+      type: resolved.channel.type || "public",
+      messages: history.slice(start),
+    };
+  }
+
+  handlePublicRoomsRequest(req, res, parsedUrl) {
+    if (req.method !== "GET") {
+      this.sendJson(res, 405, { ok: false, error: "Method not allowed" });
+      return;
+    }
+    const type = String(parsedUrl.searchParams.get("type") || "").trim();
+    this.sendJson(res, 200, { ok: true, rooms: this.listPublicRooms(type) });
+  }
+
+  handlePublicChannelsRequest(req, res, parsedUrl) {
+    if (req.method !== "GET") {
+      this.sendJson(res, 405, { ok: false, error: "Method not allowed" });
+      return;
+    }
+    const type = String(parsedUrl.searchParams.get("type") || "").trim();
+    const channels = this.listChannels().filter((channel) => !type || channel.type === type);
+    this.sendJson(res, 200, { ok: true, channels });
+  }
+
+  handleChannelMessagesRequest(req, res, channelRef, parsedUrl) {
+    if (req.method !== "GET") {
+      this.sendJson(res, 405, { ok: false, error: "Method not allowed" });
+      return;
+    }
+    const limitRaw = Number.parseInt(String(parsedUrl.searchParams.get("limit") || "80"), 10);
+    const limit = Number.isFinite(limitRaw) ? limitRaw : 80;
+    const channelData = this.listChannelMessages(channelRef, limit);
+    if (!channelData) {
+      this.sendJson(res, 404, { ok: false, error: "Channel not found" });
+      return;
+    }
+    this.sendJson(res, 200, {
+      ok: true,
+      channel: {
+        channel_id: channelData.channel_id,
+        name: channelData.name,
+        type: channelData.type,
+      },
+      messages: channelData.messages,
+    });
+  }
+
+  handleRoomMessagesRequest(req, res, roomId, parsedUrl) {
+    if (req.method !== "GET") {
+      this.sendJson(res, 405, { ok: false, error: "Method not allowed" });
+      return;
+    }
+    const room = this.rooms.get(roomId);
+    if (!room) {
+      this.sendJson(res, 404, { ok: false, error: "Room not found" });
+      return;
+    }
+    // Private rooms require password via query param
+    if (room.type === "private") {
+      const password = String(parsedUrl.searchParams.get("password") || "");
+      const stored = this.roomPasswords.get(roomId);
+      if (!stored || !this.verifyPassword(password, stored)) {
+        this.sendJson(res, 403, { ok: false, error: "Invalid room password" });
+        return;
+      }
+    }
+    const limitRaw = Number.parseInt(String(parsedUrl.searchParams.get("limit") || "80"), 10);
+    const limit = Number.isFinite(limitRaw) ? limitRaw : 80;
+    const roomData = this.listRoomMessages(roomId, limit);
+    if (!roomData) {
+      this.sendJson(res, 404, { ok: false, error: "Room not found" });
+      return;
+    }
+    this.sendJson(res, 200, {
+      ok: true,
+      room: { room_id: roomData.room_id, name: roomData.name, type: roomData.type },
+      messages: roomData.messages,
+    });
+  }
+
+  recordChannelMessage(channelId, channel, client, eventPayload) {
+    const rawText = eventPayload?.payload?.message;
+    let text = "";
+    if (typeof rawText === "string") text = rawText;
+    else if (rawText !== null && rawText !== undefined) text = JSON.stringify(rawText);
+    if (!text) return;
+
+    const history = this.channelMessageHistory.get(channelId) || [];
+    const ts = eventPayload.ts || new Date().toISOString();
+    const entry = {
+      event_id: `event_${String(++this.eventSeq).padStart(8, "0")}`,
+      ts,
       channel_id: channelId,
-      name: channel.name || "",
-      type: channel.type || "public",
-      members: channel.members.size,
-      created_at: channel.created_at,
-    }));
+      channel_name: channel?.name || channelId,
+      from: client.subscriberId || "",
+      nickname: client.nickname || "",
+      text,
+    };
+    history.push(entry);
+    if (history.length > this.channelHistoryLimit) {
+      history.splice(0, history.length - this.channelHistoryLimit);
+    }
+    this.channelMessageHistory.set(channelId, history);
+    if (channel) {
+      channel.last_message_at = ts;
+    }
+  }
+
+  recordRoomMessage(roomId, room, client, eventPayload) {
+    const rawText = eventPayload?.payload?.message;
+    let text = "";
+    if (typeof rawText === "string") text = rawText;
+    else if (rawText !== null && rawText !== undefined) text = JSON.stringify(rawText);
+    if (!text) return;
+
+    const history = this.roomMessageHistory.get(roomId) || [];
+    const ts = eventPayload.ts || new Date().toISOString();
+    const entry = {
+      event_id: `event_${String(++this.eventSeq).padStart(8, "0")}`,
+      ts,
+      room_id: roomId,
+      room_name: room?.name || roomId,
+      from: client.subscriberId || "",
+      nickname: client.nickname || "",
+      text,
+    };
+    history.push(entry);
+    if (history.length > this.channelHistoryLimit) {
+      history.splice(0, history.length - this.channelHistoryLimit);
+    }
+    this.roomMessageHistory.set(roomId, history);
+  }
+
+  listRoomMessages(roomId, limit = 80) {
+    const room = this.rooms.get(roomId);
+    if (!room) return null;
+    const history = this.roomMessageHistory.get(roomId) || [];
+    const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(limit, 500)) : 80;
+    const start = Math.max(0, history.length - safeLimit);
+    return {
+      room_id: roomId,
+      name: room.name || "",
+      type: room.type,
+      messages: history.slice(start),
+    };
   }
 
   handleRoomsRequest(req, res) {
@@ -320,6 +560,7 @@ class OnlineServer extends EventEmitter {
           }
           const name = String(payload.name || "").trim();
           const type = String(payload.type).trim();
+          const createdBy = String(payload.created_by || payload.creator || "").trim();
           if (!["public", "private"].includes(type)) {
             this.sendJson(res, 400, { ok: false, error: "Invalid room type" });
             return;
@@ -328,6 +569,10 @@ class OnlineServer extends EventEmitter {
             const nameErr = this.validateIdentifier(name, "name");
             if (nameErr) { this.sendJson(res, 400, { ok: false, error: nameErr }); return; }
           }
+          if (createdBy) {
+            const creatorErr = this.validateIdentifier(createdBy, "created_by");
+            if (creatorErr) { this.sendJson(res, 400, { ok: false, error: creatorErr }); return; }
+          }
           if (this.rooms.size >= this.maxRooms) {
             this.sendJson(res, 429, { ok: false, error: "Room limit reached" });
             return;
@@ -353,9 +598,14 @@ class OnlineServer extends EventEmitter {
             name,
             type,
             members: new Set(),
+            observers: new Set(),
             created_at: new Date().toISOString(),
+            created_by: createdBy,
+          });
+          this.sendJson(res, 200, {
+            ok: true,
+            room: { room_id: roomId, name, type, created_by: createdBy, password_required: type === "private" },
           });
-          this.sendJson(res, 200, { ok: true, room: { room_id: roomId, name, type } });
         })
         .catch(() => {
           // Step 3: 413 on payload too large
@@ -388,12 +638,17 @@ class OnlineServer extends EventEmitter {
           }
           const name = String(payload.name || "").trim();
           const type = String(payload.type || "public").trim();
+          const createdBy = String(payload.created_by || payload.creator || "").trim();
           if (!name) {
             this.sendJson(res, 400, { ok: false, error: "Invalid channel name" });
             return;
           }
           const chNameErr = this.validateIdentifier(name, "name");
           if (chNameErr) { this.sendJson(res, 400, { ok: false, error: chNameErr }); return; }
+          if (createdBy) {
+            const creatorErr = this.validateIdentifier(createdBy, "created_by");
+            if (creatorErr) { this.sendJson(res, 400, { ok: false, error: creatorErr }); return; }
+          }
           if (!["world", "public"].includes(type)) {
             this.sendJson(res, 400, { ok: false, error: "Invalid channel type" });
             return;
@@ -419,10 +674,12 @@ class OnlineServer extends EventEmitter {
             name,
             type,
             members: new Set(),
+            observers: new Set(),
             created_at: new Date().toISOString(),
+            created_by: createdBy,
           });
           this.channelNames.set(name, channelId);
-          this.sendJson(res, 200, { ok: true, channel: { channel_id: channelId, name, type } });
+          this.sendJson(res, 200, { ok: true, channel: { channel_id: channelId, name, type, created_by: createdBy } });
         })
         .catch(() => {
           // Step 3: 413 on payload too large
@@ -475,6 +732,7 @@ class OnlineServer extends EventEmitter {
       authed: false,
       subscriberId: null,
       nickname: null,
+      role: "agent", // "agent" or "observer"
       channels: new Set(),
       helloReceived: false,
       connectedAt: Date.now(),
@@ -621,6 +879,12 @@ class OnlineServer extends EventEmitter {
     client.pendingWorld = world;
     client.rooms = new Set();
 
+    // Observer role: set from capabilities
+    const caps = Array.isArray(info.capabilities) ? info.capabilities : [];
+    if (caps.includes("observer")) {
+      client.role = "observer";
+    }
+
     this.send(client.ws, {
       type: "hello_ack",
       ok: true,
@@ -727,7 +991,9 @@ class OnlineServer extends EventEmitter {
       name: channelRef,
       type: "public",
       members: new Set(),
+      observers: new Set(),
       created_at: new Date().toISOString(),
+      created_by: "",
     };
     this.channels.set(channelRef, channel);
     this.channelNames.set(channelRef, channelRef);
@@ -762,7 +1028,12 @@ class OnlineServer extends EventEmitter {
     const channelId = resolved.channelId;
     const channelInfo = resolved.channel;
 
-    channelInfo.members.add(client);
+    if (client.role === "observer") {
+      if (!channelInfo.observers) channelInfo.observers = new Set();
+      channelInfo.observers.add(client);
+    } else {
+      channelInfo.members.add(client);
+    }
     client.channels.add(channelId);
     this.send(client.ws, { type: "join_ack", ok: true, channel: channelId });
   }
@@ -787,6 +1058,7 @@ class OnlineServer extends EventEmitter {
     const channelInfo = resolved?.channel || null;
     if (channelInfo) {
       channelInfo.members.delete(client);
+      if (channelInfo.observers) channelInfo.observers.delete(client);
     }
     client.channels.delete(channelId);
     this.send(client.ws, { type: "leave_ack", ok: true, channel: channelId });
@@ -794,6 +1066,10 @@ class OnlineServer extends EventEmitter {
 
   handleEvent(client, message) {
     if (!this.requireAuth(client)) return;
+    if (client.role === "observer") {
+      this.sendError(client.ws, "Observers are read-only", false, "EVENT_OBSERVER_READONLY");
+      return;
+    }
     if (!client.subscriberId) {
       this.sendError(client.ws, "Unknown subscriber", false, "SUBSCRIBER_UNKNOWN");
       return;
@@ -850,14 +1126,19 @@ class OnlineServer extends EventEmitter {
         this.sendError(client.ws, "Room not found", false, "ROOM_NOT_FOUND");
         return;
       }
-      room.members.forEach((member) => {
-        if (member !== client) {
-          this.send(member.ws, payload);
+      const broadcastRoom = (recipient) => {
+        if (recipient !== client) {
+          this.send(recipient.ws, payload);
           if (payload.payload && payload.payload.kind === "wake") {
-            this.send(member.ws, { type: "wake", from: client.subscriberId });
+            this.send(recipient.ws, { type: "wake", from: client.subscriberId });
           }
         }
-      });
+      };
+      room.members.forEach(broadcastRoom);
+      if (room.observers) room.observers.forEach(broadcastRoom);
+      if (kind === "message") {
+        this.recordRoomMessage(payload.room, room, client, payload);
+      }
       return;
     }
 
@@ -874,17 +1155,20 @@ class OnlineServer extends EventEmitter {
         this.sendError(client.ws, "Join channel first", false, "NOT_IN_CHANNEL");
         return;
       }
-      const members = channel ? channel.members : null;
-      if (!members || members.size === 0) return;
       payload.channel = channelId;
-      members.forEach((member) => {
-        if (member !== client) {
-          this.send(member.ws, payload);
+      if (kind === "message") {
+        this.recordChannelMessage(channelId, channel, client, payload);
+      }
+      const broadcastChannel = (recipient) => {
+        if (recipient !== client) {
+          this.send(recipient.ws, payload);
           if (payload.payload && payload.payload.kind === "wake") {
-            this.send(member.ws, { type: "wake", from: client.subscriberId });
+            this.send(recipient.ws, { type: "wake", from: client.subscriberId });
           }
         }
-      });
+      };
+      if (channel.members) channel.members.forEach(broadcastChannel);
+      if (channel.observers) channel.observers.forEach(broadcastChannel);
       return;
     }
 
@@ -934,7 +1218,12 @@ class OnlineServer extends EventEmitter {
       return;
     }
 
-    room.members.add(client);
+    if (client.role === "observer") {
+      if (!room.observers) room.observers = new Set();
+      room.observers.add(client);
+    } else {
+      room.members.add(client);
+    }
     client.rooms.add(roomId);
     this.send(client.ws, { type: "join_ack", ok: true, room: roomId });
   }
@@ -948,6 +1237,7 @@ class OnlineServer extends EventEmitter {
     const room = this.rooms.get(roomId);
     if (room) {
       room.members.delete(client);
+      if (room.observers) room.observers.delete(client);
     }
     client.rooms.delete(roomId);
     this.send(client.ws, { type: "leave_ack", ok: true, room: roomId });
@@ -965,6 +1255,7 @@ class OnlineServer extends EventEmitter {
       const channelInfo = this.channels.get(channel);
       if (channelInfo) {
         channelInfo.members.delete(client);
+        if (channelInfo.observers) channelInfo.observers.delete(client);
       }
     });
     client.channels.clear();
@@ -974,6 +1265,7 @@ class OnlineServer extends EventEmitter {
         const room = this.rooms.get(roomId);
         if (room) {
           room.members.delete(client);
+          if (room.observers) room.observers.delete(client);
         }
       });
       client.rooms.clear();

package/src/shared/eventContract.js

@@ -7,8 +7,13 @@ const IPC_REQUEST_TYPES = {
   BUS_SEND: "bus_send",
   CLOSE_AGENT: "close_agent",
   LAUNCH_AGENT: "launch_agent",
+  LAUNCH_GROUP: "launch_group",
   RESUME_AGENTS: "resume_agents",
   LIST_RECOVERABLE_AGENTS: "list_recoverable_agents",
+  STOP_GROUP: "stop_group",
+  GROUP_STATUS: "group_status",
+  GROUP_TEMPLATE_VALIDATE: "group_template_validate",
+  GROUP_DIAGRAM: "group_diagram",
   REGISTER_AGENT: "register_agent",
   AGENT_READY: "agent_ready",
   AGENT_REPORT: "agent_report",

package/src/ufoo/paths.js

@@ -17,6 +17,7 @@ function getUfooPaths(projectRoot) {
   const busDaemonCountsDir = path.join(busDaemonDir, "counts");
 
   const runDir = path.join(ufooDir, "run");
+  const groupsDir = path.join(ufooDir, "groups");
   const ufooDaemonPid = path.join(runDir, "ufoo-daemon.pid");
   const ufooDaemonLog = path.join(runDir, "ufoo-daemon.log");
   const ufooSock = path.join(runDir, "ufoo.sock");
@@ -35,6 +36,7 @@ function getUfooPaths(projectRoot) {
     busDaemonLog,
     busDaemonCountsDir,
     runDir,
+    groupsDir,
     ufooDaemonPid,
     ufooDaemonLog,
     ufooSock,

package/templates/groups/dev-basic.json

@@ -0,0 +1,78 @@
+{
+  "schema_version": 1,
+  "template": {
+    "id": "software-dev-basic",
+    "alias": "dev-basic",
+    "name": "Software Dev Basic"
+  },
+  "defaults": {
+    "launch_mode": "auto",
+    "start_timeout_ms": 15000
+  },
+  "agents": [
+    {
+      "id": "pm",
+      "nickname": "pm",
+      "type": "codex",
+      "role": "task coordinator",
+      "prompt_profile": "task-breakdown",
+      "accept_from": [],
+      "report_to": [],
+      "startup_order": 1,
+      "depends_on": []
+    },
+    {
+      "id": "architect",
+      "nickname": "architect",
+      "type": "claude",
+      "role": "system architect",
+      "prompt_profile": "architecture-review",
+      "accept_from": [
+        "pm"
+      ],
+      "report_to": [
+        "pm"
+      ],
+      "startup_order": 2,
+      "depends_on": [
+        "pm"
+      ]
+    },
+    {
+      "id": "builder",
+      "nickname": "builder",
+      "type": "codex",
+      "role": "implementation engineer",
+      "prompt_profile": "code-implement",
+      "accept_from": [
+        "pm",
+        "architect"
+      ],
+      "report_to": [
+        "pm"
+      ],
+      "startup_order": 3,
+      "depends_on": [
+        "pm",
+        "architect"
+      ]
+    }
+  ],
+  "edges": [
+    {
+      "from": "pm",
+      "to": "architect",
+      "kind": "task"
+    },
+    {
+      "from": "pm",
+      "to": "builder",
+      "kind": "task"
+    },
+    {
+      "from": "architect",
+      "to": "builder",
+      "kind": "review"
+    }
+  ]
+}

package/templates/groups/research-quick.json

@@ -0,0 +1,49 @@
+{
+  "schema_version": 1,
+  "template": {
+    "id": "research-quick",
+    "alias": "research-quick",
+    "name": "Research Quick"
+  },
+  "defaults": {
+    "launch_mode": "auto",
+    "start_timeout_ms": 10000
+  },
+  "agents": [
+    {
+      "id": "researcher",
+      "nickname": "researcher",
+      "type": "claude",
+      "role": "collect references and summarize findings",
+      "prompt_profile": "research-scan",
+      "accept_from": [],
+      "report_to": [],
+      "startup_order": 1,
+      "depends_on": []
+    },
+    {
+      "id": "coder",
+      "nickname": "coder",
+      "type": "codex",
+      "role": "prototype and verify implementation",
+      "prompt_profile": "rapid-prototype",
+      "accept_from": [
+        "researcher"
+      ],
+      "report_to": [
+        "researcher"
+      ],
+      "startup_order": 2,
+      "depends_on": [
+        "researcher"
+      ]
+    }
+  ],
+  "edges": [
+    {
+      "from": "researcher",
+      "to": "coder",
+      "kind": "task"
+    }
+  ]
+}