@adhdev/daemon-core 0.9.68 → 0.9.70

package/dist/commands/mesh-coordinator.d.ts

@@ -0,0 +1,25 @@
+import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js';
+export type MeshCoordinatorSetup = {
+    kind: 'auto_import';
+    serverName: string;
+    configPath: string;
+    configFormat?: MeshCoordinatorMcpConfigFormat;
+} | {
+    kind: 'manual';
+    serverName: string;
+    configFormat?: MeshCoordinatorMcpConfigFormat;
+    configPathCommand?: string;
+    requiresRestart: boolean;
+    instructions: string;
+    template: string;
+} | {
+    kind: 'unsupported';
+    reason: string;
+};
+export interface ResolveMeshCoordinatorSetupOptions {
+    provider?: ProviderModule | null;
+    meshId: string;
+    workspace: string;
+    adhdevMcpCommand?: string;
+}
+export declare function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupOptions): MeshCoordinatorSetup;

package/dist/index.js

@@ -17531,6 +17531,8 @@ var KNOWN_PROVIDER_FIELDS = /* @__PURE__ */ new Set([
   "type",
   "name",
   "category",
+  "transcriptAuthority",
+  "transcriptContext",
   "aliases",
   "cdpPorts",
   "targetFilter",
@@ -17575,6 +17577,7 @@ var KNOWN_PROVIDER_FIELDS = /* @__PURE__ */ new Set([
   "staticConfigOptions",
   "spawnArgBuilder",
   "auth",
+  "meshCoordinator",
   "contractVersion",
   "capabilities",
   "providerVersion",
@@ -17632,6 +17635,7 @@ function validateProviderDefinition(raw) {
   }
   validateCapabilities(provider, controls, errors);
   validateCanonicalHistory(provider.canonicalHistory, errors);
+  validateMeshCoordinator(provider.meshCoordinator, errors);
   for (const control of controls) {
     validateControl(control, errors);
   }
@@ -17722,6 +17726,60 @@ function validateCanonicalHistory(raw, errors) {
     }
   }
 }
+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 config = mcpConfig;
+  const mode = config.mode;
+  if (!["auto_import", "manual", "none"].includes(String(mode))) {
+    errors.push("meshCoordinator.mcpConfig.mode must be one of: auto_import, manual, none");
+  }
+  const format = config.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 = config[key];
+    if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
+      errors.push(`meshCoordinator.mcpConfig.${key} must be a non-empty string when provided`);
+    }
+  }
+  if (config.requiresRestart !== void 0 && typeof config.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 config.path !== "string" || !config.path.trim()) {
+      errors.push("meshCoordinator.mcpConfig.path is required for auto_import MCP setup");
+    }
+  }
+  if (mode === "manual") {
+    if (typeof config.instructions !== "string" || !config.instructions.trim()) {
+      errors.push("meshCoordinator.mcpConfig.instructions is required for manual MCP setup");
+    }
+    if (typeof config.template !== "string" || !config.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");
@@ -19877,6 +19935,69 @@ cleanOldFiles();
 // src/commands/router.ts
 init_logger();
 
+// src/commands/mesh-coordinator.ts
+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 config = provider?.meshCoordinator;
+  if (!config?.supported) {
+    return {
+      kind: "unsupported",
+      reason: config?.reason || "Provider does not declare Repo Mesh coordinator support"
+    };
+  }
+  const mcpConfig = config.mcpConfig;
+  if (!mcpConfig || mcpConfig.mode === "none") {
+    return {
+      kind: "unsupported",
+      reason: config.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] || "");
+}
+
 // src/status/snapshot.ts
 var os17 = __toESM(require("os"));
 init_config();
@@ -19928,7 +20049,8 @@ function buildAvailableProviders(providerLoader) {
     ...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 buildMachineInfo(profile = "full") {
@@ -21337,9 +21459,45 @@ var DaemonCommandRouter = class {
           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) {
@@ -21353,14 +21511,14 @@ var DaemonCommandRouter = class {
             ...existingMcpConfig,
             mcpServers: {
               ...existingMcpConfig.mcpServers || {},
-              "adhdev-mesh": {
+              [coordinatorSetup.serverName]: {
                 command: "adhdev-mcp",
                 args: ["--repo-mesh", meshId]
               }
             }
           };
           writeFileSync12(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf-8");
-          LOG.info("MeshCoordinator", `Wrote .mcp.json to ${workspace} with adhdev-mesh server`);
+          LOG.info("MeshCoordinator", `Wrote ${mcpConfigPath} with ${coordinatorSetup.serverName} server`);
           let systemPrompt = "";
           try {
             systemPrompt = buildCoordinatorSystemPrompt2({ mesh });