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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-standalone",
-  "version": "0.9.77-rc.10",
+  "version": "0.9.77-rc.11",
   "description": "ADHDev standalone daemon — embedded HTTP/WS server for local dashboard",
   "main": "dist/index.js",
   "bin": {

package/vendor/mcp-server/index.js

@@ -26264,7 +26264,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}`);
   });
@@ -33701,11 +33701,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) {
@@ -35567,6 +35569,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,
@@ -35574,12 +35592,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 {
@@ -53346,6 +53359,93 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   meshCoordinatorSetup: coordinatorSetup
                 };
               }
+              if (coordinatorSetup.kind === "cli_command") {
+                let cliCmdSystemPrompt = "";
+                try {
+                  cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType });
+                } catch (error48) {
+                  const message = error48?.message || String(error48);
+                  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 (error48) {
+                  LOG.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);
+                      }
+                      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 {