@a-company/paradigm 3.43.0 → 3.46.0

package/dist/symphony-YCHBYN3E.js

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+import {
+  approveFileRequest,
+  buildMessage,
+  cleanStaleAgents,
+  createThread,
+  denyFileRequest,
+  discoverClaudeCodeSessions,
+  expireOldRequests,
+  getMyIdentity,
+  getThreadMessages,
+  isAgentAsleep,
+  listAgents,
+  listFileRequests,
+  listThreads,
+  loadThread,
+  readInbox,
+  resolveAgentIdentity,
+  resolveThread,
+  routeMessage
+} from "./chunk-S2HO5MLR.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/platform-server/routes/symphony.ts
+import { Router } from "express";
+function createSymphonyRouter(projectDir, broadcast) {
+  const router = Router();
+  router.get("/agents", (_req, res) => {
+    try {
+      cleanStaleAgents();
+      const agents = listAgents();
+      const discovered = discoverClaudeCodeSessions();
+      const agentIds = new Set(agents.map((a) => a.id));
+      for (const d of discovered) {
+        if (!agentIds.has(d.id)) agents.push(d);
+      }
+      const result = agents.map((a) => ({
+        id: a.id,
+        name: a.name,
+        project: a.project,
+        role: a.role,
+        status: isAgentAsleep(a) ? "asleep" : "awake",
+        lastPoll: a.lastPoll,
+        startedAt: a.startedAt,
+        statusBlurb: a.statusBlurb
+      }));
+      res.json({ agents: result });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to list agents", detail: String(err) });
+    }
+  });
+  router.get("/agents/me", (_req, res) => {
+    try {
+      const identity = getMyIdentity(projectDir);
+      res.json({ identity: identity || null });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to get identity", detail: String(err) });
+    }
+  });
+  router.get("/peers", async (_req, res) => {
+    try {
+      const { loadPeers } = await import("./symphony-peers-HSY3RI3S.js");
+      const peers = loadPeers();
+      const result = peers.map((p) => ({
+        id: p.id,
+        displayName: p.displayName,
+        address: p.address,
+        connectedAt: p.connectedAt,
+        lastSeen: p.lastSeen,
+        revoked: p.revoked,
+        agents: p.agents || []
+      }));
+      res.json({ peers: result });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to list peers", detail: String(err) });
+    }
+  });
+  router.get("/threads", (req, res) => {
+    try {
+      const statusParam = req.query.status;
+      let status;
+      if (statusParam === "active" || statusParam === "resolved") {
+        status = statusParam;
+      }
+      const threads = listThreads(status);
+      const result = threads.map((t) => ({
+        id: t.id,
+        topic: t.topic,
+        status: t.status,
+        participants: t.participants.map((p) => ({ id: p.id, name: p.name, type: p.type })),
+        messageCount: t.messageCount,
+        lastActivity: t.lastActivity,
+        decision: t.decision
+      }));
+      res.json({ threads: result });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to list threads", detail: String(err) });
+    }
+  });
+  router.get("/threads/:threadId", (req, res) => {
+    try {
+      const { threadId } = req.params;
+      const thread = loadThread(threadId);
+      if (!thread) {
+        res.status(404).json({ error: `Thread not found: ${threadId}` });
+        return;
+      }
+      const messages = getThreadMessages(threadId);
+      const symbolsDiscussed = /* @__PURE__ */ new Set();
+      for (const msg of messages) {
+        for (const sym of msg.symbols) symbolsDiscussed.add(sym);
+      }
+      res.json({
+        thread: {
+          id: thread.id,
+          topic: thread.topic,
+          status: thread.status,
+          participants: thread.participants.map((p) => ({ id: p.id, name: p.name, type: p.type })),
+          messageCount: thread.messageCount,
+          lastActivity: thread.lastActivity,
+          decision: thread.decision
+        },
+        messages: messages.map((m) => ({
+          id: m.id,
+          sender: { id: m.sender.id, name: m.sender.name, type: m.sender.type },
+          intent: m.intent,
+          text: m.content.text,
+          timestamp: m.timestamp,
+          symbols: m.symbols,
+          diff: m.content.diff,
+          decision: m.content.decision,
+          recipients: m.recipients?.map((r) => ({ id: r.id, name: r.name }))
+        })),
+        symbolsDiscussed: [...symbolsDiscussed]
+      });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to load thread", detail: String(err) });
+    }
+  });
+  router.post("/threads/:threadId/resolve", (req, res) => {
+    try {
+      const { threadId } = req.params;
+      const { decision } = req.body;
+      const success = resolveThread(threadId, decision);
+      if (!success) {
+        res.status(404).json({ error: `Thread not found: ${threadId}` });
+        return;
+      }
+      if (broadcast) {
+        broadcast({ type: "symphony:thread_resolved", threadId, decision });
+      }
+      res.json({ resolved: true, threadId, decision });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to resolve thread", detail: String(err) });
+    }
+  });
+  router.post("/messages", (req, res) => {
+    try {
+      const { intent, text, threadRoot, recipients, symbols, diff, decision } = req.body;
+      if (!intent || !text) {
+        res.status(400).json({ error: "intent and text are required" });
+        return;
+      }
+      const agentId = resolveAgentIdentity(projectDir);
+      const sender = {
+        id: `human/${agentId}`,
+        name: "Human (Platform UI)",
+        type: "human"
+      };
+      let effectiveThreadRoot = threadRoot;
+      let threadCreated = false;
+      if (!threadRoot) {
+        const topic = text.length > 60 ? text.slice(0, 60) + "..." : text;
+        const thread = createThread(topic, sender);
+        effectiveThreadRoot = thread.id;
+        threadCreated = true;
+      }
+      let resolvedRecipients;
+      if (recipients && recipients.length > 0) {
+        const allAgents = listAgents();
+        resolvedRecipients = recipients.map((id) => {
+          const agent = allAgents.find((a) => a.id === id);
+          if (agent) return { id: agent.id, name: agent.name, type: "agent" };
+          return { id, name: id, type: "agent" };
+        });
+      }
+      const message = buildMessage({
+        sender,
+        recipients: resolvedRecipients,
+        intent,
+        text,
+        threadRoot: effectiveThreadRoot,
+        symbols,
+        diff,
+        decision
+      });
+      const deliveryCount = routeMessage(message);
+      if (broadcast) {
+        broadcast({
+          type: "symphony:message",
+          message: {
+            id: message.id,
+            sender: { id: sender.id, name: sender.name, type: sender.type },
+            intent: message.intent,
+            text: message.content.text,
+            timestamp: message.timestamp,
+            symbols: message.symbols,
+            diff: message.content.diff,
+            decision: message.content.decision
+          },
+          threadId: effectiveThreadRoot
+        });
+      }
+      res.json({
+        sent: true,
+        messageId: message.id,
+        threadId: effectiveThreadRoot,
+        threadCreated,
+        deliveredTo: deliveryCount
+      });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to send message", detail: String(err) });
+    }
+  });
+  router.get("/inbox", (_req, res) => {
+    try {
+      const agentId = resolveAgentIdentity(projectDir);
+      const messages = readInbox(agentId);
+      res.json({
+        agentId,
+        messages: messages.map((m) => ({
+          id: m.id,
+          sender: { id: m.sender.id, name: m.sender.name, type: m.sender.type },
+          intent: m.intent,
+          text: m.content.text,
+          timestamp: m.timestamp,
+          threadRoot: m.threadRoot,
+          symbols: m.symbols
+        }))
+      });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to read inbox", detail: String(err) });
+    }
+  });
+  router.get("/file-requests", (req, res) => {
+    try {
+      expireOldRequests();
+      const statusParam = req.query.status;
+      let status;
+      if (statusParam === "pending" || statusParam === "approved" || statusParam === "denied" || statusParam === "expired") {
+        status = statusParam;
+      }
+      const requests = listFileRequests(status);
+      const result = requests.map((r) => ({
+        requestId: r.request.requestId,
+        filePath: r.request.filePath,
+        reason: r.request.reason,
+        requester: { id: r.request.requester.id, name: r.request.requester.name },
+        urgency: r.request.urgency,
+        snippet: r.request.snippet,
+        status: r.status,
+        createdAt: r.createdAt,
+        resolvedAt: r.resolvedAt,
+        denyReason: r.denyReason
+      }));
+      res.json({ fileRequests: result });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to list file requests", detail: String(err) });
+    }
+  });
+  router.post("/file-requests/:requestId/action", (req, res) => {
+    try {
+      const { requestId } = req.params;
+      const { action, reason } = req.body;
+      if (!action) {
+        res.status(400).json({ error: "action is required" });
+        return;
+      }
+      if (action === "deny") {
+        const success = denyFileRequest(requestId, reason);
+        res.json({ success, requestId, action: "denied", reason });
+        return;
+      }
+      const redact = action === "approve-redacted";
+      const result = approveFileRequest(requestId, projectDir, redact);
+      if (!result.success) {
+        res.status(400).json({ success: false, requestId, error: result.error });
+        return;
+      }
+      res.json({
+        success: true,
+        requestId,
+        action: redact ? "approved-redacted" : "approved",
+        filePath: result.delivery?.filePath,
+        size: result.delivery?.size
+      });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to handle file request", detail: String(err) });
+    }
+  });
+  router.get("/status", (_req, res) => {
+    try {
+      cleanStaleAgents();
+      const agents = listAgents();
+      const awake = agents.filter((a) => !isAgentAsleep(a)).length;
+      const threads = listThreads("active");
+      const agentId = resolveAgentIdentity(projectDir);
+      const unread = readInbox(agentId);
+      const pendingRequests = listFileRequests("pending");
+      res.json({
+        agentCount: agents.length,
+        awakeCount: awake,
+        asleepCount: agents.length - awake,
+        activeThreadCount: threads.length,
+        unreadCount: unread.length,
+        pendingFileRequests: pendingRequests.length
+      });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to get status", detail: String(err) });
+    }
+  });
+  return router;
+}
+export {
+  createSymphonyRouter
+};

