@highway1/cli 0.1.44 → 0.1.46

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import path, { join } from 'path';
+import path, { join, resolve, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { setMaxListeners as setMaxListeners$1 } from 'events';
 import { Buffer as Buffer$1 } from 'buffer';
@@ -7,7 +7,7 @@ import * as crypto7 from 'crypto';
 import crypto7__default, { webcrypto } from 'crypto';
 import util, { promisify } from 'util';
 import { Resolver } from 'dns/promises';
-import net, { isIPv4, isIPv6 } from 'net';
+import net, { connect, createServer, isIPv4, isIPv6 } from 'net';
 import process3 from 'process';
 import os, { homedir } from 'os';
 import tty from 'tty';
@@ -19,8 +19,11 @@ import { Command } from 'commander';
 import Conf from 'conf';
 import chalk from 'chalk';
 import ora from 'ora';
+import { mkdir, writeFile, readFile } from 'fs/promises';
 import Table from 'cli-table3';
 import inquirer from 'inquirer';
+import { spawn } from 'child_process';
+import { writeFileSync, existsSync, unlinkSync } from 'fs';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -10948,17 +10951,17 @@ var init_src13 = __esm({
 
 // ../../node_modules/.pnpm/@libp2p+logger@5.2.0/node_modules/@libp2p/logger/dist/src/index.js
 function createDisabledLogger(namespace) {
-  const logger11 = () => {
+  const logger13 = () => {
   };
-  logger11.enabled = false;
-  logger11.color = "";
-  logger11.diff = 0;
-  logger11.log = () => {
+  logger13.enabled = false;
+  logger13.color = "";
+  logger13.diff = 0;
+  logger13.log = () => {
   };
-  logger11.namespace = namespace;
-  logger11.destroy = () => true;
-  logger11.extend = () => logger11;
-  return logger11;
+  logger13.namespace = namespace;
+  logger13.destroy = () => true;
+  logger13.extend = () => logger13;
+  return logger13;
 }
 function defaultLogger() {
   return {
@@ -12215,8 +12218,8 @@ var init_src19 = __esm({
 // ../../node_modules/.pnpm/p-defer@4.0.1/node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
-  deferred.promise = new Promise((resolve, reject) => {
-    deferred.resolve = resolve;
+  deferred.promise = new Promise((resolve2, reject) => {
+    deferred.resolve = resolve2;
     deferred.reject = reject;
   });
   return deferred;
@@ -12350,12 +12353,12 @@ function _pushable(getNext, options) {
       if (ended) {
         return { done: true };
       }
-      return await new Promise((resolve, reject) => {
+      return await new Promise((resolve2, reject) => {
         onNext = (next) => {
           onNext = null;
           buffer.push(next);
           try {
-            resolve(getNext(buffer));
+            resolve2(getNext(buffer));
           } catch (err2) {
             reject(err2);
           }
@@ -12431,7 +12434,7 @@ function _pushable(getNext, options) {
       let cancel;
       let listener;
       if (signal != null) {
-        cancel = new Promise((resolve, reject) => {
+        cancel = new Promise((resolve2, reject) => {
           listener = () => {
             reject(new AbortError3());
           };
@@ -12523,7 +12526,7 @@ async function raceEvent(emitter, eventName, signal, opts) {
   if (signal?.aborted === true) {
     return Promise.reject(error2);
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     function removeListeners() {
       removeListener(signal, "abort", abortListener);
       removeListener(emitter, eventName, eventListener);
@@ -12540,7 +12543,7 @@ async function raceEvent(emitter, eventName, signal, opts) {
         return;
       }
       removeListeners();
-      resolve(evt);
+      resolve2(evt);
     };
     const errorEventListener = (evt) => {
       removeListeners();
@@ -12622,7 +12625,7 @@ async function raceSignal(promise, signal, opts) {
   try {
     return await Promise.race([
       promise,
-      new Promise((resolve, reject) => {
+      new Promise((resolve2, reject) => {
         listener = () => {
           reject(translateError(signal));
         };
@@ -13092,7 +13095,7 @@ var init_channel = __esm({
                   name: requestEvent.name,
                   identifier: requestEvent.identifier
                 });
-                await new Promise((resolve) => {
+                await new Promise((resolve2) => {
                   const releaseEventListener = (event2) => {
                     if (event2?.data == null) {
                       return;
@@ -13104,7 +13107,7 @@ var init_channel = __esm({
                     };
                     if (releaseEvent.type === releaseType && releaseEvent.identifier === requestEvent.identifier) {
                       channel.removeEventListener("message", releaseEventListener);
-                      resolve();
+                      resolve2();
                     }
                   };
                   channel.addEventListener("message", releaseEventListener);
@@ -13167,11 +13170,11 @@ var init_cluster = __esm({
                   name: requestEvent.name,
                   identifier: requestEvent.identifier
                 });
-                await new Promise((resolve) => {
+                await new Promise((resolve2) => {
                   const releaseEventListener = (releaseEvent) => {
                     if (releaseEvent.type === releaseType && releaseEvent.identifier === requestEvent.identifier) {
                       worker2.removeListener("message", releaseEventListener);
-                      resolve();
+                      resolve2();
                     }
                   };
                   worker2.on("message", releaseEventListener);
@@ -13258,7 +13261,7 @@ var init_channel2 = __esm({
           identifier: id,
           name: this.name
         });
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const abortListener = () => {
             this.channel.postMessage({
               type: abortType,
@@ -13276,7 +13279,7 @@ var init_channel2 = __esm({
             if (event.data?.type === grantType) {
               this.channel.removeEventListener("message", listener);
               options?.signal?.removeEventListener("abort", abortListener);
-              resolve(() => {
+              resolve2(() => {
                 this.channel.postMessage({
                   type: releaseType,
                   identifier: id,
@@ -13342,7 +13345,7 @@ var init_cluster2 = __esm({
           identifier: id,
           name: this.name
         });
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const abortListener = () => {
             process.send?.({
               type: abortType,
@@ -13360,7 +13363,7 @@ var init_cluster2 = __esm({
             if (event.type === grantType) {
               process.removeListener("message", listener);
               options?.signal?.removeEventListener("abort", abortListener);
-              resolve(() => {
+              resolve2(() => {
                 process.send?.({
                   type: releaseType,
                   identifier: id,
@@ -13506,8 +13509,8 @@ function getImplementation(opts) {
 async function createReleasable(queue, options) {
   let res;
   let rej;
-  const p2 = new Promise((resolve, reject) => {
-    res = resolve;
+  const p2 = new Promise((resolve2, reject) => {
+    res = resolve2;
     rej = reject;
   });
   const listener = () => {
@@ -13517,10 +13520,10 @@ async function createReleasable(queue, options) {
     once: true
   });
   queue.add(async () => {
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       res(() => {
         options?.signal?.removeEventListener("abort", listener);
-        resolve();
+        resolve2();
       });
     });
   }, {
@@ -17147,10 +17150,10 @@ function createDelay({ clearTimeout: defaultClear, setTimeout: defaultSet } = {}
         signal.removeEventListener("abort", signalListener);
       }
     };
-    const delayPromise = new Promise((resolve, reject) => {
+    const delayPromise = new Promise((resolve2, reject) => {
       settle = () => {
         cleanup();
-        resolve(value2);
+        resolve2(value2);
       };
       rejectFunction = reject;
       timeoutId = (defaultSet ?? setTimeout)(settle, milliseconds);
@@ -17668,7 +17671,7 @@ async function raceSignal2(promise, signal, opts) {
   try {
     return await Promise.race([
       promise,
-      new Promise((resolve, reject) => {
+      new Promise((resolve2, reject) => {
         listener = () => {
           reject(error2);
         };
@@ -18948,7 +18951,7 @@ var init_is_network_error = __esm({
 
 // ../../node_modules/.pnpm/p-retry@6.2.1/node_modules/p-retry/index.js
 async function pRetry(input, options) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     options = { ...options };
     options.onFailedAttempt ??= () => {
     };
@@ -18970,7 +18973,7 @@ async function pRetry(input, options) {
       try {
         const result = await input(attemptNumber);
         cleanUp();
-        resolve(result);
+        resolve2(result);
       } catch (error2) {
         try {
           if (!(error2 instanceof Error)) {
@@ -22708,7 +22711,7 @@ function pTimeout(promise, options) {
   } = options;
   let timer;
   let abortHandler;
-  const wrappedPromise = new Promise((resolve, reject) => {
+  const wrappedPromise = new Promise((resolve2, reject) => {
     if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
       throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
     }
@@ -22723,14 +22726,14 @@ function pTimeout(promise, options) {
       signal.addEventListener("abort", abortHandler, { once: true });
     }
     if (milliseconds === Number.POSITIVE_INFINITY) {
-      promise.then(resolve, reject);
+      promise.then(resolve2, reject);
       return;
     }
     const timeoutError = new TimeoutError2();
     timer = customTimers.setTimeout.call(void 0, () => {
       if (fallback) {
         try {
-          resolve(fallback());
+          resolve2(fallback());
         } catch (error2) {
           reject(error2);
         }
@@ -22740,7 +22743,7 @@ function pTimeout(promise, options) {
         promise.cancel();
       }
       if (message2 === false) {
-        resolve();
+        resolve2();
       } else if (message2 instanceof Error) {
         reject(message2);
       } else {
@@ -22750,7 +22753,7 @@ function pTimeout(promise, options) {
     }, milliseconds);
     (async () => {
       try {
-        resolve(await promise);
+        resolve2(await promise);
       } catch (error2) {
         reject(error2);
       }
@@ -22796,7 +22799,7 @@ var init_p_timeout = __esm({
 // ../../node_modules/.pnpm/p-event@6.0.1/node_modules/p-event/index.js
 function pEventMultiple(emitter, event, options) {
   let cancel;
-  const returnValue = new Promise((resolve, reject) => {
+  const returnValue = new Promise((resolve2, reject) => {
     options = {
       rejectionEvents: ["error"],
       multiArgs: false,
@@ -22818,7 +22821,7 @@ function pEventMultiple(emitter, event, options) {
       items.push(value2);
       if (options.count === items.length) {
         cancel();
-        resolve(items);
+        resolve2(items);
       }
     };
     const rejectHandler = (error2) => {
@@ -22845,7 +22848,7 @@ function pEventMultiple(emitter, event, options) {
       }, { once: true });
     }
     if (options.resolveImmediately) {
-      resolve(items);
+      resolve2(items);
     }
   });
   returnValue.cancel = cancel;
@@ -22986,20 +22989,20 @@ function sink(writable) {
       drainCb?.();
     };
     const waitForDrainOrClose = async () => {
-      return new Promise((resolve, reject) => {
-        closeCb = drainCb = resolve;
+      return new Promise((resolve2, reject) => {
+        closeCb = drainCb = resolve2;
         errCb = reject;
         writable.once("drain", drainHandler);
       });
     };
     const waitForDone = async () => {
       await maybeEndSource();
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         if (closed || finished || error2 != null) {
-          resolve();
+          resolve2();
           return;
         }
-        finishCb = closeCb = resolve;
+        finishCb = closeCb = resolve2;
         errCb = reject;
       });
     };
@@ -23450,9 +23453,9 @@ var init_listener = __esm({
           return;
         }
         const netConfig = this.status.netConfig;
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           this.server.once("error", reject);
-          this.server.listen(netConfig, resolve);
+          this.server.listen(netConfig, resolve2);
         });
         this.status = { ...this.status, code: TCPListenerStatusCode.ACTIVE };
         this.log("listening on %s", this.server.address());
@@ -23542,7 +23545,7 @@ var init_tcp = __esm({
         options.signal.throwIfAborted();
         options.onProgress?.(new CustomProgressEvent("tcp:open-connection"));
         let rawSocket;
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const start2 = Date.now();
           const cOpts = multiaddrToNetConfig(ma, {
             ...this.opts.dialOpts ?? {},
@@ -23584,7 +23587,7 @@ var init_tcp = __esm({
               reject(err2);
               return;
             }
-            resolve(rawSocket);
+            resolve2(rawSocket);
           };
           rawSocket.on("error", onError);
           rawSocket.on("timeout", onTimeout);
@@ -31007,7 +31010,7 @@ function byteStream2(duplex2, opts) {
     read: async (bytes, options) => {
       options?.signal?.throwIfAborted();
       let listener;
-      const abortPromise = new Promise((resolve, reject) => {
+      const abortPromise = new Promise((resolve2, reject) => {
         listener = () => {
           reject(new AbortError7("Read aborted"));
         };
@@ -32199,7 +32202,7 @@ var init_dist2 = __esm({
           throwOnTimeout: this.#throwOnTimeout,
           ...options
         };
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           this.#queue.enqueue(async () => {
             this.#pending++;
             try {
@@ -32213,11 +32216,11 @@ var init_dist2 = __esm({
                 operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
               }
               const result = await operation;
-              resolve(result);
+              resolve2(result);
               this.emit("completed", result);
             } catch (error2) {
               if (error2 instanceof TimeoutError2 && !options.throwOnTimeout) {
-                resolve();
+                resolve2();
                 return;
               }
               reject(error2);
@@ -32292,13 +32295,13 @@ var init_dist2 = __esm({
         await this.#onEvent("idle");
       }
       async #onEvent(event, filter2) {
-        return new Promise((resolve) => {
+        return new Promise((resolve2) => {
           const listener = () => {
             if (filter2 && !filter2()) {
               return;
             }
             this.off(event, listener);
-            resolve();
+            resolve2();
           };
           this.on(event, listener);
         });
@@ -106574,7 +106577,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -106601,7 +106604,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -107176,7 +107179,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -107403,7 +107406,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -107958,13 +107961,13 @@ var require_core = __commonJS({
     }, warn() {
     }, error() {
     } };
-    function getLogger(logger11) {
-      if (logger11 === false)
+    function getLogger(logger13) {
+      if (logger13 === false)
         return noLogs;
-      if (logger11 === void 0)
+      if (logger13 === void 0)
         return console;
-      if (logger11.log && logger11.warn && logger11.error)
-        return logger11;
+      if (logger13.log && logger13.warn && logger13.error)
+        return logger13;
       throw new Error("logger must implement log, warn and error methods");
     }
     var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
@@ -112401,7 +112404,7 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync = (path3) => {
+    var readFileSync2 = (path3) => {
       const fd = fs.openSync(path3, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -112409,14 +112412,14 @@ var require_filesystem = __commonJS({
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path3) => new Promise((resolve, reject) => {
+    var readFile2 = (path3) => new Promise((resolve2, reject) => {
       fs.open(path3, "r", (err2, fd) => {
         if (err2) {
           reject(err2);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
           fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
-            resolve(buffer.subarray(0, bytesRead));
+            resolve2(buffer.subarray(0, bytesRead));
             fs.close(fd, () => {
             });
           });
@@ -112426,8 +112429,8 @@ var require_filesystem = __commonJS({
     module.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync,
-      readFile
+      readFileSync: readFileSync2,
+      readFile: readFile2
     };
   }
 });
@@ -112475,7 +112478,7 @@ var require_detect_libc = __commonJS({
     init_esm_shims();
     var childProcess = __require("child_process");
     var { isLinux, getReport } = require_process();
-    var { LDD_PATH, SELF_PATH, readFile, readFileSync } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync2 } = require_filesystem();
     var { interpreterPath } = require_elf();
     var cachedFamilyInterpreter;
     var cachedFamilyFilesystem;
@@ -112484,10 +112487,10 @@ var require_detect_libc = __commonJS({
     var commandOut = "";
     var safeCommand = () => {
       if (!commandOut) {
-        return new Promise((resolve) => {
+        return new Promise((resolve2) => {
           childProcess.exec(command, (err2, out) => {
             commandOut = err2 ? " " : out;
-            resolve(commandOut);
+            resolve2(commandOut);
           });
         });
       }
@@ -112555,7 +112558,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = await readFile(LDD_PATH);
+        const lddContent = await readFile2(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e2) {
       }
@@ -112567,7 +112570,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync(LDD_PATH);
+        const lddContent = readFileSync2(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e2) {
       }
@@ -112579,7 +112582,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = await readFile(SELF_PATH);
+        const selfContent = await readFile2(SELF_PATH);
         const path3 = interpreterPath(selfContent);
         cachedFamilyInterpreter = familyFromInterpreterPath(path3);
       } catch (e2) {
@@ -112592,7 +112595,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = readFileSync(SELF_PATH);
+        const selfContent = readFileSync2(SELF_PATH);
         const path3 = interpreterPath(selfContent);
         cachedFamilyInterpreter = familyFromInterpreterPath(path3);
       } catch (e2) {
@@ -112641,7 +112644,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = await readFile(LDD_PATH);
+        const lddContent = await readFile2(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -112656,7 +112659,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync(LDD_PATH);
+        const lddContent = readFileSync2(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -112769,9 +112772,9 @@ var require_node_gyp_build_optional_packages = __commonJS({
         var debug = getFirst(path3.join(dir, "build/Debug"), matchBuild);
         if (debug) return debug;
       }
-      var prebuild = resolve(dir);
+      var prebuild = resolve2(dir);
       if (prebuild) return prebuild;
-      var nearby = resolve(path3.dirname(process.execPath));
+      var nearby = resolve2(path3.dirname(process.execPath));
       if (nearby) return nearby;
       var platformPackage = (packageName[0] == "@" ? "" : "@" + packageName + "/") + packageName + "-" + platform + "-" + arch;
       try {
@@ -112793,7 +112796,7 @@ var require_node_gyp_build_optional_packages = __commonJS({
         // eslint-disable-line
       ].filter(Boolean).join(" ");
       throw new Error("No native build was found for " + target2 + "\n    attempted loading from: " + dir + " and package: " + platformPackage + "\n");
-      function resolve(dir2) {
+      function resolve2(dir2) {
         var tuples = readdirSync(path3.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
         if (!tuple) return;
@@ -116216,8 +116219,8 @@ async function createNode(config2) {
         // Optimize for small networks: reduce replication factor and query timeout
         kBucketSize: 20,
         // Default K=20, keep for compatibility
-        querySelfInterval: 3e5,
-        // Self-query every 5 min (default 30s)
+        querySelfInterval: 3e4,
+        // Self-query every 30 seconds (libp2p default)
         // Allow queries to complete faster in small networks
         allowQueryWithZeroPeers: true
       });
@@ -116620,6 +116623,11 @@ function createDHTOperations(libp2p) {
     },
     resolveDID: async (did) => {
       try {
+        const cached = peerCache.get(did);
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+          logger4.debug("Using cached peer info", { did });
+          return { peerId: cached.peerId, multiaddrs: cached.multiaddrs };
+        }
         const dht = libp2p.services?.dht;
         if (!dht) throw new DiscoveryError("DHT service not available");
         const key = fromString2(`/clawiverse/agent/${did}`);
@@ -116629,7 +116637,13 @@ function createDHTOperations(libp2p) {
             const card = decodeFromCBOR(raw);
             if (card.peerId) {
               logger4.debug("Resolved DID to peer", { did, peerId: card.peerId });
-              return { peerId: card.peerId, multiaddrs: card.endpoints || [] };
+              const result = { peerId: card.peerId, multiaddrs: card.endpoints || [] };
+              peerCache.set(did, {
+                peerId: result.peerId,
+                multiaddrs: result.multiaddrs,
+                timestamp: Date.now()
+              });
+              return result;
             }
             logger4.warn("Agent Card found but has no peerId", { did });
             return null;
@@ -116718,6 +116732,18 @@ function decodeMessageJSON(json) {
     throw new MessagingError("Failed to decode message from JSON", error2);
   }
 }
+function concatUint8Arrays(arrays) {
+  if (arrays.length === 0) return new Uint8Array(0);
+  if (arrays.length === 1) return arrays[0];
+  const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
 function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
   const handlers = /* @__PURE__ */ new Map();
   let catchAllHandler;
@@ -116768,16 +116794,25 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
           multiaddrs: targetMultiaddrs
         });
         let stream;
+        const DIAL_TIMEOUT2 = 3e3;
         const relayMultiaddrs = targetMultiaddrs.filter((a2) => a2.includes("/p2p-circuit/"));
         const directMultiaddrs = targetMultiaddrs.filter((a2) => !a2.includes("/p2p-circuit/"));
-        for (const addr of directMultiaddrs) {
-          try {
-            const conn = await libp2p.dial(multiaddr(addr));
-            stream = await conn.newStream(PROTOCOL_PREFIX3, { runOnLimitedConnection: true });
-            logger5.info("Direct dial succeeded", { addr });
-            break;
-          } catch {
-          }
+        if (directMultiaddrs.length > 0) {
+          const directDialPromises = directMultiaddrs.map(async (addr) => {
+            try {
+              const conn = await libp2p.dial(multiaddr(addr), {
+                signal: AbortSignal.timeout(DIAL_TIMEOUT2)
+              });
+              const s2 = await conn.newStream(PROTOCOL_PREFIX3, { runOnLimitedConnection: true });
+              logger5.info("Direct dial succeeded", { addr });
+              return s2;
+            } catch {
+              return null;
+            }
+          });
+          stream = await Promise.race(
+            directDialPromises.map((p2) => p2.then((s2) => s2 || Promise.reject()))
+          ).catch(() => void 0);
         }
         let lastError;
         if (!stream) {
@@ -116786,17 +116821,25 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
             ...(relayPeers ?? []).map((r2) => buildCircuitRelayAddr(r2, targetPeerIdStr))
           ];
           const uniqueRelayAddrs = [...new Set(allRelayAddrs)];
-          for (const addr of uniqueRelayAddrs) {
-            try {
-              const conn = await libp2p.dial(multiaddr(addr));
-              logger5.info("Relay connection established", { addr });
-              stream = await conn.newStream(PROTOCOL_PREFIX3, { runOnLimitedConnection: true });
-              logger5.info("Relay stream opened", { addr });
-              break;
-            } catch (relayErr) {
-              logger5.warn("Relay dial failed", { addr, error: relayErr.message });
-              lastError = relayErr;
-            }
+          if (uniqueRelayAddrs.length > 0) {
+            const relayDialPromises = uniqueRelayAddrs.map(async (addr) => {
+              try {
+                const conn = await libp2p.dial(multiaddr(addr), {
+                  signal: AbortSignal.timeout(DIAL_TIMEOUT2)
+                });
+                logger5.info("Relay connection established", { addr });
+                const s2 = await conn.newStream(PROTOCOL_PREFIX3, { runOnLimitedConnection: true });
+                logger5.info("Relay stream opened", { addr });
+                return s2;
+              } catch (relayErr) {
+                logger5.warn("Relay dial failed", { addr, error: relayErr.message });
+                lastError = relayErr;
+                return null;
+              }
+            });
+            stream = await Promise.race(
+              relayDialPromises.map((p2) => p2.then((s2) => s2 || Promise.reject()))
+            ).catch(() => void 0);
           }
         }
         if (!stream && dht && "queryRelayPeers" in dht) {
@@ -116832,21 +116875,14 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
         if (envelope.type === "request") {
           logger5.debug("Waiting for response to request", { id: envelope.id });
           try {
-            const RESPONSE_TIMEOUT = 3e4;
+            const RESPONSE_TIMEOUT = 5e3;
             const responsePromise = (async () => {
               const responseChunks = [];
               for await (const chunk of stream.source) {
                 responseChunks.push(chunk.subarray());
               }
               if (responseChunks.length > 0) {
-                const responseData = new Uint8Array(
-                  responseChunks.reduce((acc, chunk) => acc + chunk.length, 0)
-                );
-                let offset = 0;
-                for (const chunk of responseChunks) {
-                  responseData.set(chunk, offset);
-                  offset += chunk.length;
-                }
+                const responseData = concatUint8Arrays(responseChunks);
                 const responseEnvelope = decodeMessage2(responseData);
                 logger5.info("Received response", {
                   id: responseEnvelope.id,
@@ -116858,10 +116894,10 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
                 return void 0;
               }
             })();
-            const timeoutPromise = new Promise((resolve) => {
+            const timeoutPromise = new Promise((resolve2) => {
               setTimeout(() => {
                 logger5.warn("Response timeout", { id: envelope.id, timeout: RESPONSE_TIMEOUT });
-                resolve(void 0);
+                resolve2(void 0);
               }, RESPONSE_TIMEOUT);
             });
             const response = await Promise.race([responsePromise, timeoutPromise]);
@@ -116904,14 +116940,7 @@ async function handleIncomingStream(stream, handlers, catchAllHandler, verifyFn)
     for await (const chunk of stream.source) {
       chunks.push(chunk.subarray());
     }
-    const data = new Uint8Array(
-      chunks.reduce((acc, chunk) => acc + chunk.length, 0)
-    );
-    let offset = 0;
-    for (const chunk of chunks) {
-      data.set(chunk, offset);
-      offset += chunk.length;
-    }
+    const data = concatUint8Arrays(chunks);
     const envelope = decodeMessage2(data);
     if (!validateEnvelope(envelope)) {
       logger5.warn("Received invalid message envelope");
@@ -116996,7 +117025,7 @@ function createDefaultTrustScore() {
 function createTrustSystem(config2) {
   return new TrustSystem(config2);
 }
-var import_ajv, import_lunr, ClawiverseError, IdentityError, TransportError, DiscoveryError, MessagingError, LogLevel, Logger, createLogger, logger2, legacyAgentCardSchema, ajv, validateLegacySchema, CLAWIVERSE_CONTEXT, SCHEMA_ORG_CONTEXT, clawiverseContext, CapabilityTypes, ParameterTypes, logger22, SearchIndex, CapabilityMatcher, logger3, SemanticSearchEngine, logger4, logger5, TrustMetrics, logger6, InteractionHistory, logger7, EndorsementManager, logger8, SybilDefense, logger9, TrustSystem;
+var import_ajv, import_lunr, ClawiverseError, IdentityError, TransportError, DiscoveryError, MessagingError, LogLevel, Logger, createLogger, logger2, legacyAgentCardSchema, ajv, validateLegacySchema, CLAWIVERSE_CONTEXT, SCHEMA_ORG_CONTEXT, clawiverseContext, CapabilityTypes, ParameterTypes, logger22, SearchIndex, CapabilityMatcher, logger3, SemanticSearchEngine, logger4, peerCache, CACHE_TTL, logger5, TrustMetrics, logger6, InteractionHistory, logger7, EndorsementManager, logger8, SybilDefense, logger9, TrustSystem;
 var init_dist3 = __esm({
   "../core/dist/index.js"() {
     init_esm_shims();
@@ -117644,6 +117673,8 @@ var init_dist3 = __esm({
       }
     };
     logger4 = createLogger("dht");
+    peerCache = /* @__PURE__ */ new Map();
+    CACHE_TTL = 5 * 60 * 1e3;
     logger5 = createLogger("router");
     TrustMetrics = class {
       /**
@@ -118313,7 +118344,7 @@ function registerInitCommand(program2) {
 init_esm_shims();
 init_dist3();
 function registerJoinCommand(program2) {
-  program2.command("join").description("Join the Clawiverse network").option("--bootstrap <peers...>", "Bootstrap peer addresses").option("--relay", "Run as a relay server and advertise relay capability").action(async (options) => {
+  program2.command("join").description("Join the Clawiverse network").option("--bootstrap <peers...>", "Bootstrap peer addresses").option("--relay", "Run as a relay server and advertise relay capability").option("--save-dir <path>", "Directory to save received file attachments", "./downloads").action(async (options) => {
     try {
       printHeader("Join Clawiverse Network");
       const identity3 = getIdentity();
@@ -118343,12 +118374,12 @@ function registerJoinCommand(program2) {
       info(`Listening on: ${node.getMultiaddrs().join(", ")}`);
       const connectSpin = spinner("Connecting to bootstrap peers...");
       let connected = false;
-      await new Promise((resolve) => {
-        const timeout = setTimeout(resolve, 1e4);
+      await new Promise((resolve2) => {
+        const timeout = setTimeout(resolve2, 1e4);
         node.libp2p.addEventListener("peer:connect", () => {
           connected = true;
           clearTimeout(timeout);
-          resolve();
+          resolve2();
         }, { once: true });
       });
       if (!connected && bootstrapPeers.length > 0) {
@@ -118368,7 +118399,7 @@ function registerJoinCommand(program2) {
       info("Waiting for relay reservation...");
       let reservationSucceeded = false;
       if (initialRelayCount === 0) {
-        await new Promise((resolve) => {
+        await new Promise((resolve2) => {
           const RELAY_WAIT_MS = 3e4;
           const POLL_MS = 500;
           let settled = false;
@@ -118379,7 +118410,7 @@ function registerJoinCommand(program2) {
             clearInterval(pollTimer);
             node.libp2p.removeEventListener("relay:reservation", onReservation);
             node.libp2p.removeEventListener("self:peer:update", onPeerUpdate);
-            resolve();
+            resolve2();
           };
           const onReservation = () => {
             reservationSucceeded = true;
@@ -118514,6 +118545,7 @@ function registerJoinCommand(program2) {
         verifyFn,
         dht
       );
+      const saveDir = resolve(options.saveDir ?? "./downloads");
       const messageHandler = async (envelope) => {
         const payload = envelope.payload;
         console.log();
@@ -118521,7 +118553,24 @@ function registerJoinCommand(program2) {
         info(`    Message ID: ${envelope.id}`);
         info(`    Protocol:   ${envelope.protocol}`);
         info(`    Type:       ${envelope.type}`);
-        info(`    Payload:    ${JSON.stringify(payload, null, 2)}`);
+        let savedPath;
+        if (payload.attachment) {
+          const att = payload.attachment;
+          try {
+            await mkdir(saveDir, { recursive: true });
+            const safeName = att.filename.replace(/[^a-zA-Z0-9._-]/g, "_");
+            savedPath = join(saveDir, `${envelope.id.slice(-8)}_${safeName}`);
+            await writeFile(savedPath, Buffer.from(att.data, "base64"));
+            success(`    Attachment saved: ${savedPath}`);
+            info(`    File: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+          } catch (e2) {
+            error(`    Failed to save attachment: ${e2.message}`);
+          }
+          const displayPayload = { ...payload, attachment: "[binary data omitted]" };
+          info(`    Payload:    ${JSON.stringify(displayPayload, null, 2)}`);
+        } else {
+          info(`    Payload:    ${JSON.stringify(payload, null, 2)}`);
+        }
         console.log();
         if (envelope.type === "request") {
           info("    Sending acknowledgment response...");
@@ -118533,19 +118582,16 @@ function registerJoinCommand(program2) {
           });
           const responseEnvelope = createEnvelope2(
             envelope.to,
-            // We are the recipient, now we're the sender
             envelope.from,
-            // Original sender is now the recipient
             "response",
             envelope.protocol,
             {
               status: "received",
               message: "Message received and processed",
-              originalPayload: payload,
+              savedPath: savedPath ?? null,
               timestamp: Date.now()
             },
             envelope.id
-            // replyTo: original message ID
           );
           const signedResponse = await signEnvelope2(
             responseEnvelope,
@@ -118607,11 +118653,11 @@ function registerDiscoverCommand(program2) {
       });
       await node.start();
       spin.text = "Waiting for DHT peers...";
-      await new Promise((resolve) => {
-        const timeout = setTimeout(resolve, 15e3);
+      await new Promise((resolve2) => {
+        const timeout = setTimeout(resolve2, 15e3);
         node.libp2p.addEventListener("peer:connect", () => {
           clearTimeout(timeout);
-          setTimeout(resolve, 3e3);
+          setTimeout(resolve2, 3e3);
         }, { once: true });
       });
       spin.text = "Querying DHT...";
@@ -118705,8 +118751,68 @@ function registerDiscoverCommand(program2) {
 // src/commands/send.ts
 init_esm_shims();
 init_dist3();
+
+// src/daemon/client.ts
+init_esm_shims();
+init_dist3();
+var logger10 = createLogger("daemon-client");
+var DaemonClient = class {
+  socketPath;
+  constructor(socketPath = "/tmp/clawiverse.sock") {
+    this.socketPath = socketPath;
+  }
+  async send(command, params) {
+    return new Promise((resolve2, reject) => {
+      const socket = connect(this.socketPath);
+      const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      let responseReceived = false;
+      socket.on("connect", () => {
+        const request = { id: requestId, command, params };
+        logger10.debug("Sending request", { command, id: requestId });
+        socket.write(JSON.stringify(request));
+      });
+      socket.on("data", (data) => {
+        try {
+          const response = JSON.parse(data.toString());
+          responseReceived = true;
+          socket.end();
+          logger10.debug("Received response", { success: response.success, id: response.id });
+          if (response.success) {
+            resolve2(response.data);
+          } else {
+            reject(new Error(response.error));
+          }
+        } catch (error2) {
+          reject(new Error(`Failed to parse response: ${error2.message}`));
+        }
+      });
+      socket.on("error", (err2) => {
+        if (!responseReceived) {
+          logger10.debug("Socket error", { error: err2.message });
+          reject(err2);
+        }
+      });
+      socket.setTimeout(3e4, () => {
+        if (!responseReceived) {
+          socket.destroy();
+          reject(new Error("Request timeout"));
+        }
+      });
+    });
+  }
+  async isDaemonRunning() {
+    try {
+      await this.send("status", {});
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/commands/send.ts
 function registerSendCommand(program2) {
-  program2.command("send").description("Send a message to another agent").requiredOption("--to <did>", "Recipient DID").requiredOption("--protocol <protocol>", "Protocol identifier").requiredOption("--payload <json>", "Message payload (JSON)").option("--type <type>", "Message type (request|notification)", "request").option("--bootstrap <peers...>", "Bootstrap peer addresses").option("--peer <multiaddr>", "Direct peer multiaddr (bypasses DHT lookup)").action(async (options) => {
+  program2.command("send").description("Send a message to another agent").requiredOption("--to <did>", "Recipient DID").requiredOption("--protocol <protocol>", "Protocol identifier").option("--payload <json>", "Message payload (JSON)").option("--file <path>", "Attach a file (image, binary, text) as payload attachment").option("--type <type>", "Message type (request|notification)", "request").option("--bootstrap <peers...>", "Bootstrap peer addresses").option("--peer <multiaddr>", "Direct peer multiaddr (bypasses DHT lookup)").action(async (options) => {
     try {
       printHeader("Send Message");
       const identity3 = getIdentity();
@@ -118714,13 +118820,95 @@ function registerSendCommand(program2) {
         error('No identity found. Run "hw1 init" first.');
         process.exit(1);
       }
-      let payload;
-      try {
-        payload = JSON.parse(options.payload);
-      } catch {
-        error("Invalid JSON payload");
+      if (!options.payload && !options.file) {
+        error("Either --payload <json> or --file <path> is required.");
         process.exit(1);
       }
+      let payload = {};
+      if (options.payload) {
+        try {
+          payload = JSON.parse(options.payload);
+        } catch {
+          error("Invalid JSON payload");
+          process.exit(1);
+        }
+      }
+      if (options.file) {
+        const filePath = options.file;
+        let fileBytes;
+        try {
+          fileBytes = await readFile(filePath);
+        } catch {
+          error(`Cannot read file: ${filePath}`);
+          process.exit(1);
+        }
+        const filename = basename(filePath);
+        const mimeType = guessMimeType(filename);
+        payload.attachment = {
+          filename,
+          mimeType,
+          size: fileBytes.length,
+          data: fileBytes.toString("base64")
+        };
+        info(`Attaching file: ${filename} (${fileBytes.length} bytes, ${mimeType})`);
+      }
+      const client = new DaemonClient();
+      if (await client.isDaemonRunning()) {
+        const spin2 = spinner("Sending message via daemon...");
+        try {
+          const result = await client.send("send", {
+            to: options.to,
+            protocol: options.protocol,
+            payload,
+            type: options.type,
+            peer: options.peer
+          });
+          spin2.succeed("Message sent successfully!");
+          console.log();
+          info(`Message ID: ${result.id}`);
+          info(`To: ${options.to}`);
+          info(`Protocol: ${options.protocol}`);
+          info(`Type: ${options.type}`);
+          if (payload.attachment) {
+            const att = payload.attachment;
+            info(`Attachment: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+            const rest = { ...payload, attachment: "[binary data omitted]" };
+            info(`Payload: ${JSON.stringify(rest)}`);
+          } else {
+            info(`Payload: ${JSON.stringify(payload)}`);
+          }
+          if (result.response) {
+            console.log();
+            success(">>> Received response from recipient");
+            info(`Response ID: ${result.response.id}`);
+            info(`Reply To: ${result.response.replyTo}`);
+            info(`Protocol: ${result.response.protocol}`);
+            const respPayload = result.response.payload;
+            if (respPayload?.attachment) {
+              const att = respPayload.attachment;
+              info(`Attachment: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+              info(`Payload: ${JSON.stringify({ ...respPayload, attachment: "[binary data omitted]" }, null, 2)}`);
+            } else {
+              info(`Payload: ${JSON.stringify(result.response.payload, null, 2)}`);
+            }
+          } else if (options.type === "request") {
+            console.log();
+            info("No response received (recipient may not have returned a response)");
+          }
+          success("Done");
+          return;
+        } catch (err2) {
+          spin2.fail("Daemon send failed, falling back to ephemeral node");
+          console.log();
+          info('Tip: Restart daemon with "clawiverse daemon restart" if issues persist');
+          console.log();
+        }
+      } else {
+        console.log();
+        info("\u26A0 Daemon not running, using ephemeral node (slower)");
+        info('Tip: Start daemon with "clawiverse daemon start" for faster messaging');
+        console.log();
+      }
       const spin = spinner("Starting node...");
       const keyPair = importKeyPair({
         publicKey: identity3.publicKey,
@@ -118732,11 +118920,11 @@ function registerSendCommand(program2) {
         bootstrapPeers,
         enableDHT: true
       });
-      const identifyDone = new Promise((resolve) => {
-        const timeout = setTimeout(resolve, 12e3);
+      const identifyDone = new Promise((resolve2) => {
+        const timeout = setTimeout(resolve2, 2e3);
         node.libp2p.addEventListener("peer:identify", () => {
           clearTimeout(timeout);
-          setTimeout(resolve, 500);
+          resolve2();
         }, { once: true });
       });
       await node.start();
@@ -118791,14 +118979,28 @@ function registerSendCommand(program2) {
       info(`To: ${options.to}`);
       info(`Protocol: ${options.protocol}`);
       info(`Type: ${options.type}`);
-      info(`Payload: ${JSON.stringify(payload)}`);
+      if (payload.attachment) {
+        const att = payload.attachment;
+        info(`Attachment: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+        const rest = { ...payload, attachment: "[binary data omitted]" };
+        info(`Payload: ${JSON.stringify(rest)}`);
+      } else {
+        info(`Payload: ${JSON.stringify(payload)}`);
+      }
       if (response) {
         console.log();
         success(">>> Received response from recipient");
         info(`Response ID: ${response.id}`);
         info(`Reply To: ${response.replyTo}`);
         info(`Protocol: ${response.protocol}`);
-        info(`Payload: ${JSON.stringify(response.payload, null, 2)}`);
+        const respPayload = response.payload;
+        if (respPayload?.attachment) {
+          const att = respPayload.attachment;
+          info(`Attachment: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+          info(`Payload: ${JSON.stringify({ ...respPayload, attachment: "[binary data omitted]" }, null, 2)}`);
+        } else {
+          info(`Payload: ${JSON.stringify(response.payload, null, 2)}`);
+        }
       } else if (options.type === "request") {
         console.log();
         info("No response received (recipient may not have returned a response)");
@@ -118814,6 +119016,32 @@ function registerSendCommand(program2) {
     }
   });
 }
+function guessMimeType(filename) {
+  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+  const map2 = {
+    // images
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    // documents
+    pdf: "application/pdf",
+    txt: "text/plain",
+    md: "text/markdown",
+    json: "application/json",
+    csv: "text/csv",
+    // audio/video
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    wav: "audio/wav",
+    // archives
+    zip: "application/zip",
+    gz: "application/gzip"
+  };
+  return map2[ext] ?? "application/octet-stream";
+}
 
 // src/commands/status.ts
 init_esm_shims();
@@ -118950,7 +119178,7 @@ function registerCardCommand(program2) {
 // src/commands/trust.ts
 init_esm_shims();
 init_dist3();
-var logger10 = createLogger("cli:trust");
+var logger11 = createLogger("cli:trust");
 function createTrustCommand() {
   const trust = new Command("trust").description("Manage trust scores and endorsements");
   trust.command("show").description("Show trust score for an agent").argument("<did>", "Agent DID").action(async (did) => {
@@ -118983,7 +119211,7 @@ function createTrustCommand() {
       }
       await trustSystem.stop();
     } catch (error2) {
-      logger10.error("Failed to show trust score", error2);
+      logger11.error("Failed to show trust score", error2);
       console.error("Error:", error2 instanceof Error ? error2.message : error2);
       process.exit(1);
     }
@@ -119024,7 +119252,7 @@ function createTrustCommand() {
       console.log(`Reason: ${endorsement.reason}`);
       await trustSystem.stop();
     } catch (error2) {
-      logger10.error("Failed to endorse agent", error2);
+      logger11.error("Failed to endorse agent", error2);
       console.error("Error:", error2 instanceof Error ? error2.message : error2);
       process.exit(1);
     }
@@ -119060,7 +119288,7 @@ function createTrustCommand() {
       }
       await trustSystem.stop();
     } catch (error2) {
-      logger10.error("Failed to show history", error2);
+      logger11.error("Failed to show history", error2);
       console.error("Error:", error2 instanceof Error ? error2.message : error2);
       process.exit(1);
     }
@@ -119097,7 +119325,7 @@ function createTrustCommand() {
       await history.close();
       await trustSystem.stop();
     } catch (error2) {
-      logger10.error("Failed to show stats", error2);
+      logger11.error("Failed to show stats", error2);
       console.error("Error:", error2 instanceof Error ? error2.message : error2);
       process.exit(1);
     }
@@ -119105,16 +119333,367 @@ function createTrustCommand() {
   return trust;
 }
 
+// src/commands/daemon.ts
+init_esm_shims();
+
+// src/daemon/server.ts
+init_esm_shims();
+init_dist3();
+init_dist3();
+var logger12 = createLogger("daemon");
+var ClawDaemon = class {
+  node = null;
+  router = null;
+  dht = null;
+  server = null;
+  socketPath;
+  identity;
+  bootstrapPeers;
+  constructor(socketPath = "/tmp/clawiverse.sock") {
+    this.socketPath = socketPath;
+    this.identity = getIdentity();
+    this.bootstrapPeers = getBootstrapPeers();
+    if (!this.identity) {
+      throw new Error('No identity found. Run "clawiverse init" first.');
+    }
+  }
+  async start() {
+    try {
+      logger12.info("Starting Clawiverse daemon", { socketPath: this.socketPath });
+      const keyPair = importKeyPair({
+        publicKey: this.identity.publicKey,
+        privateKey: this.identity.privateKey
+      });
+      this.node = await createNode({
+        keyPair,
+        bootstrapPeers: this.bootstrapPeers,
+        enableDHT: true
+      });
+      await this.node.start();
+      logger12.info("Node started", { peerId: this.node.getPeerId() });
+      this.dht = createDHTOperations(this.node.libp2p);
+      const verifyFn = async (signature, data) => {
+        try {
+          const decoded = JSON.parse(new TextDecoder().decode(data));
+          if (!decoded.from || typeof decoded.from !== "string") return false;
+          const senderPublicKey = extractPublicKey(decoded.from);
+          return verify(signature, data, senderPublicKey);
+        } catch {
+          return false;
+        }
+      };
+      this.router = createMessageRouter(
+        this.node.libp2p,
+        verifyFn,
+        this.dht,
+        this.bootstrapPeers
+      );
+      await this.router.start();
+      logger12.info("Router started");
+      this.server = createServer((socket) => {
+        this.handleConnection(socket);
+      });
+      this.server.listen(this.socketPath);
+      logger12.info("Daemon listening", { socketPath: this.socketPath });
+      console.log(`\u2713 Clawiverse daemon started`);
+      console.log(`  Socket: ${this.socketPath}`);
+      console.log(`  Peer ID: ${this.node.getPeerId()}`);
+      console.log(`  DID: ${this.identity.did}`);
+    } catch (error2) {
+      logger12.error("Failed to start daemon", error2);
+      throw error2;
+    }
+  }
+  handleConnection(socket) {
+    socket.on("data", async (data) => {
+      try {
+        const request = JSON.parse(data.toString());
+        logger12.debug("Received request", { command: request.command, id: request.id });
+        const response = await this.handleRequest(request);
+        socket.write(JSON.stringify(response) + "\n");
+      } catch (error2) {
+        const errorResponse = {
+          id: "unknown",
+          success: false,
+          error: error2.message
+        };
+        socket.write(JSON.stringify(errorResponse) + "\n");
+      }
+    });
+    socket.on("error", (error2) => {
+      logger12.warn("Socket error", { error: error2.message });
+    });
+  }
+  async handleRequest(req) {
+    try {
+      switch (req.command) {
+        case "send":
+          return await this.handleSend(req);
+        case "discover":
+          return await this.handleDiscover(req);
+        case "status":
+          return this.handleStatus(req);
+        case "shutdown":
+          await this.shutdown();
+          return { id: req.id, success: true };
+        default:
+          return { id: req.id, success: false, error: "Unknown command" };
+      }
+    } catch (error2) {
+      logger12.error("Request handler error", { command: req.command, error: error2 });
+      return { id: req.id, success: false, error: error2.message };
+    }
+  }
+  async handleSend(req) {
+    const { to, protocol, payload, type, peer } = req.params;
+    if (!this.router) {
+      return { id: req.id, success: false, error: "Router not initialized" };
+    }
+    const envelope = createEnvelope(
+      this.identity.did,
+      to,
+      type || "request",
+      protocol,
+      payload
+    );
+    const keyPair = importKeyPair({
+      publicKey: this.identity.publicKey,
+      privateKey: this.identity.privateKey
+    });
+    const signedEnvelope = await signEnvelope(
+      envelope,
+      (data) => sign(data, keyPair.privateKey)
+    );
+    let peerHint = void 0;
+    if (peer) {
+      const parts = peer.split("/p2p/");
+      if (parts.length === 2) {
+        peerHint = {
+          peerId: parts[1],
+          multiaddrs: [peer]
+        };
+      }
+    }
+    const response = await this.router.sendMessage(signedEnvelope, peerHint);
+    return {
+      id: req.id,
+      success: true,
+      data: {
+        id: signedEnvelope.id,
+        response: response || null
+      }
+    };
+  }
+  async handleDiscover(req) {
+    const { query } = req.params;
+    if (!this.dht) {
+      return { id: req.id, success: false, error: "DHT not initialized" };
+    }
+    const results = await this.dht.searchSemantic(query);
+    return {
+      id: req.id,
+      success: true,
+      data: results
+    };
+  }
+  handleStatus(req) {
+    if (!this.node) {
+      return { id: req.id, success: false, error: "Node not initialized" };
+    }
+    return {
+      id: req.id,
+      success: true,
+      data: {
+        running: true,
+        peerId: this.node.getPeerId(),
+        did: this.identity.did,
+        multiaddrs: this.node.getMultiaddrs(),
+        bootstrapPeers: this.bootstrapPeers
+      }
+    };
+  }
+  async shutdown() {
+    logger12.info("Shutting down daemon");
+    if (this.router) {
+      await this.router.stop();
+      this.router = null;
+    }
+    if (this.node) {
+      await this.node.stop();
+      this.node = null;
+    }
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    logger12.info("Daemon stopped");
+  }
+};
+var PID_FILE = "/tmp/clawiverse.pid";
+var SOCKET_PATH = "/tmp/clawiverse.sock";
+function registerDaemonCommand(program2) {
+  const daemonCommand = program2.command("daemon").description("Manage Clawiverse daemon for fast messaging");
+  daemonCommand.command("start").description("Start daemon in background").action(async () => {
+    try {
+      const client = new DaemonClient(SOCKET_PATH);
+      if (await client.isDaemonRunning()) {
+        success("Daemon already running");
+        const status = await client.send("status", {});
+        info(`Peer ID: ${status.peerId}`);
+        info(`DID: ${status.did}`);
+        return;
+      }
+      const child = spawn(process.execPath, [
+        process.argv[1],
+        "daemon",
+        "run"
+      ], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      writeFileSync(PID_FILE, child.pid.toString());
+      for (let i2 = 0; i2 < 20; i2++) {
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
+        if (await client.isDaemonRunning()) {
+          success("Daemon started");
+          const status = await client.send("status", {});
+          info(`Peer ID: ${status.peerId}`);
+          info(`DID: ${status.did}`);
+          info(`Socket: ${SOCKET_PATH}`);
+          return;
+        }
+      }
+      error("Failed to start daemon (timeout)");
+      process.exit(1);
+    } catch (err2) {
+      error(`Failed to start daemon: ${err2.message}`);
+      process.exit(1);
+    }
+  });
+  daemonCommand.command("run").description("Run daemon in foreground (internal use)").action(async () => {
+    try {
+      const daemon = new ClawDaemon(SOCKET_PATH);
+      await daemon.start();
+      process.on("SIGINT", async () => {
+        console.log("\nShutting down...");
+        await daemon.shutdown();
+        process.exit(0);
+      });
+      process.on("SIGTERM", async () => {
+        await daemon.shutdown();
+        process.exit(0);
+      });
+    } catch (err2) {
+      error(`Failed to run daemon: ${err2.message}`);
+      process.exit(1);
+    }
+  });
+  daemonCommand.command("stop").description("Stop daemon").action(async () => {
+    try {
+      const client = new DaemonClient(SOCKET_PATH);
+      if (!await client.isDaemonRunning()) {
+        info("Daemon not running");
+        return;
+      }
+      await client.send("shutdown", {});
+      success("Daemon stopped");
+      try {
+        if (existsSync(PID_FILE)) {
+          unlinkSync(PID_FILE);
+        }
+      } catch {
+      }
+      try {
+        if (existsSync(SOCKET_PATH)) {
+          unlinkSync(SOCKET_PATH);
+        }
+      } catch {
+      }
+    } catch (err2) {
+      error(`Failed to stop daemon: ${err2.message}`);
+      process.exit(1);
+    }
+  });
+  daemonCommand.command("status").description("Check daemon status").action(async () => {
+    try {
+      const client = new DaemonClient(SOCKET_PATH);
+      if (await client.isDaemonRunning()) {
+        const status = await client.send("status", {});
+        success("Daemon running");
+        console.log();
+        info(`Peer ID: ${status.peerId}`);
+        info(`DID: ${status.did}`);
+        info(`Socket: ${SOCKET_PATH}`);
+        info(`Bootstrap peers: ${status.bootstrapPeers.length}`);
+        console.log();
+        info("Multiaddrs:");
+        status.multiaddrs.forEach((addr) => {
+          console.log(`  ${addr}`);
+        });
+      } else {
+        info("Daemon not running");
+        console.log();
+        info("Start daemon with: clawiverse daemon start");
+      }
+    } catch (err2) {
+      error(`Failed to check status: ${err2.message}`);
+      process.exit(1);
+    }
+  });
+  daemonCommand.command("restart").description("Restart daemon").action(async () => {
+    try {
+      const client = new DaemonClient(SOCKET_PATH);
+      if (await client.isDaemonRunning()) {
+        info("Stopping daemon...");
+        await client.send("shutdown", {});
+        await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+      }
+      try {
+        if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
+        if (existsSync(SOCKET_PATH)) unlinkSync(SOCKET_PATH);
+      } catch {
+      }
+      info("Starting daemon...");
+      const child = spawn(process.execPath, [
+        process.argv[1],
+        "daemon",
+        "run"
+      ], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      writeFileSync(PID_FILE, child.pid.toString());
+      for (let i2 = 0; i2 < 20; i2++) {
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
+        if (await client.isDaemonRunning()) {
+          success("Daemon restarted");
+          const status = await client.send("status", {});
+          info(`Peer ID: ${status.peerId}`);
+          info(`DID: ${status.did}`);
+          return;
+        }
+      }
+      error("Failed to restart daemon (timeout)");
+      process.exit(1);
+    } catch (err2) {
+      error(`Failed to restart daemon: ${err2.message}`);
+      process.exit(1);
+    }
+  });
+}
+
 // src/index.ts
 if (!Promise.withResolvers) {
   Promise.withResolvers = function() {
-    let resolve;
+    let resolve2;
     let reject;
     const promise = new Promise((res, rej) => {
-      resolve = res;
+      resolve2 = res;
       reject = rej;
     });
-    return { promise, resolve, reject };
+    return { promise, resolve: resolve2, reject };
   };
 }
 var require2 = createRequire(import.meta.url);
@@ -119129,6 +119708,7 @@ registerSendCommand(program);
 registerStatusCommand(program);
 registerIdentityCommand(program);
 registerCardCommand(program);
+registerDaemonCommand(program);
 program.addCommand(createTrustCommand());
 program.parse();
 /*! Bundled license information: