@adhdev/daemon-standalone 0.9.77-rc.10 → 0.9.77-rc.11

package/dist/index.js

@@ -32538,7 +32538,7 @@ Follow these recovery rules:
         targetSessionId: sessionId,
         cliType: providerType,
         action: "send_chat",
-        input: task.message
+        message: task.message
       }).catch((e) => {
         LOG2.error("MeshQueue", `Failed to dispatch task to node ${nodeId}: ${e?.message}`);
       });
@@ -46300,11 +46300,13 @@ ${effect.notification.body || ""}`.trim();
     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) {
@@ -52974,6 +52976,22 @@ Run 'adhdev doctor' for detailed diagnostics.`
         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,
@@ -52981,12 +52999,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           configPathCommand: mcpConfig.configPathCommand,
           requiresRestart: mcpConfig.requiresRestart === true,
           instructions,
-          template: renderMeshCoordinatorTemplate(template, {
-            meshId,
-            workspace,
-            serverName,
-            adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
-          })
+          template: renderedTemplate
         };
       }
       return {
@@ -55160,6 +55173,93 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   meshCoordinatorSetup: coordinatorSetup
                 };
               }
+              if (coordinatorSetup.kind === "cli_command") {
+                let cliCmdSystemPrompt = "";
+                try {
+                  cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType });
+                } catch (error48) {
+                  const message = error48?.message || String(error48);
+                  LOG2.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;
+                  LOG2.info("MeshCoordinator", `Running MCP registration: ${coordinatorSetup.command}`);
+                  execCmdSync(regCmd, regArgs, { stdio: "pipe", timeout: 15e3 });
+                } catch (error48) {
+                  LOG2.warn("MeshCoordinator", `MCP registration command failed (may be pre-registered): ${error48?.message || error48}`);
+                }
+                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);
+                      }
+                      LOG2.info("MeshCoordinator", `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
+                    } catch (e) {
+                      LOG2.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" };
+                }
+                LOG2.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 {