abtars 0.3.4-alpha.8 → 0.3.4

package/bundle/tribe-GDTFYJTK.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+ import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
+import {
+  bootstrapIdentity,
+  deriveVerifyKey,
+  init_peer_config,
+  loadPeerConfig
+} from "./chunk-3BG3AIDP.js";
+import "./chunk-5RVOEFGT.js";
+import "./chunk-WC5O5KOE.js";
+import "./chunk-XRTXYN66.js";
+import "./chunk-GALQBVKO.js";
+import "./chunk-O7KQG6ME.js";
+import "./chunk-7K2YZTLD.js";
+
+// src/cli/commands/tribe.ts
+init_peer_config();
+async function tribe(args) {
+  const subcommand = args[0] ?? "status";
+  switch (subcommand) {
+    case "join":
+    case "invite":
+      return await tribeEnroll(args);
+    case "status":
+      return await tribeStatus();
+    default:
+      process.stderr.write(`Unknown tribe subcommand: ${subcommand}
+Usage: abtars tribe join --peer <host:port>
+       abtars tribe invite --peer <host:port>
+       abtars tribe status
+`);
+      return 2;
+  }
+}
+async function tribeEnroll(args) {
+  const peerIdx = args.indexOf("--peer");
+  if (peerIdx < 0 || !args[peerIdx + 1]) {
+    process.stderr.write("Usage: abtars tribe join --peer <host:port>\n");
+    return 1;
+  }
+  const peerArg = args[peerIdx + 1];
+  const colonIdx = peerArg.lastIndexOf(":");
+  if (colonIdx < 0) {
+    process.stderr.write(`Invalid peer address: ${peerArg} (expected host:port)
+`);
+    return 1;
+  }
+  const host = peerArg.slice(0, colonIdx);
+  const port = parseInt(peerArg.slice(colonIdx + 1), 10);
+  if (!host || isNaN(port)) {
+    process.stderr.write(`Invalid peer address: ${peerArg}
+`);
+    return 1;
+  }
+  bootstrapIdentity();
+  const config = loadPeerConfig();
+  const selfVerifyKey = deriveVerifyKey(config.self.signingKey);
+  process.stdout.write(`Enrolling with ${host}:${port}...
+`);
+  const { WsPeerClient } = await import("./ws-peer-client-U3NNPOK7.js");
+  const client = new WsPeerClient("__enrolling__", { host, port, verifyKey: "" });
+  try {
+    await client.enroll(
+      config.self.tribeToken,
+      config.self.signingKey,
+      selfVerifyKey,
+      config.self.name
+    );
+    process.stdout.write(`+ Enrollment successful
+`);
+    process.stdout.write(`  Own verifyKey: ${selfVerifyKey}
+`);
+    process.stdout.write(`  Enrolled peer recorded at trust=1.
+`);
+    return 0;
+  } catch (err) {
+    process.stderr.write(`x Enrollment failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function tribeStatus() {
+  bootstrapIdentity();
+  const config = loadPeerConfig();
+  const verifyKey = deriveVerifyKey(config.self.signingKey);
+  process.stdout.write(`Self: ${config.self.name}
+`);
+  process.stdout.write(`VerifyKey (share out-of-band for enrollment):
+  ${verifyKey}
+
+`);
+  const peers = Object.entries(config.peers);
+  if (peers.length === 0) {
+    process.stdout.write("No enrolled peers.\n");
+    return 0;
+  }
+  process.stdout.write(`Enrolled peers (${peers.length}):
+`);
+  for (const [name, entry] of peers) {
+    const trust = entry.trust ?? 0;
+    const trustLabel = trust === 0 ? "quarantine" : trust === 1 ? "enrolled" : trust === 2 ? "trusted" : `owner(${trust})`;
+    const transport = entry.transport ?? "http";
+    process.stdout.write(`  ${name.padEnd(20)} ${entry.host}:${entry.port}  trust=${trust}(${trustLabel})  transport=${transport}
+`);
+  }
+  return 0;
+}
+export {
+  tribe
+};
+//# sourceMappingURL=tribe-GDTFYJTK.js.map

package/bundle/tribe-GDTFYJTK.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/cli/commands/tribe.ts"],
+  "sourcesContent": ["/**\n * tribe.ts \u2014 abtars tribe CLI (#1293).\n *\n * Commands:\n *   abtars tribe join --peer <host:port>    \u2014 enroll with a remote peer (initiator)\n *   abtars tribe invite --peer <host:port>  \u2014 same (either side can dial; protocol is symmetric)\n *   abtars tribe status                     \u2014 print own verifyKey + list enrolled peers\n */\n\nimport { loadPeerConfig, deriveVerifyKey, bootstrapIdentity } from \"../../components/peer-config.js\";\n\nexport async function tribe(args: string[]): Promise<number> {\n  const subcommand = args[0] ?? \"status\";\n\n  switch (subcommand) {\n    case \"join\":\n    case \"invite\":\n      return await tribeEnroll(args);\n    case \"status\":\n      return await tribeStatus();\n    default:\n      process.stderr.write(`Unknown tribe subcommand: ${subcommand}\\nUsage: abtars tribe join --peer <host:port>\\n       abtars tribe invite --peer <host:port>\\n       abtars tribe status\\n`);\n      return 2;\n  }\n}\n\nasync function tribeEnroll(args: string[]): Promise<number> {\n  // Parse --peer host:port\n  const peerIdx = args.indexOf(\"--peer\");\n  if (peerIdx < 0 || !args[peerIdx + 1]) {\n    process.stderr.write(\"Usage: abtars tribe join --peer <host:port>\\n\");\n    return 1;\n  }\n  const peerArg = args[peerIdx + 1]!;\n  const colonIdx = peerArg.lastIndexOf(\":\");\n  if (colonIdx < 0) {\n    process.stderr.write(`Invalid peer address: ${peerArg} (expected host:port)\\n`);\n    return 1;\n  }\n  const host = peerArg.slice(0, colonIdx);\n  const port = parseInt(peerArg.slice(colonIdx + 1), 10);\n  if (!host || isNaN(port)) {\n    process.stderr.write(`Invalid peer address: ${peerArg}\\n`);\n    return 1;\n  }\n\n  // Ensure identity exists\n  bootstrapIdentity();\n  const config = loadPeerConfig();\n  const selfVerifyKey = deriveVerifyKey(config.self.signingKey);\n\n  process.stdout.write(`Enrolling with ${host}:${port}...\\n`);\n\n  const { WsPeerClient } = await import(\"../../components/peer-transport/ws-peer-client.js\");\n  const client = new WsPeerClient(\"__enrolling__\", { host, port, verifyKey: \"\" });\n\n  try {\n    await client.enroll(\n      config.self.tribeToken,\n      config.self.signingKey,\n      selfVerifyKey,\n      config.self.name,\n    );\n    process.stdout.write(`+ Enrollment successful\\n`);\n    process.stdout.write(`  Own verifyKey: ${selfVerifyKey}\\n`);\n    process.stdout.write(`  Enrolled peer recorded at trust=1.\\n`);\n    return 0;\n  } catch (err) {\n    process.stderr.write(`x Enrollment failed: ${err instanceof Error ? err.message : String(err)}\\n`);\n    return 1;\n  }\n}\n\nasync function tribeStatus(): Promise<number> {\n  bootstrapIdentity();\n  const config = loadPeerConfig();\n  const verifyKey = deriveVerifyKey(config.self.signingKey);\n\n  process.stdout.write(`Self: ${config.self.name}\\n`);\n  process.stdout.write(`VerifyKey (share out-of-band for enrollment):\\n  ${verifyKey}\\n\\n`);\n\n  const peers = Object.entries(config.peers);\n  if (peers.length === 0) {\n    process.stdout.write(\"No enrolled peers.\\n\");\n    return 0;\n  }\n\n  process.stdout.write(`Enrolled peers (${peers.length}):\\n`);\n  for (const [name, entry] of peers) {\n    const trust = entry.trust ?? 0;\n    const trustLabel = trust === 0 ? \"quarantine\" : trust === 1 ? \"enrolled\" : trust === 2 ? \"trusted\" : `owner(${trust})`;\n    const transport = entry.transport ?? \"http\";\n    process.stdout.write(`  ${name.padEnd(20)} ${entry.host}:${entry.port}  trust=${trust}(${trustLabel})  transport=${transport}\\n`);\n  }\n  return 0;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AASA;AAEA,eAAsB,MAAM,MAAiC;AAC3D,QAAM,aAAa,KAAK,CAAC,KAAK;AAE9B,UAAQ,YAAY;AAAA,IAClB,KAAK;AAAA,IACL,KAAK;AACH,aAAO,MAAM,YAAY,IAAI;AAAA,IAC/B,KAAK;AACH,aAAO,MAAM,YAAY;AAAA,IAC3B;AACE,cAAQ,OAAO,MAAM,6BAA6B,UAAU;AAAA;AAAA;AAAA;AAAA,CAA4H;AACxL,aAAO;AAAA,EACX;AACF;AAEA,eAAe,YAAY,MAAiC;AAE1D,QAAM,UAAU,KAAK,QAAQ,QAAQ;AACrC,MAAI,UAAU,KAAK,CAAC,KAAK,UAAU,CAAC,GAAG;AACrC,YAAQ,OAAO,MAAM,+CAA+C;AACpE,WAAO;AAAA,EACT;AACA,QAAM,UAAU,KAAK,UAAU,CAAC;AAChC,QAAM,WAAW,QAAQ,YAAY,GAAG;AACxC,MAAI,WAAW,GAAG;AAChB,YAAQ,OAAO,MAAM,yBAAyB,OAAO;AAAA,CAAyB;AAC9E,WAAO;AAAA,EACT;AACA,QAAM,OAAO,QAAQ,MAAM,GAAG,QAAQ;AACtC,QAAM,OAAO,SAAS,QAAQ,MAAM,WAAW,CAAC,GAAG,EAAE;AACrD,MAAI,CAAC,QAAQ,MAAM,IAAI,GAAG;AACxB,YAAQ,OAAO,MAAM,yBAAyB,OAAO;AAAA,CAAI;AACzD,WAAO;AAAA,EACT;AAGA,oBAAkB;AAClB,QAAM,SAAS,eAAe;AAC9B,QAAM,gBAAgB,gBAAgB,OAAO,KAAK,UAAU;AAE5D,UAAQ,OAAO,MAAM,kBAAkB,IAAI,IAAI,IAAI;AAAA,CAAO;AAE1D,QAAM,EAAE,aAAa,IAAI,MAAM,OAAO,8BAAmD;AACzF,QAAM,SAAS,IAAI,aAAa,iBAAiB,EAAE,MAAM,MAAM,WAAW,GAAG,CAAC;AAE9E,MAAI;AACF,UAAM,OAAO;AAAA,MACX,OAAO,KAAK;AAAA,MACZ,OAAO,KAAK;AAAA,MACZ;AAAA,MACA,OAAO,KAAK;AAAA,IACd;AACA,YAAQ,OAAO,MAAM;AAAA,CAA2B;AAChD,YAAQ,OAAO,MAAM,oBAAoB,aAAa;AAAA,CAAI;AAC1D,YAAQ,OAAO,MAAM;AAAA,CAAwC;AAC7D,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,YAAQ,OAAO,MAAM,wBAAwB,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,CAAI;AACjG,WAAO;AAAA,EACT;AACF;AAEA,eAAe,cAA+B;AAC5C,oBAAkB;AAClB,QAAM,SAAS,eAAe;AAC9B,QAAM,YAAY,gBAAgB,OAAO,KAAK,UAAU;AAExD,UAAQ,OAAO,MAAM,SAAS,OAAO,KAAK,IAAI;AAAA,CAAI;AAClD,UAAQ,OAAO,MAAM;AAAA,IAAoD,SAAS;AAAA;AAAA,CAAM;AAExF,QAAM,QAAQ,OAAO,QAAQ,OAAO,KAAK;AACzC,MAAI,MAAM,WAAW,GAAG;AACtB,YAAQ,OAAO,MAAM,sBAAsB;AAC3C,WAAO;AAAA,EACT;AAEA,UAAQ,OAAO,MAAM,mBAAmB,MAAM,MAAM;AAAA,CAAM;AAC1D,aAAW,CAAC,MAAM,KAAK,KAAK,OAAO;AACjC,UAAM,QAAQ,MAAM,SAAS;AAC7B,UAAM,aAAa,UAAU,IAAI,eAAe,UAAU,IAAI,aAAa,UAAU,IAAI,YAAY,SAAS,KAAK;AACnH,UAAM,YAAY,MAAM,aAAa;AACrC,YAAQ,OAAO,MAAM,KAAK,KAAK,OAAO,EAAE,CAAC,IAAI,MAAM,IAAI,IAAI,MAAM,IAAI,WAAW,KAAK,IAAI,UAAU,gBAAgB,SAAS;AAAA,CAAI;AAAA,EAClI;AACA,SAAO;AACT;",
+  "names": []
+}

package/bundle/{update-CKFP6LBE.js → update-HGQAOC5L.js}

@@ -2,8 +2,8 @@
  import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
 import {
   update
-} from "./chunk-75ATTOW4.js";
-import "./chunk-UNM3OXHB.js";
+} from "./chunk-IY6UKLPS.js";
+import "./chunk-HGSHCQ5F.js";
 import "./chunk-YDY6QVWJ.js";
 import "./chunk-5NY2YULC.js";
 import "./chunk-O7KQG6ME.js";
@@ -11,4 +11,4 @@ import "./chunk-7K2YZTLD.js";
 export {
   update
 };
-//# sourceMappingURL=update-CKFP6LBE.js.map
+//# sourceMappingURL=update-HGQAOC5L.js.map

package/bundle/{usage-tracker-NXD364VX.js → usage-tracker-SR4BI6ZT.js}

@@ -7,7 +7,7 @@ import {
   readUsage,
   recordUsage,
   resetUsage
-} from "./chunk-TMUYFERL.js";
+} from "./chunk-6B5ZFUPD.js";
 import "./chunk-7K2YZTLD.js";
 export {
   flushUsage,
@@ -17,4 +17,4 @@ export {
   recordUsage,
   resetUsage
 };
-//# sourceMappingURL=usage-tracker-NXD364VX.js.map
+//# sourceMappingURL=usage-tracker-SR4BI6ZT.js.map

package/bundle/{user-registry-35BW4XKM.js → user-registry-4PACZJIJ.js}

@@ -5,9 +5,9 @@ import {
   init_user_registry,
   loadUsers,
   setUserRegistryOverride
-} from "./chunk-ZV4IWKDJ.js";
-import "./chunk-65VCEC32.js";
-import "./chunk-GWILHZPT.js";
+} from "./chunk-E7XD5UGB.js";
+import "./chunk-6PA5JBUU.js";
+import "./chunk-XRTXYN66.js";
 import "./chunk-GALQBVKO.js";
 import "./chunk-O7KQG6ME.js";
 import "./chunk-7K2YZTLD.js";
@@ -17,4 +17,4 @@ export {
   loadUsers,
   setUserRegistryOverride
 };
-//# sourceMappingURL=user-registry-35BW4XKM.js.map
+//# sourceMappingURL=user-registry-4PACZJIJ.js.map

package/bundle/wire-platform-KKPWNNNQ.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+ import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
+import {
+  init_logger,
+  logInfo,
+  logWarn
+} from "./chunk-XRTXYN66.js";
+import "./chunk-GALQBVKO.js";
+import "./chunk-O7KQG6ME.js";
+import "./chunk-7K2YZTLD.js";
+
+// src/boot/wire-platform.ts
+init_logger();
+var TAG = "boot";
+async function wireTelegram(ctx) {
+  const adapter = ctx.telegramAdapter;
+  if (!adapter || !ctx.pipelineDeps || !ctx.transport) return;
+  adapter.setMessageHandler({
+    pipeline: ctx.pipelineDeps,
+    conversationBuffer: ctx.conversationBuffer,
+    transport: ctx.transport,
+    memory: ctx.memory,
+    sessionManager: ctx.sessionManager,
+    actionGate: ctx.actionGate
+  });
+  const mainChatId = ctx.config.mainChatId;
+  if (mainChatId) {
+    const { setSendDocument } = await import("./tool-registry-JJMWCQKZ.js");
+    setSendDocument((path, caption) => adapter.sendDocument(String(mainChatId), path, caption));
+    if (ctx.actionGate) {
+      const api = adapter.api;
+      const chatId = String(mainChatId);
+      ctx.actionGate.setNotify(async (text, buttons) => {
+        const opts = {};
+        if (buttons.length > 0) {
+          opts["reply_markup"] = { inline_keyboard: [buttons.map((b) => ({ text: b.text, callback_data: b.data }))] };
+        }
+        await api.sendMessage(chatId, text, opts);
+      });
+    }
+  }
+  logInfo(TAG, "Telegram: full pipeline wired");
+}
+async function wireDiscord(ctx) {
+  const adapter = ctx.discordAdapter;
+  if (!adapter || !ctx.pipelineDeps || !ctx.transport) return;
+  adapter.setMessageHandler({
+    pipeline: ctx.pipelineDeps,
+    transport: ctx.transport,
+    memory: ctx.memory,
+    conversationBuffer: ctx.conversationBuffer
+  });
+  logInfo(TAG, "Discord: full pipeline wired");
+}
+async function wireIrc(ctx) {
+  const adapter = ctx.platformAdapters.get("irc");
+  if (!adapter || !ctx.pipelineDeps) return;
+  const pipelineDeps = ctx.pipelineDeps;
+  if ("setMessageHandler" in adapter) {
+    const { handleInboundMessage } = await import("./message-pipeline-GRDRWONR.js");
+    adapter.setMessageHandler((msg) => {
+      void handleInboundMessage(msg, adapter, pipelineDeps);
+    });
+    const { setIrcSend } = await import("./tool-registry-JJMWCQKZ.js");
+    setIrcSend((channel, message) => {
+      adapter.sendMessage(channel, message);
+    });
+    logInfo(TAG, "IRC: full pipeline wired");
+  }
+}
+async function drainRecoveryQueue(ctx) {
+  const queue = ctx._recoveryQueue;
+  if (!queue?.length || !ctx.pipelineDeps) return;
+  const pipelineDeps = ctx.pipelineDeps;
+  const { handleInboundMessage } = await import("./message-pipeline-GRDRWONR.js");
+  logInfo(TAG, `Draining ${queue.length} queued message(s) from recovery handler`);
+  for (const { msg, adapter } of queue) {
+    handleInboundMessage(msg, adapter, pipelineDeps).catch((err) => logWarn(TAG, `Drain error: ${err}`));
+  }
+  queue.length = 0;
+}
+export {
+  drainRecoveryQueue,
+  wireDiscord,
+  wireIrc,
+  wireTelegram
+};
+//# sourceMappingURL=wire-platform-KKPWNNNQ.js.map

package/bundle/wire-platform-KKPWNNNQ.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/boot/wire-platform.ts"],
+  "sourcesContent": ["/**\n * wire-platform.ts \u2014 idempotent per-platform pipeline wiring (#1306).\n *\n * Called from two sites:\n *   1. phasePipelineDeps (boot path) \u2014 after ctx.pipelineDeps is set.\n *   2. factory.create() in phasePlatformsConnect (retry path) \u2014 when a new\n *      adapter instance is created after phasePipelineDeps already completed.\n *\n * Each function is a no-op when its prerequisite (adapter + pipelineDeps) is\n * absent, so it is safe to call unconditionally from both paths.\n */\n\nimport { logInfo, logWarn } from \"../components/logger.js\";\nimport type { BootCtx } from \"./context.js\";\n\nconst TAG = \"boot\";\n\n/** Wire the full Telegram pipeline onto ctx.telegramAdapter. Idempotent. */\nexport async function wireTelegram(ctx: BootCtx): Promise<void> {\n  const adapter = ctx.telegramAdapter;\n  if (!adapter || !ctx.pipelineDeps || !ctx.transport) return;\n\n  adapter.setMessageHandler({\n    pipeline: ctx.pipelineDeps,\n    conversationBuffer: ctx.conversationBuffer,\n    transport: ctx.transport,\n    memory: ctx.memory,\n    sessionManager: ctx.sessionManager,\n    actionGate: ctx.actionGate,\n  });\n\n  // Re-bind send_document tool + ActionGate notify to THIS adapter instance.\n  // These are stateful globals that must always point to the live instance.\n  const mainChatId = ctx.config.mainChatId;\n  if (mainChatId) {\n    const { setSendDocument } = await import(\"../components/transport/tool-registry.js\");\n    setSendDocument((path, caption) => adapter.sendDocument(String(mainChatId), path, caption));\n    if (ctx.actionGate) {\n      const api = (adapter as unknown as { api: { sendMessage(chatId: string, text: string, opts?: unknown): Promise<unknown> } }).api;\n      const chatId = String(mainChatId);\n      ctx.actionGate.setNotify(async (text: string, buttons: Array<{ text: string; data: string }>) => {\n        const opts: Record<string, unknown> = {};\n        if (buttons.length > 0) {\n          opts[\"reply_markup\"] = { inline_keyboard: [buttons.map(b => ({ text: b.text, callback_data: b.data }))] };\n        }\n        await api.sendMessage(chatId, text, opts);\n      });\n    }\n  }\n\n  logInfo(TAG, \"Telegram: full pipeline wired\");\n}\n\n/** Wire the full Discord pipeline onto ctx.discordAdapter. Idempotent. */\nexport async function wireDiscord(ctx: BootCtx): Promise<void> {\n  const adapter = ctx.discordAdapter;\n  if (!adapter || !ctx.pipelineDeps || !ctx.transport) return;\n\n  adapter.setMessageHandler({\n    pipeline: ctx.pipelineDeps,\n    transport: ctx.transport,\n    memory: ctx.memory,\n    conversationBuffer: ctx.conversationBuffer,\n  });\n\n  logInfo(TAG, \"Discord: full pipeline wired\");\n}\n\n/** Wire the full IRC pipeline + send tool onto the IRC adapter. Idempotent. */\nexport async function wireIrc(ctx: BootCtx): Promise<void> {\n  const adapter = ctx.platformAdapters.get(\"irc\");\n  if (!adapter || !ctx.pipelineDeps) return;\n\n  const pipelineDeps = ctx.pipelineDeps;\n\n  if (\"setMessageHandler\" in adapter) {\n    const { handleInboundMessage } = await import(\"../components/message-pipeline.js\");\n    (adapter as unknown as { setMessageHandler(cb: (msg: unknown) => void): void })\n      .setMessageHandler((msg) => { void handleInboundMessage(msg as never, adapter as never, pipelineDeps); });\n\n    const { setIrcSend } = await import(\"../components/transport/tool-registry.js\");\n    setIrcSend((channel, message) => { adapter.sendMessage(channel, message); });\n\n    logInfo(TAG, \"IRC: full pipeline wired\");\n  }\n}\n\n/** Drain messages queued by the recovery handler while the pipeline was down. */\nexport async function drainRecoveryQueue(ctx: BootCtx): Promise<void> {\n  const queue = (ctx as unknown as { _recoveryQueue?: Array<{ msg: unknown; adapter: unknown }> })._recoveryQueue;\n  if (!queue?.length || !ctx.pipelineDeps) return;\n\n  const pipelineDeps = ctx.pipelineDeps;\n  const { handleInboundMessage } = await import(\"../components/message-pipeline.js\");\n\n  logInfo(TAG, `Draining ${queue.length} queued message(s) from recovery handler`);\n  for (const { msg, adapter } of queue) {\n    handleInboundMessage(msg as never, adapter as never, pipelineDeps)\n      .catch(err => logWarn(TAG, `Drain error: ${err}`));\n  }\n  queue.length = 0;\n}\n"],
+  "mappings": ";;;;;;;;;;;;AAYA;AAGA,IAAM,MAAM;AAGZ,eAAsB,aAAa,KAA6B;AAC9D,QAAM,UAAU,IAAI;AACpB,MAAI,CAAC,WAAW,CAAC,IAAI,gBAAgB,CAAC,IAAI,UAAW;AAErD,UAAQ,kBAAkB;AAAA,IACxB,UAAU,IAAI;AAAA,IACd,oBAAoB,IAAI;AAAA,IACxB,WAAW,IAAI;AAAA,IACf,QAAQ,IAAI;AAAA,IACZ,gBAAgB,IAAI;AAAA,IACpB,YAAY,IAAI;AAAA,EAClB,CAAC;AAID,QAAM,aAAa,IAAI,OAAO;AAC9B,MAAI,YAAY;AACd,UAAM,EAAE,gBAAgB,IAAI,MAAM,OAAO,6BAA0C;AACnF,oBAAgB,CAAC,MAAM,YAAY,QAAQ,aAAa,OAAO,UAAU,GAAG,MAAM,OAAO,CAAC;AAC1F,QAAI,IAAI,YAAY;AAClB,YAAM,MAAO,QAAgH;AAC7H,YAAM,SAAS,OAAO,UAAU;AAChC,UAAI,WAAW,UAAU,OAAO,MAAc,YAAmD;AAC/F,cAAM,OAAgC,CAAC;AACvC,YAAI,QAAQ,SAAS,GAAG;AACtB,eAAK,cAAc,IAAI,EAAE,iBAAiB,CAAC,QAAQ,IAAI,QAAM,EAAE,MAAM,EAAE,MAAM,eAAe,EAAE,KAAK,EAAE,CAAC,EAAE;AAAA,QAC1G;AACA,cAAM,IAAI,YAAY,QAAQ,MAAM,IAAI;AAAA,MAC1C,CAAC;AAAA,IACH;AAAA,EACF;AAEA,UAAQ,KAAK,+BAA+B;AAC9C;AAGA,eAAsB,YAAY,KAA6B;AAC7D,QAAM,UAAU,IAAI;AACpB,MAAI,CAAC,WAAW,CAAC,IAAI,gBAAgB,CAAC,IAAI,UAAW;AAErD,UAAQ,kBAAkB;AAAA,IACxB,UAAU,IAAI;AAAA,IACd,WAAW,IAAI;AAAA,IACf,QAAQ,IAAI;AAAA,IACZ,oBAAoB,IAAI;AAAA,EAC1B,CAAC;AAED,UAAQ,KAAK,8BAA8B;AAC7C;AAGA,eAAsB,QAAQ,KAA6B;AACzD,QAAM,UAAU,IAAI,iBAAiB,IAAI,KAAK;AAC9C,MAAI,CAAC,WAAW,CAAC,IAAI,aAAc;AAEnC,QAAM,eAAe,IAAI;AAEzB,MAAI,uBAAuB,SAAS;AAClC,UAAM,EAAE,qBAAqB,IAAI,MAAM,OAAO,gCAAmC;AACjF,IAAC,QACE,kBAAkB,CAAC,QAAQ;AAAE,WAAK,qBAAqB,KAAc,SAAkB,YAAY;AAAA,IAAG,CAAC;AAE1G,UAAM,EAAE,WAAW,IAAI,MAAM,OAAO,6BAA0C;AAC9E,eAAW,CAAC,SAAS,YAAY;AAAE,cAAQ,YAAY,SAAS,OAAO;AAAA,IAAG,CAAC;AAE3E,YAAQ,KAAK,0BAA0B;AAAA,EACzC;AACF;AAGA,eAAsB,mBAAmB,KAA6B;AACpE,QAAM,QAAS,IAAkF;AACjG,MAAI,CAAC,OAAO,UAAU,CAAC,IAAI,aAAc;AAEzC,QAAM,eAAe,IAAI;AACzB,QAAM,EAAE,qBAAqB,IAAI,MAAM,OAAO,gCAAmC;AAEjF,UAAQ,KAAK,YAAY,MAAM,MAAM,0CAA0C;AAC/E,aAAW,EAAE,KAAK,QAAQ,KAAK,OAAO;AACpC,yBAAqB,KAAc,SAAkB,YAAY,EAC9D,MAAM,SAAO,QAAQ,KAAK,gBAAgB,GAAG,EAAE,CAAC;AAAA,EACrD;AACA,QAAM,SAAS;AACjB;",
+  "names": []
+}

package/bundle/ws-peer-client-U3NNPOK7.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+ import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
+import {
+  init_wrapper,
+  wrapper_default
+} from "./chunk-ZT5ZBGWS.js";
+import "./chunk-R76K6L6H.js";
+import {
+  init_peer_config,
+  loadPeerConfig
+} from "./chunk-3BG3AIDP.js";
+import "./chunk-5RVOEFGT.js";
+import {
+  init_peer_auth,
+  signRequest,
+  verifyServerCert
+} from "./chunk-WC5O5KOE.js";
+import {
+  init_logger,
+  logDebug,
+  logInfo,
+  logWarn
+} from "./chunk-XRTXYN66.js";
+import {
+  abtarsHome,
+  init_paths
+} from "./chunk-GALQBVKO.js";
+import "./chunk-O7KQG6ME.js";
+import {
+  __esm,
+  __require
+} from "./chunk-7K2YZTLD.js";
+
+// src/components/peer-transport/ws-peer-client.ts
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+var TAG, MAX_BACKOFF_MS, REQUEST_TIMEOUT_MS, QUEUE_MAX, WsPeerClient;
+var init_ws_peer_client = __esm({
+  "src/components/peer-transport/ws-peer-client.ts"() {
+    init_wrapper();
+    init_peer_auth();
+    init_peer_config();
+    init_logger();
+    init_paths();
+    TAG = "ws-peer";
+    MAX_BACKOFF_MS = 3e4;
+    REQUEST_TIMEOUT_MS = 3e4;
+    QUEUE_MAX = 200;
+    WsPeerClient = class {
+      ws = null;
+      peerName;
+      entry;
+      backoff = 1e3;
+      reconnectTimer = null;
+      pushHandler = null;
+      pending = /* @__PURE__ */ new Map();
+      destroyed = false;
+      /** Durable outbound queue: pending messages while disconnected. */
+      _queue = [];
+      queuePath;
+      constructor(peerName, entry) {
+        this.peerName = peerName;
+        this.entry = entry;
+        this.queuePath = join(abtarsHome(), `ws-queue-${peerName}.json`);
+        this.loadQueue();
+      }
+      onPush(handler) {
+        this.pushHandler = handler;
+      }
+      connect() {
+        if (this.destroyed) return;
+        if (this.ws && (this.ws.readyState === wrapper_default.OPEN || this.ws.readyState === wrapper_default.CONNECTING)) {
+          return;
+        }
+        const config = loadPeerConfig();
+        if (!this.entry.verifyKey) {
+          logWarn(TAG, `Cannot connect to ${this.peerName}: no verifyKey (not enrolled)`);
+          return;
+        }
+        const url = `wss://${this.entry.host}:${this.entry.port}/v1/ws`;
+        const sigHeaders = signRequest("GET", "/v1/ws", "", config.self.signingKey, config.self.name);
+        this.ws = new wrapper_default(url, {
+          headers: sigHeaders,
+          minVersion: "TLSv1.3",
+          rejectUnauthorized: true,
+          checkServerIdentity: (_host, cert) => {
+            if (!cert.raw) return new Error("No cert from peer");
+            try {
+              const { createPublicKey } = __require("node:crypto");
+              const keyObj = createPublicKey({ key: cert.raw, format: "der", type: "spki" });
+              const certDerB64 = cert.raw.toString("base64");
+              const certPemBlock = `-----BEGIN CERTIFICATE-----
+${certDerB64.match(/.{1,64}/g).join("\n")}
+-----END CERTIFICATE-----
+`;
+              if (!verifyServerCert(certPemBlock, this.entry.verifyKey)) {
+                return new Error(`${this.peerName} cert key != enrolled verifyKey`);
+              }
+            } catch (e) {
+              return new Error(`Cert verify: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            return void 0;
+          }
+        });
+        this.ws.on("open", () => {
+          logInfo(TAG, `Connected to ${this.peerName}`);
+          this.backoff = 1e3;
+          this.ws._socket?.setKeepAlive(true, 2e4);
+          this.drainQueue();
+        });
+        this.ws.on("message", (data) => this.handleMessage(data.toString()));
+        this.ws.on("close", () => {
+          this.cleanup();
+          if (!this.destroyed) this.scheduleReconnect();
+        });
+        this.ws.on("error", (err) => {
+          logDebug(TAG, `WS error (${this.peerName}): ${err.message}`);
+          this.ws?.close();
+        });
+      }
+      /**
+       * Send a message over the WS. If disconnected, enqueues it for delivery on reconnect.
+       */
+      async send(method, payload) {
+        if (!this.ws || this.ws.readyState !== wrapper_default.OPEN) {
+          return this.enqueue(method, payload);
+        }
+        return this.sendNow(method, payload);
+      }
+      get connected() {
+        return this.ws?.readyState === wrapper_default.OPEN;
+      }
+      destroy() {
+        this.destroyed = true;
+        if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+        this.cleanup();
+        this.ws?.close();
+        this.clearPersistedQueue();
+      }
+      async sendNow(method, payload) {
+        if (!this.ws || this.ws.readyState !== wrapper_default.OPEN) {
+          throw new Error(`WS not connected to ${this.peerName}`);
+        }
+        const id = randomUUID();
+        const config = loadPeerConfig();
+        const payloadStr = JSON.stringify(payload);
+        const sigHeaders = signRequest("POST", `/${method}`, payloadStr, config.self.signingKey, config.self.name);
+        return new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            this.pending.delete(id);
+            reject(new Error(`WS request timeout (${this.peerName}/${method})`));
+          }, REQUEST_TIMEOUT_MS);
+          this.pending.set(id, { resolve, reject, timer });
+          this.ws.send(JSON.stringify({ type: "request", id, method, payload, ...sigHeaders }));
+        });
+      }
+      enqueue(method, payload) {
+        return new Promise((resolve, reject) => {
+          if (this._queue.length >= QUEUE_MAX) {
+            const dropped = this._queue.shift();
+            logWarn(TAG, `[warn] ws queue for ${this.peerName} full, dropping oldest (${dropped.method})`);
+          }
+          const entry = { method, payload, id: randomUUID() };
+          this._queue.push(entry);
+          this.persistQueue();
+          resolve({ queued: true, id: entry.id });
+        });
+      }
+      drainQueue() {
+        if (this._queue.length === 0) return;
+        logInfo(TAG, `Draining ${this._queue.length} queued message(s) for ${this.peerName}`);
+        const queue = this._queue.splice(0);
+        this.clearPersistedQueue();
+        for (const entry of queue) {
+          this.sendNow(entry.method, entry.payload).catch((err) => {
+            logWarn(TAG, `Queue drain failed for ${this.peerName}/${entry.method}: ${err.message}`);
+          });
+        }
+      }
+      persistQueue() {
+        try {
+          writeFileSync(this.queuePath, JSON.stringify(this._queue), { encoding: "utf-8", mode: 384 });
+        } catch {
+        }
+      }
+      clearPersistedQueue() {
+        try {
+          if (existsSync(this.queuePath)) unlinkSync(this.queuePath);
+        } catch {
+        }
+      }
+      loadQueue() {
+        try {
+          if (existsSync(this.queuePath)) {
+            const data = readFileSync(this.queuePath, "utf-8");
+            const parsed = JSON.parse(data);
+            if (Array.isArray(parsed)) {
+              this._queue = parsed.slice(0, QUEUE_MAX);
+              if (this._queue.length > 0) {
+                logInfo(TAG, `Loaded ${this._queue.length} queued message(s) for ${this.peerName} from disk`);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      handleMessage(raw) {
+        try {
+          const msg = JSON.parse(raw);
+          if (msg.type === "response" && msg.id && this.pending.has(msg.id)) {
+            const p = this.pending.get(msg.id);
+            this.pending.delete(msg.id);
+            clearTimeout(p.timer);
+            p.resolve(msg.payload);
+          } else if (msg.type === "push") {
+            this.pushHandler?.(msg.method, msg.payload);
+          }
+        } catch {
+        }
+      }
+      cleanup() {
+        for (const [, p] of this.pending) {
+          clearTimeout(p.timer);
+          p.reject(new Error("WS connection closed"));
+        }
+        this.pending.clear();
+      }
+      scheduleReconnect() {
+        const jitter = this.backoff * (0.8 + Math.random() * 0.4);
+        logDebug(TAG, `Reconnecting to ${this.peerName} in ${Math.round(jitter)}ms`);
+        this.reconnectTimer = setTimeout(() => {
+          this.reconnectTimer = null;
+          this.connect();
+        }, jitter);
+        this.backoff = Math.min(this.backoff * 2, MAX_BACKOFF_MS);
+      }
+      /**
+       * Dialer-side enrollment handshake over /v1/enroll-ws.
+       * Called by `abtars tribe join`.
+       */
+      async enroll(tribeToken, selfSigningKey, selfVerifyKey, selfName) {
+        const { randomBytes } = await import("node:crypto");
+        const {
+          macTribe,
+          signEnroll,
+          verifyAck
+        } = await import("./peer-auth-RI43DKJE.js");
+        const { clearPeerConfigCache } = await import("./peer-config-URM7DCW6.js");
+        const { writeFileSync: writeFileSync2, existsSync: exSync, mkdirSync } = await import("node:fs");
+        const enrollUrl = `wss://${this.entry.host}:${this.entry.port}/v1/enroll-ws`;
+        const nonceI = randomBytes(16).toString("hex");
+        const tsNow = Math.floor(Date.now() / 1e3);
+        return new Promise((resolve, reject) => {
+          const enrollWs = new wrapper_default(enrollUrl, {
+            minVersion: "TLSv1.3",
+            rejectUnauthorized: false
+            // Can't pin yet — cert is verified via MAC binding in step B
+          });
+          let stage = 0;
+          let nonceR = "";
+          let pubKeyR = "";
+          enrollWs.on("open", () => {
+            enrollWs.send(JSON.stringify({
+              pubKey_i: selfVerifyKey,
+              nonce_i: nonceI,
+              ts: tsNow
+            }));
+            stage = 1;
+          });
+          enrollWs.on("message", async (rawData) => {
+            try {
+              const msg = JSON.parse(rawData.toString());
+              if (stage === 1) {
+                const { pubKey_r, nonce_r, ts, mac_r } = msg;
+                if (!pubKey_r || !nonce_r || !mac_r) {
+                  reject(new Error("Invalid challenge"));
+                  enrollWs.close();
+                  return;
+                }
+                const expectedMacR = macTribe(tribeToken, pubKey_r + nonceI);
+                if (mac_r !== expectedMacR) {
+                  reject(new Error("tribe token mismatch \u2014 not same tribe"));
+                  enrollWs.close();
+                  return;
+                }
+                nonceR = nonce_r;
+                pubKeyR = pubKey_r;
+                stage = 2;
+                const macI = macTribe(tribeToken, selfVerifyKey + nonceR);
+                const selfSig = signEnroll(selfSigningKey, selfVerifyKey, nonceR, selfName);
+                enrollWs.send(JSON.stringify({
+                  mac_i: macI,
+                  name: selfName,
+                  nonce_r: nonceR,
+                  ts: Math.floor(Date.now() / 1e3),
+                  selfSig
+                }));
+                return;
+              }
+              if (stage === 2) {
+                const { name_r, pubKey_r: pubKeyRd, ackSig } = msg;
+                if (!ackSig || !name_r) {
+                  reject(new Error("Invalid ack"));
+                  enrollWs.close();
+                  return;
+                }
+                if (!verifyAck(ackSig, pubKeyRd, name_r, pubKeyRd, nonceR)) {
+                  reject(new Error("Invalid ack signature"));
+                  enrollWs.close();
+                  return;
+                }
+                const peersPath = join(abtarsHome(), "config", "peers.json");
+                let raw = {};
+                if (exSync(peersPath)) {
+                  try {
+                    raw = JSON.parse(__require("fs").readFileSync(peersPath, "utf-8"));
+                  } catch {
+                    raw = {};
+                  }
+                }
+                if (!raw.peers || typeof raw.peers !== "object") raw.peers = {};
+                raw.peers[name_r] = {
+                  host: this.entry.host,
+                  port: this.entry.port,
+                  verifyKey: pubKeyRd,
+                  trust: 1,
+                  transport: "ws-outbound"
+                };
+                writeFileSync2(peersPath, JSON.stringify(raw, null, 2) + "\n", { encoding: "utf-8" });
+                clearPeerConfigCache();
+                logInfo(TAG, `Enrolled with '${name_r}' at trust=1`);
+                this.ws = enrollWs;
+                enrollWs.removeAllListeners("message");
+                enrollWs.on("message", (data) => this.handleMessage(data.toString()));
+                enrollWs.on("close", () => {
+                  this.cleanup();
+                  if (!this.destroyed) this.scheduleReconnect();
+                });
+                enrollWs.on("error", (err) => {
+                  logDebug(TAG, `WS error (${this.peerName}): ${err.message}`);
+                  this.ws?.close();
+                });
+                resolve();
+              }
+            } catch (err) {
+              reject(err);
+              enrollWs.close();
+            }
+          });
+          enrollWs.on("error", (err) => reject(new Error(`Enrollment WS error: ${err.message}`)));
+          enrollWs.on("close", (code, reason) => {
+            if (stage < 2) reject(new Error(`Enrollment WS closed early: ${code} ${reason}`));
+          });
+          setTimeout(() => {
+            if (stage < 2) {
+              reject(new Error("Enrollment timeout"));
+              enrollWs.close();
+            }
+          }, 3e4);
+        });
+      }
+    };
+  }
+});
+init_ws_peer_client();
+export {
+  WsPeerClient
+};
+//# sourceMappingURL=ws-peer-client-U3NNPOK7.js.map