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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.77-rc.10",
+  "version": "0.9.77-rc.12",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/mesh-coordinator.ts

@@ -28,6 +28,15 @@ export type MeshCoordinatorSetup =
       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
@@ -152,6 +161,24 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
     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,
+    })
+    // Detect if the template is a runnable CLI command (single line, no YAML/JSON structure).
+    // If so, use cli_command kind so the daemon can execute it automatically.
+    const isCliCommand = !renderedTemplate.trim().includes('\n') && !renderedTemplate.trim().startsWith('{')
+    if (isCliCommand) {
+      return {
+        kind: 'cli_command',
+        serverName,
+        command: renderedTemplate.trim(),
+        requiresRestart: mcpConfig.requiresRestart === true,
+        instructions: instructions,
+      }
+    }
     return {
       kind: 'manual',
       serverName,
@@ -159,12 +186,7 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
       configPathCommand: mcpConfig.configPathCommand,
       requiresRestart: mcpConfig.requiresRestart === true,
       instructions,
-      template: renderMeshCoordinatorTemplate(template, {
-        meshId,
-        workspace,
-        serverName,
-        adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND,
-      }),
+      template: renderedTemplate,
     }
   }
 

package/src/commands/router.ts

@@ -1711,6 +1711,105 @@ export class DaemonCommandRouter {
                         };
                     }
 
+                    // ─── CLI-command MCP registration (Codex, Gemini CLI) ───────────
+                    if (coordinatorSetup.kind === 'cli_command') {
+                        // Build coordinator prompt first — fail closed on errors.
+                        let cliCmdSystemPrompt = '';
+                        try {
+                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType });
+                        } catch (error: any) {
+                            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,
+                            };
+                        }
+
+                        // Run the provider's MCP registration command.
+                        try {
+                            const { execFileSync: execCmdSync } = await import('node: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: 15_000 });
+                        } catch (error: any) {
+                            // Non-fatal — server may already be registered (providers return exit 1 on duplicate).
+                            LOG.warn('MeshCoordinator', `MCP registration command failed (may be pre-registered): ${error?.message || error}`);
+                        }
+
+                        // Inject system prompt using provider-native methods.
+                        // Codex: -c 'instructions="..."' CLI config override
+                        // Gemini: write GEMINI.md to workspace (auto-loaded as context)
+                        const cliCmdArgs: string[] = [];
+                        const cliCmdEnv: Record<string, string> = {};
+                        if (cliCmdSystemPrompt) {
+                            if (cliType === 'codex-cli') {
+                                // Codex reads `developer_instructions` from config.toml as system instructions.
+                                // The -c flag overrides a config key for this session only.
+                                cliCmdArgs.push('-c', `developer_instructions=${JSON.stringify(cliCmdSystemPrompt)}`);
+                            } else if (cliType === 'gemini-cli') {
+                                // Gemini CLI auto-loads GEMINI.md from CWD as project context.
+                                // Write a temporary GEMINI.md to the workspace before launch.
+                                try {
+                                    const { writeFileSync: wfs, existsSync: efs, readFileSync: rfs } = await import('node:fs');
+                                    const geminiMdPath = `${workspace}/GEMINI.md`;
+                                    const marker = '<!-- adhdev-mesh-coordinator-prompt -->';
+                                    const markerEnd = '<!-- /adhdev-mesh-coordinator-prompt -->';
+                                    const block = `${marker}\n${cliCmdSystemPrompt}\n${markerEnd}`;
+                                    if (efs(geminiMdPath)) {
+                                        const existing = rfs(geminiMdPath, 'utf-8');
+                                        // Replace existing block or append
+                                        const replaced = existing.replace(
+                                            new RegExp(`${marker}[\\s\\S]*?${markerEnd}`, 'g'),
+                                            block,
+                                        );
+                                        wfs(geminiMdPath, replaced.includes(marker) ? replaced : `${existing}\n\n${block}`);
+                                    } else {
+                                        wfs(geminiMdPath, block);
+                                    }
+                                    LOG.info('MeshCoordinator', `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
+                                } catch (e: any) {
+                                    LOG.warn('MeshCoordinator', `Could not write GEMINI.md: ${e?.message || e}`);
+                                }
+                            }
+                        }
+
+                        const cliCmdLaunch: any = await this.deps.cliManager.handleCliCommand('launch_cli', {
+                            cliType,
+                            dir: workspace,
+                            cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : undefined,
+                            env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : undefined,
+                            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 } = await import('../mesh/mesh-ledger.js');
+                            appendLedgerEntry(meshId, {
+                                kind: 'coordinator_started',
+                                sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                                providerType: cliType,
+                                payload: { workspace },
+                            });
+                        } catch { /* best-effort */ }
+
+                        return {
+                            success: true,
+                            meshId,
+                            cliType,
+                            workspace,
+                            sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                            mcpRegistered: true,
+                        };
+                    }
+
                     const configFormat = coordinatorSetup.configFormat as MeshCoordinatorConfigFormat;
                     if (configFormat !== 'claude_mcp_json' && configFormat !== 'hermes_config_yaml') {
                         return {

package/src/commands/stream-commands.ts

@@ -113,11 +113,18 @@ export async function handleOpenPanel(h: CommandHelpers, args: any): Promise<Com
 export async function handlePtyInput(h: CommandHelpers, args: any): Promise<CommandResult> {
     const { cliType, data, targetSessionId } = args || {};
     if (!data) return { success: false, error: 'data required' };
+
+    // Filter out VT100/VT420 Device Attributes responses (e.g. \x1b[?1;2c)
+    // These are echoed by xterm.js in the dashboard in response to \x1b[c queries
+    // and pollute the CLI input buffer.
+    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 };
 }
 

package/src/mesh/mesh-events.ts

@@ -76,7 +76,7 @@ export function tryAssignQueueTask(
         targetSessionId: sessionId,
         cliType: providerType,
         action: 'send_chat',
-        input: task.message,
+        message: task.message,
     }).catch((e: any) => {
         LOG.error('MeshQueue', `Failed to dispatch task to node ${nodeId}: ${e?.message}`);
     });