@adhdev/daemon-standalone 0.9.68 → 0.9.69

package/dist/index.js

@@ -45254,6 +45254,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       "type",
       "name",
       "category",
+      "transcriptAuthority",
+      "transcriptContext",
       "aliases",
       "cdpPorts",
       "targetFilter",
@@ -45298,6 +45300,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       "staticConfigOptions",
       "spawnArgBuilder",
       "auth",
+      "meshCoordinator",
       "contractVersion",
       "capabilities",
       "providerVersion",
@@ -45355,6 +45358,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       validateCapabilities(provider, controls, errors);
       validateCanonicalHistory(provider.canonicalHistory, errors);
+      validateMeshCoordinator(provider.meshCoordinator, errors);
       for (const control of controls) {
         validateControl(control, errors);
       }
@@ -45445,6 +45449,60 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
       }
     }
+    function validateMeshCoordinator(raw, errors) {
+      if (raw === void 0) return;
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        errors.push("meshCoordinator must be an object");
+        return;
+      }
+      const meshCoordinator = raw;
+      if (typeof meshCoordinator.supported !== "boolean") {
+        errors.push("meshCoordinator.supported must be boolean");
+      }
+      if (meshCoordinator.reason !== void 0 && (typeof meshCoordinator.reason !== "string" || !meshCoordinator.reason.trim())) {
+        errors.push("meshCoordinator.reason must be a non-empty string when provided");
+      }
+      const mcpConfig = meshCoordinator.mcpConfig;
+      if (mcpConfig === void 0) return;
+      if (!mcpConfig || typeof mcpConfig !== "object" || Array.isArray(mcpConfig)) {
+        errors.push("meshCoordinator.mcpConfig must be an object");
+        return;
+      }
+      const config2 = mcpConfig;
+      const mode = config2.mode;
+      if (!["auto_import", "manual", "none"].includes(String(mode))) {
+        errors.push("meshCoordinator.mcpConfig.mode must be one of: auto_import, manual, none");
+      }
+      const format = config2.format;
+      if (format !== void 0 && !["claude_mcp_json", "hermes_config_yaml"].includes(String(format))) {
+        errors.push("meshCoordinator.mcpConfig.format must be one of: claude_mcp_json, hermes_config_yaml");
+      }
+      for (const key of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
+        const value = config2[key];
+        if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
+          errors.push(`meshCoordinator.mcpConfig.${key} must be a non-empty string when provided`);
+        }
+      }
+      if (config2.requiresRestart !== void 0 && typeof config2.requiresRestart !== "boolean") {
+        errors.push("meshCoordinator.mcpConfig.requiresRestart must be boolean when provided");
+      }
+      if (mode === "auto_import") {
+        if (format === void 0) {
+          errors.push("meshCoordinator.mcpConfig.format is required for auto_import MCP setup");
+        }
+        if (typeof config2.path !== "string" || !config2.path.trim()) {
+          errors.push("meshCoordinator.mcpConfig.path is required for auto_import MCP setup");
+        }
+      }
+      if (mode === "manual") {
+        if (typeof config2.instructions !== "string" || !config2.instructions.trim()) {
+          errors.push("meshCoordinator.mcpConfig.instructions is required for manual MCP setup");
+        }
+        if (typeof config2.template !== "string" || !config2.template.trim()) {
+          errors.push("meshCoordinator.mcpConfig.template is required for manual MCP setup");
+        }
+      }
+    }
     function validateControl(control, errors) {
       if (!control || typeof control !== "object") {
         errors.push("controls: each control must be an object");
@@ -47587,6 +47645,67 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     cleanOldFiles();
     init_logger();
+    var import_path4 = require("path");
+    var DEFAULT_SERVER_NAME = "adhdev-mesh";
+    var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
+    function resolveMeshCoordinatorSetup(options) {
+      const { provider, meshId, workspace } = options;
+      const config2 = provider?.meshCoordinator;
+      if (!config2?.supported) {
+        return {
+          kind: "unsupported",
+          reason: config2?.reason || "Provider does not declare Repo Mesh coordinator support"
+        };
+      }
+      const mcpConfig = config2.mcpConfig;
+      if (!mcpConfig || mcpConfig.mode === "none") {
+        return {
+          kind: "unsupported",
+          reason: config2.reason || "Provider does not declare a usable Repo Mesh MCP configuration mode"
+        };
+      }
+      const serverName = mcpConfig.serverName?.trim() || DEFAULT_SERVER_NAME;
+      if (mcpConfig.mode === "auto_import") {
+        const path26 = mcpConfig.path?.trim();
+        if (!path26) {
+          return { kind: "unsupported", reason: "Provider auto-import MCP config is missing a config path" };
+        }
+        return {
+          kind: "auto_import",
+          serverName,
+          configPath: (0, import_path4.join)(workspace, path26),
+          configFormat: mcpConfig.format
+        };
+      }
+      if (mcpConfig.mode === "manual") {
+        const instructions = mcpConfig.instructions?.trim();
+        const template = mcpConfig.template;
+        if (!instructions || !template?.trim()) {
+          return { kind: "unsupported", reason: "Provider manual MCP setup is missing instructions or template" };
+        }
+        return {
+          kind: "manual",
+          serverName,
+          configFormat: mcpConfig.format,
+          configPathCommand: mcpConfig.configPathCommand,
+          requiresRestart: mcpConfig.requiresRestart === true,
+          instructions,
+          template: renderMeshCoordinatorTemplate(template, {
+            meshId,
+            workspace,
+            serverName,
+            adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
+          })
+        };
+      }
+      return {
+        kind: "unsupported",
+        reason: `Unsupported Repo Mesh MCP configuration mode: ${String(mcpConfig.mode)}`
+      };
+    }
+    function renderMeshCoordinatorTemplate(template, values) {
+      return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand)\s*\}\}/g, (_, key) => values[key] || "");
+    }
     var os17 = __toESM2(require("os"));
     init_config();
     init_terminal_screen();
