adhdev 0.9.56 → 0.9.58

package/dist/index.js

@@ -34934,7 +34934,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             resolvedDir,
             resolvedCliArgs,
             resolvedProvider,
-            {},
+            this.providerLoader.getSettings(normalizedType),
             false,
             {
               providerSessionId: sessionBinding.providerSessionId,
@@ -49343,6 +49343,58 @@ var init_server_connection = __esm({
       onStateChange(callback) {
         this.stateChangeCallbacks.push(callback);
       }
+      /**
+       * Send a command to another daemon owned by the same user, via server relay.
+       * The server validates ownership before forwarding to the target daemon.
+       *
+       * Returns the command result or throws on timeout / auth failure.
+       */
+      sendMeshCommand(targetDaemonId, command, args = {}, timeoutMs = 3e4) {
+        return new Promise((resolve19, reject) => {
+          const requestId = `mesh_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+          const timer = setTimeout(() => {
+            this.off("daemon_mesh_result", handler);
+            reject(new Error(`Mesh command timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          const handler = (msg) => {
+            if (msg.payload?.requestId !== requestId) return;
+            this.off("daemon_mesh_result", handler);
+            clearTimeout(timer);
+            if (msg.payload?.success === false) {
+              reject(new Error(msg.payload?.error ?? "Mesh command failed"));
+            } else {
+              resolve19(msg.payload?.result);
+            }
+          };
+          this.on("daemon_mesh_result", handler);
+          const sent = this.ws?.readyState === 1 && (() => {
+            try {
+              this.ws.send(JSON.stringify({
+                type: "daemon_mesh_command",
+                requestId,
+                targetDaemonId,
+                command,
+                args,
+                timestamp: Date.now()
+              }));
+              return true;
+            } catch {
+              return false;
+            }
+          })();
+          if (!sent) {
+            clearTimeout(timer);
+            this.off("daemon_mesh_result", handler);
+            reject(new Error("Not connected to server"));
+          }
+        });
+      }
+      off(type, handler) {
+        const handlers = this.messageHandlers.get(type);
+        if (!handlers) return;
+        const idx = handlers.indexOf(handler);
+        if (idx !== -1) handlers.splice(idx, 1);
+      }
       getState() {
         return this.state;
       }
@@ -58793,6 +58845,64 @@ var init_version = __esm({
   }
 });
 
+// src/daemon-mesh-manager.ts
+var daemon_mesh_manager_exports = {};
+__export(daemon_mesh_manager_exports, {
+  DaemonMeshManager: () => DaemonMeshManager
+});
+function interpolateArgs(args, context) {
+  const result = {};
+  for (const [k, v] of Object.entries(args)) {
+    result[k] = typeof v === "string" ? interpolateString(v, context) : v;
+  }
+  return result;
+}
+function interpolateString(template, ctx) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_2, key) => {
+    const val = ctx[key];
+    return val !== void 0 ? String(val) : `{{${key}}}`;
+  });
+}
+var DaemonMeshManager;
+var init_daemon_mesh_manager = __esm({
+  "src/daemon-mesh-manager.ts"() {
+    "use strict";
+    init_src();
+    DaemonMeshManager = class {
+      rules = [];
+      serverConn;
+      constructor(serverConn) {
+        this.serverConn = serverConn;
+      }
+      setRules(rules) {
+        this.rules = rules;
+        LOG.info("Mesh", `[Mesh] ${rules.length} rule(s) loaded`);
+      }
+      async emit(event) {
+        const matching = this.rules.filter((r) => r.trigger === event.trigger);
+        if (matching.length === 0) return;
+        await Promise.allSettled(
+          matching.map((rule) => this.executeRule(rule, event.context ?? {}))
+        );
+      }
+      async executeRule(rule, context) {
+        const args = interpolateArgs(rule.args ?? {}, context);
+        try {
+          LOG.info("Mesh", `[Mesh] Relaying '${rule.command}' \u2192 ${rule.targetDaemonId.slice(0, 12)}\u2026`);
+          await this.serverConn.sendMeshCommand(rule.targetDaemonId, rule.command, args);
+          LOG.info("Mesh", `[Mesh] Relay '${rule.command}' complete`);
+        } catch (err) {
+          LOG.warn("Mesh", `[Mesh] Relay '${rule.command}' failed: ${err?.message ?? err}`);
+        }
+      }
+      /** Convenience: send a one-off mesh command without a rule. */
+      async sendCommand(targetDaemonId, command, args = {}) {
+        return this.serverConn.sendMeshCommand(targetDaemonId, command, args);
+      }
+    };
+  }
+});
+
 // src/adhdev-daemon.ts
 var adhdev_daemon_exports = {};
 __export(adhdev_daemon_exports, {
@@ -59037,13 +59147,14 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.56" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.58" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
       localClients = /* @__PURE__ */ new Set();
       serverConn = null;
       p2p = null;
+      meshManager = null;
       screenshotController = null;
       statusReporter = null;
       topicSubscriptionTimer = null;
@@ -59627,6 +59738,12 @@ ${err?.stack || ""}`);
             }
           });
           this.p2p = new DaemonP2PSender(this.serverConn);
+          const { DaemonMeshManager: DaemonMeshManager2 } = await Promise.resolve().then(() => (init_daemon_mesh_manager(), daemon_mesh_manager_exports));
+          this.meshManager = new DaemonMeshManager2(this.serverConn);
+          const meshRules = config2.meshRules;
+          if (Array.isArray(meshRules) && meshRules.length > 0) {
+            this.meshManager.setRules(meshRules);
+          }
           if (this.p2p.isAvailable) {
             console.log(source_default2.green("  \u{1F517} P2P available (node-datachannel)"));
             this.p2p.onInput(async (event) => {
@@ -59965,6 +60082,16 @@ ${err?.stack || ""}`);
           if (cmdType.startsWith("git_")) {
             void this.flushP2PWorkspaceGitSubscriptions();
           }
+          if (cmdType === "git_checkpoint" && routed.success && this.meshManager) {
+            void this.meshManager.emit({
+              trigger: "git_checkpoint_complete",
+              context: {
+                workspace: String(normalizedData.workspace ?? ""),
+                checkpoint_message: routed.checkpoint?.message ?? String(normalizedData.message ?? ""),
+                commit: routed.checkpoint?.commit ?? ""
+              }
+            });
+          }
           return { ...routed, interactionId };
         } catch (e) {
           logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd: cmdType, source: "p2p", interactionId, success: false, error: e.message, durationMs: Date.now() - cmdStart });