@rookdaemon/agora 0.5.8 → 0.6.1

package/README.md

@@ -41,6 +41,7 @@ Agent A <---direct HTTP---> Agent B
 
 2. **Peer Registry + Config**
    - Local config (`~/.config/agora/config.json`) stores identity, peers, and optional relay settings.
+   - Named profiles live under `~/.config/agora/profiles/<name>/config.json`.
    - Peer identity is public key; names are convenience labels.
 
 3. **Transport Layer**
@@ -82,15 +83,17 @@ Agent A <---direct HTTP---> Agent B
 - Automatic global pub/sub or DHT-style discovery.
 - Protocol-level consensus/governance execution.
 - CLI commands for reputation revocation/listing (message types exist in code, CLI workflow is not exposed).
-- `agora config set ...` style config mutation command.
+- Multi-identity in a single config (email-client style "send as"). Use named profiles for now.
 
 ## CLI (Current Surface)
 
+All commands accept `--profile <name>` (or `--as <name>`) to target a named profile instead of the default config.
+
 ### Identity
 
-- `agora init`
-- `agora whoami`
-- `agora status`
+- `agora init [--profile <name>]`
+- `agora whoami [--profile <name>]`
+- `agora status [--profile <name>]`
 
 ### Peers
 
@@ -98,6 +101,13 @@ Agent A <---direct HTTP---> Agent B
 - `agora peers add <name> --pubkey <pubkey> [--url <url> --token <token>]`
 - `agora peers remove <name|pubkey>`
 - `agora peers discover [--relay <url>] [--relay-pubkey <pubkey>] [--limit <n>] [--active-within <ms>] [--save]`
+- `agora peers copy <name|pubkey> --from <profile> --to <profile>`
+
+### Config Transfer
+
+- `agora config profiles` — list available profiles (default + named)
+- `agora config export [--include-identity] [--output <file>]` — export peers/relay (and optionally identity) as portable JSON
+- `agora config import <file> [--overwrite-identity] [--overwrite-relay] [--dry-run]` — merge exported config into current profile
 
 ### Messaging
 