package/dist/symphony-peers-APOGJPF4.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/symphony-peers.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+var SCORE_DIR = path.join(os.homedir(), ".paradigm", "score");
+var PEERS_FILE = path.join(SCORE_DIR, "peers.json");
+var PAIRING_TTL_MS = 5 * 60 * 1e3;
+function loadPeers() {
+  try {
+    if (!fs.existsSync(PEERS_FILE)) return [];
+    const content = fs.readFileSync(PEERS_FILE, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed)) return [];
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+function savePeers(peers) {
+  if (!fs.existsSync(SCORE_DIR)) {
+    fs.mkdirSync(SCORE_DIR, { recursive: true });
+  }
+  fs.writeFileSync(PEERS_FILE, JSON.stringify(peers, null, 2), { mode: 384 });
+}
+function findPeer(id) {
+  const peers = loadPeers();
+  return peers.find((p) => p.id === id) ?? null;
+}
+function addPeer(peer) {
+  const peers = loadPeers();
+  const idx = peers.findIndex((p) => p.id === peer.id);
+  if (idx >= 0) {
+    peers[idx] = peer;
+  } else {
+    peers.push(peer);
+  }
+  savePeers(peers);
+}
+function revokePeer(id) {
+  const peers = loadPeers();
+  const peer = peers.find((p) => p.id === id);
+  if (!peer) return false;
+  peer.revoked = true;
+  savePeers(peers);
+  return true;
+}
+function forgetAllPeers() {
+  const peers = loadPeers();
+  const count = peers.length;
+  if (fs.existsSync(PEERS_FILE)) {
+    fs.unlinkSync(PEERS_FILE);
+  }
+  return count;
+}
+function updatePeerLastSeen(id) {
+  const peers = loadPeers();
+  const peer = peers.find((p) => p.id === id);
+  if (!peer) return;
+  peer.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+  savePeers(peers);
+}
+function updatePeerAgents(id, agents) {
+  const peers = loadPeers();
+  const peer = peers.find((p) => p.id === id);
+  if (!peer) return;
+  peer.agents = agents;
+  savePeers(peers);
+}
+function generatePairing() {
+  const sharedSecret = crypto.randomBytes(32).toString("hex");
+  const code = (parseInt(crypto.randomBytes(3).toString("hex"), 16) % 1e6).toString().padStart(6, "0");
+  const codeHash = crypto.createHash("sha256").update(code).digest("hex");
+  return {
+    code,
+    codeHash,
+    sharedSecret,
+    createdAt: Date.now()
+  };
+}
+function verifyPairingCode(state, code) {
+  if (Date.now() - state.createdAt > PAIRING_TTL_MS) {
+    return false;
+  }
+  const hash = crypto.createHash("sha256").update(code).digest("hex");
+  return hash === state.codeHash;
+}
+function computeHmacProof(challenge, codeHash) {
+  return crypto.createHmac("sha256", codeHash).update(challenge).digest("hex");
+}
+function verifyHmacProof(challenge, codeHash, proof) {
+  const expected = computeHmacProof(challenge, codeHash);
+  if (expected.length !== proof.length) return false;
+  try {
+    return crypto.timingSafeEqual(
+      Buffer.from(expected, "hex"),
+      Buffer.from(proof, "hex")
+    );
+  } catch {
+    return false;
+  }
+}
+export {
+  PAIRING_TTL_MS,
+  PEERS_FILE,
+  addPeer,
+  computeHmacProof,
+  findPeer,
+  forgetAllPeers,
+  generatePairing,
+  loadPeers,
+  revokePeer,
+  savePeers,
+  updatePeerAgents,
+  updatePeerLastSeen,
+  verifyHmacProof,
+  verifyPairingCode
+};

package/dist/symphony-peers-HSY3RI3S.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import {
+  PAIRING_TTL_MS,
+  PEERS_FILE,
+  addPeer,
+  computeHmacProof,
+  findPeer,
+  forgetAllPeers,
+  generatePairing,
+  loadPeers,
+  revokePeer,
+  savePeers,
+  updatePeerAgents,
+  updatePeerLastSeen,
+  verifyHmacProof,
+  verifyPairingCode
+} from "./chunk-KVDYJLTC.js";
+import "./chunk-ZXMDA7VB.js";
+export {
+  PAIRING_TTL_MS,
+  PEERS_FILE,
+  addPeer,
+  computeHmacProof,
+  findPeer,
+  forgetAllPeers,
+  generatePairing,
+  loadPeers,
+  revokePeer,
+  savePeers,
+  updatePeerAgents,
+  updatePeerLastSeen,
+  verifyHmacProof,
+  verifyPairingCode
+};