@@ -47637,7 +47756,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         ...provider.enabled !== void 0 ? { enabled: provider.enabled } : {},
         ...provider.machineStatus !== void 0 ? { machineStatus: provider.machineStatus } : {},
         ...provider.lastDetection !== void 0 ? { lastDetection: provider.lastDetection } : {},
-        ...provider.lastVerification !== void 0 ? { lastVerification: provider.lastVerification } : {}
+        ...provider.lastVerification !== void 0 ? { lastVerification: provider.lastVerification } : {},
+        ...provider.meshCoordinator !== void 0 ? { meshCoordinator: provider.meshCoordinator } : {}
       }));
     }
     function buildMachineInfo2(profile = "full") {
@@ -49042,9 +49162,45 @@ Run 'adhdev doctor' for detailed diagnostics.`
               if (!mesh) return { success: false, error: "Mesh not found" };
               if (mesh.nodes.length === 0) return { success: false, error: "No nodes in mesh" };
               const workspace = mesh.nodes[0].workspace;
+              const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
+              const coordinatorSetup = resolveMeshCoordinatorSetup({
+                provider: providerMeta,
+                meshId,
+                workspace
+              });
+              if (coordinatorSetup.kind === "unsupported") {
+                return {
+                  success: false,
+                  code: "mesh_coordinator_unsupported",
+                  error: coordinatorSetup.reason,
+                  meshId,
+                  cliType,
+                  workspace
+                };
+              }
+              if (coordinatorSetup.kind === "manual") {
+                return {
+                  success: false,
+                  code: "mesh_coordinator_manual_mcp_setup_required",
+                  error: coordinatorSetup.instructions,
+                  meshId,
+                  cliType,
+                  workspace,
+                  meshCoordinatorSetup: coordinatorSetup
+                };
+              }
+              if (coordinatorSetup.configFormat !== "claude_mcp_json") {
+                return {
+                  success: false,
+                  code: "mesh_coordinator_unsupported",
+                  error: `Unsupported auto-import MCP config format: ${String(coordinatorSetup.configFormat)}`,
+                  meshId,
+                  cliType,
+                  workspace
+                };
+              }
               const { existsSync: existsSync21, readFileSync: readFileSync15, writeFileSync: writeFileSync12, copyFileSync: copyFileSync3 } = await import("fs");
-              const { join: join23 } = await import("path");
-              const mcpConfigPath = join23(workspace, ".mcp.json");
+              const mcpConfigPath = coordinatorSetup.configPath;
               const hadExistingMcpConfig = existsSync21(mcpConfigPath);
               let existingMcpConfig = {};
               if (hadExistingMcpConfig) {
@@ -49058,14 +49214,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 ...existingMcpConfig,
                 mcpServers: {
                   ...existingMcpConfig.mcpServers || {},
-                  "adhdev-mesh": {
+                  [coordinatorSetup.serverName]: {
                     command: "adhdev-mcp",
                     args: ["--repo-mesh", meshId]
                   }
                 }
               };
               writeFileSync12(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-              LOG2.info("MeshCoordinator", `Wrote .mcp.json to ${workspace} with adhdev-mesh server`);
+              LOG2.info("MeshCoordinator", `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
               let systemPrompt = "";
               try {
                 systemPrompt = buildCoordinatorSystemPrompt2({ mesh });