adhdev 0.9.68 → 0.9.70

package/dist/index.js

@@ -36547,6 +36547,7 @@ function validateProviderDefinition(raw) {
   }
   validateCapabilities(provider, controls, errors);
   validateCanonicalHistory(provider.canonicalHistory, errors);
+  validateMeshCoordinator(provider.meshCoordinator, errors);
   for (const control of controls) {
     validateControl(control, errors);
   }
@@ -36637,6 +36638,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 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");
@@ -36678,6 +36733,8 @@ var init_provider_schema = __esm({
       "type",
       "name",
       "category",
+      "transcriptAuthority",
+      "transcriptContext",
       "aliases",
       "cdpPorts",
       "targetFilter",
@@ -36722,6 +36779,7 @@ var init_provider_schema = __esm({
       "staticConfigOptions",
       "spawnArgBuilder",
       "auth",
+      "meshCoordinator",
       "contractVersion",
       "capabilities",
       "providerVersion",
@@ -38891,6 +38949,75 @@ var init_command_log = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/commands/mesh-coordinator.ts
+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 path33 = mcpConfig.path?.trim();
+    if (!path33) {
+      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, path33),
+      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, (_2, key) => values[key] || "");
+}
+var import_path4, DEFAULT_SERVER_NAME, DEFAULT_ADHDEV_MCP_COMMAND;
+var init_mesh_coordinator = __esm({
+  "../../oss/packages/daemon-core/src/commands/mesh-coordinator.ts"() {
+    "use strict";
+    import_path4 = require("path");
+    DEFAULT_SERVER_NAME = "adhdev-mesh";
+    DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
+  }
+});
+
 // ../../oss/packages/daemon-core/src/status/snapshot.ts
 function buildRecentReadDebugSignature(snapshot) {
   return [
@@ -38936,7 +39063,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") {
@@ -39663,6 +39791,7 @@ var init_router = __esm({
     init_logger();
     init_debug_trace();
     init_runtime_surface();
+    init_mesh_coordinator();
     init_builders();
     init_snapshot();
     init_snapshot();
@@ -40395,9 +40524,45 @@ var init_router = __esm({
               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: existsSync25, readFileSync: readFileSync20, writeFileSync: writeFileSync14, copyFileSync: copyFileSync4 } = await import("fs");
-              const { join: join32 } = await import("path");
-              const mcpConfigPath = join32(workspace, ".mcp.json");
+              const mcpConfigPath = coordinatorSetup.configPath;
               const hadExistingMcpConfig = existsSync25(mcpConfigPath);
               let existingMcpConfig = {};
               if (hadExistingMcpConfig) {
@@ -40411,14 +40576,14 @@ var init_router = __esm({
                 ...existingMcpConfig,
                 mcpServers: {
                   ...existingMcpConfig.mcpServers || {},
-                  "adhdev-mesh": {
+                  [coordinatorSetup.serverName]: {
                     command: "adhdev-mcp",
                     args: ["--repo-mesh", meshId]
                   }
                 }
               };
               writeFileSync14(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 });
@@ -58403,9 +58568,9 @@ function resolvePackageVersion(options) {
   const injectedVersion = options?.injectedVersion || "unknown";
   const dir = options?.dirname || __dirname;
   const possiblePaths = [
-    (0, import_path4.join)(dir, "..", "..", "package.json"),
-    (0, import_path4.join)(dir, "..", "package.json"),
-    (0, import_path4.join)(dir, "package.json")
+    (0, import_path5.join)(dir, "..", "..", "package.json"),
+    (0, import_path5.join)(dir, "..", "package.json"),
+    (0, import_path5.join)(dir, "package.json")
   ];
   for (const p of possiblePaths) {
     try {
@@ -58416,12 +58581,12 @@ function resolvePackageVersion(options) {
   }
   return injectedVersion;
 }
-var import_fs7, import_path4;
+var import_fs7, import_path5;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     import_fs7 = require("fs");
-    import_path4 = require("path");
+    import_path5 = require("path");
   }
 });
 
@@ -58750,7 +58915,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.68" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.70" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -74618,7 +74783,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join32(s) {
+        value: function join33(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;