@adhdev/daemon-core 0.9.77-rc.10 → 0.9.77-rc.12

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

@@ -17,6 +17,14 @@ export type MeshCoordinatorSetup = {
     requiresRestart: boolean;
     instructions: string;
     template: string;
+} | {
+    /** Provider registers MCP via its own CLI command (e.g. `codex mcp add` / `gemini mcp add`). */
+    kind: 'cli_command';
+    serverName: string;
+    /** The rendered shell command to execute before launching the coordinator session. */
+    command: string;
+    requiresRestart: boolean;
+    instructions: string;
 } | {
     kind: 'unsupported';
     reason: string;

package/dist/index.js

@@ -1323,7 +1323,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     targetSessionId: sessionId,
     cliType: providerType,
     action: "send_chat",
-    input: task.message
+    message: task.message
   }).catch((e) => {
     LOG.error("MeshQueue", `Failed to dispatch task to node ${nodeId}: ${e?.message}`);
   });
@@ -15209,11 +15209,13 @@ async function handleOpenPanel(h, args) {
 async function handlePtyInput(h, args) {
   const { cliType, data, targetSessionId } = args || {};
   if (!data) return { success: false, error: "data required" };
+  const cleanData = typeof data === "string" ? data.replace(/\x1b\[\?[0-9;]*c/g, "") : data;
+  if (!cleanData) return { success: true };
   const adapter = h.getCliAdapter(targetSessionId || cliType);
   if (!adapter || typeof adapter.writeRaw !== "function") {
     return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || "unknown"}` };
   }
-  await adapter.writeRaw(data);
+  await adapter.writeRaw(cleanData);
   return { success: true };
 }
 function handlePtyResize(_h, args) {
@@ -21923,6 +21925,22 @@ function resolveMeshCoordinatorSetup(options) {
     if (!instructions || !template?.trim()) {
       return { kind: "unsupported", reason: "Provider manual MCP setup is missing instructions or template" };
     }
+    const renderedTemplate = renderMeshCoordinatorTemplate(template, {
+      meshId,
+      workspace,
+      serverName,
+      adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
+    });
+    const isCliCommand = !renderedTemplate.trim().includes("\n") && !renderedTemplate.trim().startsWith("{");
+    if (isCliCommand) {
+      return {
+        kind: "cli_command",
+        serverName,
+        command: renderedTemplate.trim(),
+        requiresRestart: mcpConfig.requiresRestart === true,
+        instructions
+      };
+    }
     return {
       kind: "manual",
       serverName,
@@ -21930,12 +21948,7 @@ function resolveMeshCoordinatorSetup(options) {
       configPathCommand: mcpConfig.configPathCommand,
       requiresRestart: mcpConfig.requiresRestart === true,
       instructions,
-      template: renderMeshCoordinatorTemplate(template, {
-        meshId,
-        workspace,
-        serverName,
-        adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
-      })
+      template: renderedTemplate
     };
   }
   return {
@@ -24117,6 +24130,93 @@ var DaemonCommandRouter = class {
               meshCoordinatorSetup: coordinatorSetup
             };
           }
+          if (coordinatorSetup.kind === "cli_command") {
+            let cliCmdSystemPrompt = "";
+            try {
+              cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType });
+            } catch (error) {
+              const message = error?.message || String(error);
+              LOG.error("MeshCoordinator", `Failed to build coordinator prompt: ${message}`);
+              return {
+                success: false,
+                code: "mesh_coordinator_prompt_failed",
+                error: `Failed to build Repo Mesh coordinator prompt: ${message}`,
+                meshId,
+                cliType,
+                workspace
+              };
+            }
+            try {
+              const { execFileSync: execCmdSync } = await import("child_process");
+              const cmdParts = coordinatorSetup.command.trim().split(/\s+/);
+              const [regCmd, ...regArgs] = cmdParts;
+              LOG.info("MeshCoordinator", `Running MCP registration: ${coordinatorSetup.command}`);
+              execCmdSync(regCmd, regArgs, { stdio: "pipe", timeout: 15e3 });
+            } catch (error) {
+              LOG.warn("MeshCoordinator", `MCP registration command failed (may be pre-registered): ${error?.message || error}`);
+            }
+            const cliCmdArgs = [];
+            const cliCmdEnv = {};
+            if (cliCmdSystemPrompt) {
+              if (cliType === "codex-cli") {
+                cliCmdArgs.push("-c", `developer_instructions=${JSON.stringify(cliCmdSystemPrompt)}`);
+              } else if (cliType === "gemini-cli") {
+                try {
+                  const { writeFileSync: wfs, existsSync: efs, readFileSync: rfs } = await import("fs");
+                  const geminiMdPath = `${workspace}/GEMINI.md`;
+                  const marker = "<!-- adhdev-mesh-coordinator-prompt -->";
+                  const markerEnd = "<!-- /adhdev-mesh-coordinator-prompt -->";
+                  const block = `${marker}
+${cliCmdSystemPrompt}
+${markerEnd}`;
+                  if (efs(geminiMdPath)) {
+                    const existing = rfs(geminiMdPath, "utf-8");
+                    const replaced = existing.replace(
+                      new RegExp(`${marker}[\\s\\S]*?${markerEnd}`, "g"),
+                      block
+                    );
+                    wfs(geminiMdPath, replaced.includes(marker) ? replaced : `${existing}
+
+${block}`);
+                  } else {
+                    wfs(geminiMdPath, block);
+                  }
+                  LOG.info("MeshCoordinator", `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
+                } catch (e) {
+                  LOG.warn("MeshCoordinator", `Could not write GEMINI.md: ${e?.message || e}`);
+                }
+              }
+            }
+            const cliCmdLaunch = await this.deps.cliManager.handleCliCommand("launch_cli", {
+              cliType,
+              dir: workspace,
+              cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : void 0,
+              env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : void 0,
+              settings: { meshCoordinatorFor: meshId }
+            });
+            if (!cliCmdLaunch?.success) {
+              return { success: false, error: cliCmdLaunch?.error || "Failed to launch CLI session" };
+            }
+            LOG.info("MeshCoordinator", `Launched ${cliType} coordinator (cli_command) for mesh ${meshId}`);
+            try {
+              const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              appendLedgerEntry2(meshId, {
+                kind: "coordinator_started",
+                sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                providerType: cliType,
+                payload: { workspace }
+              });
+            } catch {
+            }
+            return {
+              success: true,
+              meshId,
+              cliType,
+              workspace,
+              sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+              mcpRegistered: true
+            };
+          }
           const configFormat = coordinatorSetup.configFormat;
           if (configFormat !== "claude_mcp_json" && configFormat !== "hermes_config_yaml") {
             return {