@@ -159,6 +169,28 @@ Agent A <---direct HTTP---> Agent B
 }
 ```
 
+### Profiles
+
+Run multiple identities on the same machine using named profiles:
+
+```bash
+# Default profile: ~/.config/agora/config.json
+agora init
+
+# Named profile: ~/.config/agora/profiles/stefan/config.json
+agora init --profile stefan
+
+# Send as a specific profile
+agora send bob "hello" --profile stefan
+
+# Export peers from default, import into stefan
+agora config export --output peers.json
+agora config import peers.json --profile stefan
+
+# Or copy a single peer between profiles
+agora peers copy bob --from default --to stefan
+```
+
 ## Relay + REST Mode (Library API)
 
 `agora relay` starts WebSocket relay only. For WebSocket + REST together, use `runRelay()`:

package/dist/{chunk-P5EN45ZV.js → chunk-UDRIP62M.js}

@@ -28,7 +28,7 @@ function initPeerConfig(path) {
 }
 
 // src/transport/http.ts
-async function sendToPeer(config, peerPublicKey, type, payload, inReplyTo) {
+async function sendToPeer(config, peerPublicKey, type, payload, inReplyTo, allRecipients) {
   const peer = config.peers.get(peerPublicKey);
   if (!peer) {
     return { ok: false, status: 0, error: "Unknown peer" };
@@ -43,7 +43,7 @@ async function sendToPeer(config, peerPublicKey, type, payload, inReplyTo) {
     payload,
     Date.now(),
     inReplyTo,
-    [peerPublicKey]
+    allRecipients ?? [peerPublicKey]
   );
   const envelopeJson = JSON.stringify(envelope);
   const envelopeBase64 = Buffer.from(envelopeJson).toString("base64url");
@@ -122,7 +122,7 @@ function decodeInboundEnvelope(message, knownPeers) {
 
 // src/transport/relay.ts
 import WebSocket from "ws";
-async function sendViaRelay(config, peerPublicKey, type, payload, inReplyTo) {
+async function sendViaRelay(config, peerPublicKey, type, payload, inReplyTo, allRecipients) {
   if (config.relayClient && config.relayClient.connected()) {
     const envelope = createEnvelope(
       type,
@@ -131,11 +131,11 @@ async function sendViaRelay(config, peerPublicKey, type, payload, inReplyTo) {
       payload,
       Date.now(),
       inReplyTo,
-      [peerPublicKey]
+      allRecipients ?? [peerPublicKey]
     );
     return config.relayClient.send(peerPublicKey, envelope);
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const ws = new WebSocket(config.relayUrl);
     let registered = false;
     let messageSent = false;
@@ -144,7 +144,7 @@ async function sendViaRelay(config, peerPublicKey, type, payload, inReplyTo) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeout);
-        resolve(result);
+        resolve2(result);
       }
     };
     const timeout = setTimeout(() => {
@@ -172,7 +172,7 @@ async function sendViaRelay(config, peerPublicKey, type, payload, inReplyTo) {
             payload,
             Date.now(),
             inReplyTo,
-            [peerPublicKey]
+            allRecipients ?? [peerPublicKey]
           );
           const relayMsg = {
             type: "message",
@@ -206,6 +206,183 @@ async function sendViaRelay(config, peerPublicKey, type, payload, inReplyTo) {
   });
 }
 
+// src/config.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { readFile } from "fs/promises";
+import { resolve, join, dirname } from "path";
+import { homedir } from "os";
+function getDefaultConfigPath() {
+  if (process.env.AGORA_CONFIG) {
+    return resolve(process.env.AGORA_CONFIG);
+  }
+  return resolve(homedir(), ".config", "agora", "config.json");
+}
+function parseConfig(config) {
+  const rawIdentity = config.identity;
+  if (!rawIdentity?.publicKey || !rawIdentity?.privateKey) {
+    throw new Error("Invalid config: missing identity.publicKey or identity.privateKey");
+  }
+  const identity = {
+    publicKey: rawIdentity.publicKey,
+    privateKey: rawIdentity.privateKey,
+    name: typeof rawIdentity.name === "string" ? rawIdentity.name : void 0
+  };
+  const peers = {};
+  if (config.peers && typeof config.peers === "object") {
+    for (const entry of Object.values(config.peers)) {
+      const peer = entry;
+      if (peer && typeof peer.publicKey === "string") {
+        peers[peer.publicKey] = {
+          publicKey: peer.publicKey,
+          url: typeof peer.url === "string" ? peer.url : void 0,
+          token: typeof peer.token === "string" ? peer.token : void 0,
+          name: typeof peer.name === "string" ? peer.name : void 0
+        };
+      }
+    }
+  }
+  let relay;
+  const rawRelay = config.relay;
+  if (typeof rawRelay === "string") {
+    relay = { url: rawRelay, autoConnect: true };
+  } else if (rawRelay && typeof rawRelay === "object") {
+    const r = rawRelay;
+    if (typeof r.url === "string") {
+      relay = {
+        url: r.url,
+        autoConnect: typeof r.autoConnect === "boolean" ? r.autoConnect : true,
+        name: typeof r.name === "string" ? r.name : void 0,
+        reconnectMaxMs: typeof r.reconnectMaxMs === "number" ? r.reconnectMaxMs : void 0
+      };
+    }
+  }
+  return {
+    identity,
+    peers,
+    ...relay ? { relay } : {}
+  };
+}
+function loadAgoraConfig(path) {
+  const configPath = path ?? getDefaultConfigPath();
+  if (!existsSync2(configPath)) {
+    throw new Error(`Config file not found at ${configPath}. Run 'npx @rookdaemon/agora init' first.`);
+  }
+  const content = readFileSync2(configPath, "utf-8");
+  let config;
+  try {
+    config = JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in config file: ${configPath}`);
+  }
+  return parseConfig(config);
+}
+async function loadAgoraConfigAsync(path) {
+  const configPath = path ?? getDefaultConfigPath();
+  let content;
+  try {
+    content = await readFile(configPath, "utf-8");
+  } catch (err) {
+    const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
+    if (code === "ENOENT") {
+      throw new Error(`Config file not found at ${configPath}. Run 'npx @rookdaemon/agora init' first.`);
+    }
+    throw err;
+  }
+  let config;
+  try {
+    config = JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in config file: ${configPath}`);
+  }
+  return parseConfig(config);
+}
+function getConfigDir() {
+  if (process.env.AGORA_CONFIG_DIR) {
+    return resolve(process.env.AGORA_CONFIG_DIR);
+  }
+  return resolve(homedir(), ".config", "agora");
+}
+function getProfileConfigPath(profile) {
+  if (process.env.AGORA_CONFIG) {
+    return resolve(process.env.AGORA_CONFIG);
+  }
+  const base = getConfigDir();
+  if (!profile || profile === "default") {
+    return join(base, "config.json");
+  }
+  return join(base, "profiles", profile, "config.json");
+}
+function listProfiles() {
+  const base = getConfigDir();
+  const profiles = [];
+  if (existsSync2(join(base, "config.json"))) {
+    profiles.push("default");
+  }
+  const profilesDir = join(base, "profiles");
+  if (existsSync2(profilesDir)) {
+    for (const entry of readdirSync(profilesDir, { withFileTypes: true })) {
+      if (entry.isDirectory() && existsSync2(join(profilesDir, entry.name, "config.json"))) {
+        profiles.push(entry.name);
+      }
+    }
+  }
+  return profiles;
+}
+function exportConfig(config, opts = {}) {
+  const exported = {
+    version: 1,
+    peers: Object.fromEntries(
+      Object.entries(config.peers).map(([k, v]) => [k, { ...v }])
+    )
+  };
+  if (opts.includeIdentity) {
+    exported.identity = { ...config.identity };
+  }
+  if (config.relay) {
+    exported.relay = { ...config.relay };
+  }
+  return exported;
+}
+function importConfig(target, incoming, opts = {}) {
+  const result = {
+    peersAdded: [],
+    peersSkipped: [],
+    identityImported: false,
+    relayImported: false
+  };
+  for (const [key, peer] of Object.entries(incoming.peers)) {
+    if (target.peers[key]) {
+      result.peersSkipped.push(key);
+    } else {
+      target.peers[key] = { ...peer };
+      result.peersAdded.push(key);
+    }
+  }
+  if (opts.overwriteIdentity && incoming.identity) {
+    target.identity = { ...incoming.identity };
+    result.identityImported = true;
+  }
+  if (opts.overwriteRelay && incoming.relay) {
+    target.relay = { ...incoming.relay };
+    result.relayImported = true;
+  }
+  return result;
+}
+function saveAgoraConfig(path, config) {
+  const dir = dirname(path);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const raw = {
+    identity: config.identity,
+    peers: config.peers
+  };
+  if (config.relay) {
+    raw.relay = config.relay;
+  }
+  writeFileSync2(path, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+}
+
 // src/relay/client.ts
 import { EventEmitter } from "events";
 import WebSocket2 from "ws";
@@ -317,7 +494,7 @@ var RelayClient = class extends EventEmitter {
    * Internal: Perform connection
    */
   async doConnect() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       try {
         this.ws = new WebSocket2(this.config.relayUrl);
         let resolved = false;
@@ -343,7 +520,7 @@ var RelayClient = class extends EventEmitter {
             const msg = JSON.parse(data.toString());
             this.handleMessage(msg);
             if (msg.type === "registered" && !resolved) {
-              resolveOnce(() => resolve());
+              resolveOnce(() => resolve2());
             }
           } catch (err) {
             this.emit("error", new Error(`Failed to parse message: ${err instanceof Error ? err.message : String(err)}`));
@@ -523,7 +700,7 @@ var PeerDiscoveryService = class extends EventEmitter2 {
     if (!result.ok) {
       throw new Error(`Failed to send peer list request: ${result.error}`);
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timeout = setTimeout(() => {
         cleanup();
         reject(new Error("Peer list request timed out"));
@@ -531,7 +708,7 @@ var PeerDiscoveryService = class extends EventEmitter2 {
       const messageHandler = (responseEnvelope, from) => {
         if (responseEnvelope.type === "peer_list_response" && responseEnvelope.inReplyTo === envelope.id && from === this.config.relayPublicKey) {
           cleanup();
-          resolve(responseEnvelope.payload);
+          resolve2(responseEnvelope.payload);
         }
       };
       const cleanup = () => {
@@ -858,7 +1035,7 @@ function validateRevealRecord(record) {
 
 // src/reputation/store.ts
 import { promises as fs } from "fs";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 var ReputationStore = class {
   filePath;
   verifications = /* @__PURE__ */ new Map();
@@ -929,7 +1106,7 @@ var ReputationStore = class {
    * Append a record to the JSONL file
    */
   async appendToFile(record) {
-    await fs.mkdir(dirname(this.filePath), { recursive: true });
+    await fs.mkdir(dirname2(this.filePath), { recursive: true });
     const line = JSON.stringify(record) + "\n";
     await fs.appendFile(this.filePath, line, "utf-8");
   }
@@ -1272,6 +1449,15 @@ export {
   sendToPeer,
   decodeInboundEnvelope,
   sendViaRelay,
+  getDefaultConfigPath,
+  loadAgoraConfig,
+  loadAgoraConfigAsync,
+  getConfigDir,
+  getProfileConfigPath,
+  listProfiles,
+  exportConfig,
+  importConfig,
+  saveAgoraConfig,
   RelayClient,
   PeerDiscoveryService,
   DEFAULT_BOOTSTRAP_RELAYS,
@@ -1305,4 +1491,4 @@ export {
   computeTrustScores,
   computeAllTrustScores
 };
-//# sourceMappingURL=chunk-P5EN45ZV.js.map
+//# sourceMappingURL=chunk-UDRIP62M.js.map