@adhdev/daemon-core 0.9.67 → 0.9.68

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.67",
+  "version": "0.9.68",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.67",
+  "version": "0.9.68",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -920,6 +920,162 @@ export class DaemonCommandRouter {
                 return { success: true };
             }
 
+            // ─── Mesh CRUD (local meshes.json) ───
+            case 'list_meshes': {
+                try {
+                    const { listMeshes } = await import('../config/mesh-config.js');
+                    return { success: true, meshes: listMeshes() };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'get_mesh': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                try {
+                    const { getMesh } = await import('../config/mesh-config.js');
+                    const mesh = getMesh(meshId);
+                    if (!mesh) return { success: false, error: 'Mesh not found' };
+                    return { success: true, mesh };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'create_mesh': {
+                const name = typeof args?.name === 'string' ? args.name.trim() : '';
+                const repoIdentity = typeof args?.repoIdentity === 'string' ? args.repoIdentity.trim() : '';
+                const repoRemoteUrl = typeof args?.repoRemoteUrl === 'string' ? args.repoRemoteUrl.trim() : undefined;
+                const defaultBranch = typeof args?.defaultBranch === 'string' ? args.defaultBranch.trim() : undefined;
+                if (!name) return { success: false, error: 'name required' };
+                try {
+                    const { createMesh } = await import('../config/mesh-config.js');
+                    const mesh = createMesh({ name, repoIdentity, repoRemoteUrl, defaultBranch });
+                    return { success: true, mesh };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'delete_mesh': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                try {
+                    const { deleteMesh } = await import('../config/mesh-config.js');
+                    const deleted = deleteMesh(meshId);
+                    return { success: true, deleted };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'add_mesh_node': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                if (!workspace) return { success: false, error: 'workspace required' };
+                try {
+                    const { addNode } = await import('../config/mesh-config.js');
+                    const node = addNode(meshId, { workspace });
+                    if (!node) return { success: false, error: 'Mesh not found' };
+                    return { success: true, node };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'remove_mesh_node': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const nodeId = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
+                if (!meshId || !nodeId) return { success: false, error: 'meshId and nodeId required' };
+                try {
+                    const { removeNode } = await import('../config/mesh-config.js');
+                    const removed = removeNode(meshId, nodeId);
+                    return { success: true, removed };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            // ─── Mesh Coordinator Launch ───
+            case 'launch_mesh_coordinator': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const cliType = typeof args?.cliType === 'string' ? args.cliType.trim() : 'claude-cli';
+                if (!meshId) return { success: false, error: 'meshId required' };
+
+                try {
+                    const { getMesh } = await import('../config/mesh-config.js');
+                    const { buildCoordinatorSystemPrompt } = await import('../mesh/coordinator-prompt.js');
+                    const mesh = getMesh(meshId);
+                    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;
+
+                    // 1. Write .mcp.json to workspace so Claude CLI auto-discovers mesh tools
+                    const { existsSync, readFileSync, writeFileSync, copyFileSync } = await import('fs');
+                    const { join } = await import('path');
+                    const mcpConfigPath = join(workspace, '.mcp.json');
+
+                    // Backup existing .mcp.json if present
+                    const hadExistingMcpConfig = existsSync(mcpConfigPath);
+                    let existingMcpConfig: any = {};
+                    if (hadExistingMcpConfig) {
+                        try {
+                            existingMcpConfig = JSON.parse(readFileSync(mcpConfigPath, 'utf-8'));
+                            copyFileSync(mcpConfigPath, mcpConfigPath + '.backup');
+                        } catch { /* empty */ }
+                    }
+
+                    // Merge adhdev-mesh server into existing config
+                    const mcpConfig = {
+                        ...existingMcpConfig,
+                        mcpServers: {
+                            ...(existingMcpConfig.mcpServers || {}),
+                            'adhdev-mesh': {
+                                command: 'adhdev-mcp',
+                                args: ['--repo-mesh', meshId],
+                            },
+                        },
+                    };
+                    writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
+                    LOG.info('MeshCoordinator', `Wrote .mcp.json to ${workspace} with adhdev-mesh server`);
+
+                    // 2. Build coordinator system prompt
+                    let systemPrompt = '';
+                    try {
+                        systemPrompt = buildCoordinatorSystemPrompt({ mesh });
+                    } catch {
+                        systemPrompt = `You are a Repo Mesh Coordinator for "${mesh.name}". Use the adhdev-mesh MCP tools (mesh_status, mesh_list_nodes, mesh_send_task, mesh_read_chat, mesh_launch_session, etc.) to orchestrate work across ${mesh.nodes.length} node(s).`;
+                    }
+
+                    // 3. Launch CLI session via existing cliManager
+                    const launchResult: any = await this.deps.cliManager.handleCliCommand('launch_cli', {
+                        cliType,
+                        dir: workspace,
+                        initialPrompt: systemPrompt,
+                    });
+
+                    if (!launchResult?.success) {
+                        return { success: false, error: launchResult?.error || 'Failed to launch CLI session' };
+                    }
+
+                    LOG.info('MeshCoordinator', `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
+                    return {
+                        success: true,
+                        meshId,
+                        cliType,
+                        workspace,
+                        sessionId: launchResult.sessionId || launchResult.id,
+                        mcpConfigWritten: true,
+                    };
+                } catch (e: any) {
+                    LOG.error('MeshCoordinator', `Failed: ${e.message}`);
+                    return { success: false, error: e.message };
+                }
+            }
+
             default:
                 break;
         }