@a-company/paradigm 5.10.0 → 5.21.0

package/dist/symphony-B75X2MME.js

@@ -1,326 +0,0 @@
-#!/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-PDX44BCA.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-2ZQYLRNI.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-loader-UZGON56V.js

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-import {
-  SCORE_DIR,
-  acknowledgeMessages,
-  appendJsonlLine,
-  appendToInbox,
-  appendToOutbox,
-  approveFileRequest,
-  buildMessage,
-  cleanStaleAgents,
-  createFileRequest,
-  createThread,
-  denyFileRequest,
-  discoverClaudeCodeSessions,
-  ensureMailDirs,
-  ensureScoreDirs,
-  expireOldRequests,
-  garbageCollect,
-  getAgentDir,
-  getMyIdentity,
-  getThreadMessages,
-  isAgentAsleep,
-  isPathAutoApproved,
-  isPathDenied,
-  listAgents,
-  listFileRequests,
-  listThreads,
-  loadFileRequest,
-  loadThread,
-  loadTrustConfig,
-  markAgentPollTime,
-  peekInbox,
-  readAck,
-  readInbox,
-  readJsonlFile,
-  readOutbox,
-  recordAckSize,
-  registerAgent,
-  resolveAgentIdentity,
-  resolveThread,
-  routeMessage,
-  unregisterAgent,
-  updateAgentStatus,
-  updateThread
-} from "./chunk-NQKQG45G.js";
-import "./chunk-7N7GSU6K.js";
-export {
-  SCORE_DIR,
-  acknowledgeMessages,
-  appendJsonlLine,
-  appendToInbox,
-  appendToOutbox,
-  approveFileRequest,
-  buildMessage,
-  cleanStaleAgents,
-  createFileRequest,
-  createThread,
-  denyFileRequest,
-  discoverClaudeCodeSessions,
-  ensureMailDirs,
-  ensureScoreDirs,
-  expireOldRequests,
-  garbageCollect,
-  getAgentDir,
-  getMyIdentity,
-  getThreadMessages,
-  isAgentAsleep,
-  isPathAutoApproved,
-  isPathDenied,
-  listAgents,
-  listFileRequests,
-  listThreads,
-  loadFileRequest,
-  loadThread,
-  loadTrustConfig,
-  markAgentPollTime,
-  peekInbox,
-  readAck,
-  readInbox,
-  readJsonlFile,
-  readOutbox,
-  recordAckSize,
-  registerAgent,
-  resolveAgentIdentity,
-  resolveThread,
-  routeMessage,
-  unregisterAgent,
-  updateAgentStatus,
-  updateThread
-};

package/dist/symphony-peers-2ZQYLRNI.js

@@ -1,34 +0,0 @@
-#!/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-PDX44BCA.js";
-export {
-  PAIRING_TTL_MS,
-  PEERS_FILE,
-  addPeer,
-  computeHmacProof,
-  findPeer,
-  forgetAllPeers,
-  generatePairing,
-  loadPeers,
-  revokePeer,
-  savePeers,
-  updatePeerAgents,
-  updatePeerLastSeen,
-  verifyHmacProof,
-  verifyPairingCode
-};

package/dist/symphony-peers-OL7F6M5S.js

@@ -1,121 +0,0 @@
-#!/usr/bin/env node
-import "./chunk-7N7GSU6K.js";
-
-// ../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
-};