@adhdev/daemon-core 0.9.82-rc.49 → 0.9.82-rc.491

package/src/commands/med-family/fast-forward.ts

@@ -0,0 +1,230 @@
+/**
+ * RF-ROUTER MED family — fast-forward / refine convergence commands.
+ *
+ * mesh_init, plan_mesh_refine_node, fast_forward_mesh_node, refine_mesh_node and
+ * batch_refine_mesh_nodes. These resolve the target node, forward to the owning
+ * daemon when the node is remote, and run (or plan) the fast-forward / refine
+ * convergence. Extracted verbatim from executeDaemonCommand; the async execute
+ * paths delegate back to the router's refine-job starters via ctx.
+ */
+import { daemonIdsEquivalent, meshNodeIdMatches } from '@adhdev/mesh-shared';
+import { fastForwardMeshNode } from '../../mesh/mesh-fast-forward.js';
+import { runMeshInit } from '../../mesh/mesh-init.js';
+import { detectCLIs } from '../../detection/cli-detector.js';
+import { buildMeshRefineValidationPlan } from '../router.js';
+import type { CommandRouterResult } from '../router.js';
+import type { MedFamilyContext, MedFamilyHandler } from './types.js';
+
+export const fastForwardHandlers: Record<string, MedFamilyHandler> = {
+    mesh_init: async (ctx: MedFamilyContext, args: any) => {
+        const workspace = typeof args?.workspace === 'string' && args.workspace.trim() ? args.workspace.trim() : process.cwd();
+        const mesh = args?.inlineMesh || {};
+        try {
+            const detected = await detectCLIs(ctx.deps.providerLoader, { includeVersion: true });
+            return { ...runMeshInit(mesh, workspace, detected, {
+                write: args?.write === true,
+                overwrite: args?.overwrite === true,
+            }) };
+        } catch (e: any) {
+            return { success: false, error: e?.message || String(e) };
+        }
+    },
+
+    plan_mesh_refine_node: async (ctx: MedFamilyContext, args: any) => {
+        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' };
+        // preferInline: plan is the dry-run sibling of refine — clone nodes must resolve.
+        const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        const mesh = meshRecord?.mesh;
+        const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
+        if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
+        return {
+            success: true,
+            dryRun: true,
+            nodeId,
+            workspace: node.workspace,
+            validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
+            mergeWillRun: false,
+            cleanupWillRun: false,
+        };
+    },
+
+    fast_forward_mesh_node: async (ctx: MedFamilyContext, args: any) => {
+        // The whole handler is wrapped: the safety-gate evaluation (mesh resolution,
+        // git status/stash/submodule fan-out) can throw on some platforms — notably a
+        // win32 daemon whose git invocation parsing or slow submodule probe raises
+        // before fastForwardMeshNode's own guarded body runs. router.execute re-throws,
+        // so an escaping throw surfaces to the coordinator as an opaque
+        // "Daemon IPC command failed" instead of the structured blockingReasons result
+        // a mac node returns cleanly. Catch it and return the same blocked shape so the
+        // coordinator can read the reason and route, never an IPC crash. Mirrors the
+        // mesh_init handler's try-catch contract.
+        const workspaceForError = typeof args?.workspace === 'string' ? args.workspace.trim() : '';
+        const meshIdForError = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+        const nodeIdForError = typeof args?.nodeId === 'string' ? args.nodeId.trim() : '';
+        try {
+            const meshId = meshIdForError;
+            const nodeId = nodeIdForError;
+            let workspace = workspaceForError;
+            let submoduleIgnorePaths = Array.isArray(args?.submoduleIgnorePaths)
+                ? args.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string')
+                : undefined;
+            let nodeDaemonId: string | undefined;
+            let allowAutoPublishSubmoduleMainCommits = false;
+            if (meshId && nodeId) {
+                // preferInline so fast-forward can resolve inline-cache-only clone worktree nodes.
+                const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+                const mesh = meshRecord?.mesh;
+                const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
+                if (!workspace) {
+                    workspace = typeof node?.workspace === 'string' ? node.workspace.trim() : '';
+                }
+                if (!submoduleIgnorePaths && Array.isArray(node?.policy?.submoduleIgnorePaths)) {
+                    submoduleIgnorePaths = node.policy.submoduleIgnorePaths.filter((value: unknown): value is string => typeof value === 'string');
+                }
+                allowAutoPublishSubmoduleMainCommits = mesh?.policy?.allowAutoPublishSubmoduleMainCommits === true;
+                nodeDaemonId = typeof node?.daemonId === 'string' ? node.daemonId.trim() : undefined;
+            }
+            // If the target node belongs to a remote daemon, forward the command there.
+            // _meshDirectDispatch prevents re-forwarding (and P2P self-dial) when the stored
+            // daemonId uses a legacy format that doesn't match the receiving daemon's identity.
+            const selfDaemonId = ctx.deps.statusInstanceId;
+            // daemonIdsEquivalent: a legacy-form stored daemonId that resolves to THIS
+            // machine's core must be treated as local (not remote) so it is not forwarded /
+            // P2P self-dialed. Equivalent → local.
+            const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+            if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+                const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId!, 'fast_forward_mesh_node', {
+                    ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+                    workspace,
+                    _meshDirectDispatch: true,
+                });
+                return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
+            }
+            const result = await (fastForwardMeshNode({
+                meshId: meshId || undefined,
+                nodeId: nodeId || undefined,
+                workspace,
+                branch: typeof args?.branch === 'string' ? args.branch : undefined,
+                execute: args?.execute === true,
+                dryRun: args?.dryRun === true,
+                updateSubmodules: args?.updateSubmodules === true,
+                submoduleIgnorePaths,
+                mode: args?.mode === 'push' ? 'push' : 'merge',
+                pushSubmodules: args?.pushSubmodules === true,
+                allowAutoPublishSubmoduleMainCommits,
+            }) as Promise<unknown>);
+            return result as CommandRouterResult;
+        } catch (e: any) {
+            const errorMessage = e?.message || String(e);
+            return {
+                success: false,
+                code: 'fast_forward_safety_gate_error',
+                ...(meshIdForError ? { meshId: meshIdForError } : {}),
+                ...(nodeIdForError ? { nodeId: nodeIdForError } : {}),
+                workspace: workspaceForError,
+                mode: args?.mode === 'push' ? 'push' : 'merge',
+                allowed: false,
+                willRun: false,
+                executed: false,
+                // Surface the throw as a blocking reason instead of an opaque IPC crash
+                // so the coordinator gets the same structured shape a clean node returns.
+                blockingReasons: ['fast_forward_safety_gate_error'],
+                operationError: errorMessage,
+                error: errorMessage,
+            } as CommandRouterResult;
+        }
+    },
+
+    refine_mesh_node: async (ctx: MedFamilyContext, args: any) => {
+        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' };
+
+        // Remote forward: a worktree node lives on its OWN daemon's machine, so the
+        // refine (cd into node.workspace, merge → push → cleanup) must run on THAT
+        // daemon — not the coordinator, whose filesystem has no such path. The sibling
+        // fast_forward_mesh_node / clone_mesh_node handlers already forward to the
+        // node's daemon; refine_mesh_node was the gap (the coordinator would cd into a
+        // non-existent local path and fail), so remote-machine worktrees could not be
+        // converged at all. Forward both dry-run (plan reads the worktree git state)
+        // and execute (async merge job) so the same machine that owns the worktree
+        // resolves it.
+        //
+        // coordinatorDaemonId: refine is ASYNC — the completed/failed event is queued
+        // on the executing daemon's pending-events queue scoped to a coordinator id and
+        // recovered by the coordinator's reconcile loop (pullRemoteNodeQueues →
+        // get_pending_mesh_events). Without stamping our own status id, the remote
+        // daemon would fall back to ITS OWN statusInstanceId as the coordinator
+        // (startMeshRefineJob), scoping the terminal event to the wrong inbox where the
+        // real coordinator never pulls it. Stamp the canonical status id (which is in
+        // the coordinator's self-identity set used to scope the remote drain) so the
+        // event routes back here. Preserve any caller-supplied coordinatorDaemonId.
+        //
+        // _meshDirectDispatch prevents re-forwarding (and P2P self-dial) once the call
+        // has landed on the owning daemon — that daemon then executes locally even if
+        // the stored daemonId uses a legacy form that doesn't match its own identity.
+        {
+            const meshRecordForForward = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+            const forwardNode = meshRecordForForward?.mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
+            const nodeDaemonId = typeof forwardNode?.daemonId === 'string' ? forwardNode.daemonId.trim() : undefined;
+            const selfDaemonId = ctx.deps.statusInstanceId;
+            // daemonIdsEquivalent: a legacy-form daemonId resolving to this machine's core
+            // is local — execute locally instead of forwarding. Equivalent → local.
+            const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+            if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+                const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === 'string' && args.coordinatorDaemonId.trim()
+                    ? args.coordinatorDaemonId.trim()
+                    : undefined;
+                const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId!, 'refine_mesh_node', {
+                    ...(typeof args === 'object' && args !== null ? args as Record<string, unknown> : {}),
+                    coordinatorDaemonId: callerCoordinatorDaemonId || selfDaemonId,
+                    _meshDirectDispatch: true,
+                });
+                return (forwarded ?? { success: false, error: 'no response from remote node' }) as CommandRouterResult;
+            }
+        }
+
+        // Dry-run (plan-only) is the default and stays synchronous: it does no
+        // validation/merge/push and returns the plan instantly. Only execute=true
+        // (and not dry_run) goes through the async refine job that actually
+        // validates → merges → pushes → cleans up. Mirrors the
+        // batch_refine_mesh_nodes / fast_forward_mesh_node dry_run/execute contract.
+        const isDryRun = args?.dryRun !== false && args?.execute !== true;
+        if (isDryRun) {
+            // preferInline: plan is the dry-run sibling of refine — clone nodes must resolve.
+            const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+            const mesh = meshRecord?.mesh;
+            const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId));
+            if (!node?.workspace) return { success: false, error: `Node '${nodeId}' workspace not found` };
+            return {
+                success: true,
+                dryRun: true,
+                nodeId,
+                workspace: node.workspace,
+                validationPlan: buildMeshRefineValidationPlan(mesh, node.workspace),
+                mergeWillRun: false,
+                cleanupWillRun: false,
+                hint: 'Dry-run only — no merge/push/cleanup performed. Re-invoke with execute:true to converge this node.',
+            };
+        }
+        return ctx.startMeshRefineJob(meshId, nodeId, args);
+    },
+
+    batch_refine_mesh_nodes: async (ctx: MedFamilyContext, args: any) => {
+        const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+        if (!meshId) return { success: false, error: 'meshId required' };
+        const requestedNodeIds = Array.isArray(args?.nodeIds)
+            ? (args.nodeIds as unknown[]).filter((v): v is string => typeof v === 'string' && v.trim().length > 0).map(v => v.trim())
+            : undefined;
+        // Dry-run (plan-only) stays synchronous: it does no validation/merge and
+        // returns instantly. Execute goes through the async batch job — immediate
+        // {async:true, status:'accepted'} + background convergence + terminal event,
+        // matching the single-node refine_mesh_node contract so long validation
+        // suites can't time out the IPC and strand the coordinator.
+        const isDryRun = args?.dryRun !== false && args?.execute !== true;
+        if (isDryRun) return ctx.batchRefineMeshNodes(meshId, requestedNodeIds, args);
+        return ctx.startMeshRefineBatchJob(meshId, requestedNodeIds, args);
+    },
+};

package/src/commands/med-family/ide.ts

@@ -0,0 +1,163 @@
+/**
+ * RF-ROUTER MED family — IDE lifecycle + provider/IDE detection commands.
+ *
+ * stop_ide, restart_ide, launch_ide, detect_provider, detect_ides. launch_ide
+ * spawns the IDE, connects CDP, registers extension providers and refreshes
+ * detection. restart_ide stops (with kill) then launches.
+ *
+ * launch_ide self-recursion: the original case bodies for restart_session
+ * (cli-agent family) and restart_ide re-entered `executeDaemonCommand('launch_ide')`.
+ * Lifting the launch_ide body into the module-level `launchIde(ctx, args)` helper
+ * lets those handlers invoke the launch directly (ctx.launchIde) without recursing
+ * back through the registry, while the launch_ide handler simply delegates to it.
+ */
+import { DaemonCdpManager } from '../../cdp/manager.js';
+import { registerExtensionProviders } from '../../cdp/setup.js';
+import { launchWithCdp } from '../../launch.js';
+import { loadConfig } from '../../config/config.js';
+import { loadState, saveState } from '../../config/state-store.js';
+import { resolveIdeLaunchWorkspace } from '../../config/workspaces.js';
+import { appendRecentActivity } from '../../config/recent-activity.js';
+import { detectIDEs } from '../../detection/ide-detector.js';
+import { detectCLI } from '../../detection/cli-detector.js';
+import { LOG } from '../../logging/logger.js';
+import type { CommandRouterResult } from '../router.js';
+import type { MedFamilyContext, MedFamilyHandler } from './types.js';
+
+/**
+ * IDE launch + CDP connect. Lifted verbatim from the original `launch_ide` switch
+ * case so restart_session / restart_ide can call it directly instead of recursing
+ * through executeDaemonCommand. Reads the router's CDP managers and detection
+ * caches via ctx.deps.
+ */
+export async function launchIde(ctx: MedFamilyContext, args: any): Promise<CommandRouterResult> {
+    const ideKey = args?.ideId || args?.ideType;
+    const resolvedWorkspace = resolveIdeLaunchWorkspace(
+        {
+            workspace: args?.workspace,
+            workspaceId: args?.workspaceId,
+            useDefaultWorkspace: args?.useDefaultWorkspace,
+        },
+        loadConfig(),
+    );
+    const launchArgs = {
+        ideId: ideKey,
+        workspace: resolvedWorkspace,
+        newWindow: args?.newWindow,
+    };
+    LOG.info('LaunchIDE', `target=${ideKey || 'auto'}`);
+    const result = await launchWithCdp(launchArgs);
+
+    if (result.success && result.port && result.ideId && !ctx.deps.cdpManagers.has(result.ideId)) {
+        const logFn = ctx.deps.getCdpLogFn
+            ? ctx.deps.getCdpLogFn(result.ideId)
+            : LOG.forComponent(`CDP:${result.ideId}`).asLogFn();
+        const provider = ctx.deps.providerLoader.getMeta(result.ideId);
+        const manager = new DaemonCdpManager(result.port, logFn, undefined, provider?.targetFilter);
+        const connected = await manager.connect();
+        if (connected) {
+            // Register active extension providers for this IDE in CDP manager
+            registerExtensionProviders(ctx.deps.providerLoader, manager, result.ideId);
+            ctx.deps.cdpManagers.set(result.ideId, manager);
+            LOG.info('CDP', `Connected: ${result.ideId} (port ${result.port})`);
+            LOG.info('CDP', `${ctx.deps.cdpManagers.size} IDE(s) connected`);
+
+            // Notify consumer (e.g. setupIdeInstance)
+            ctx.deps.onCdpManagerCreated?.(result.ideId, manager);
+        }
+    }
+    ctx.deps.onIdeConnected?.();
+    try {
+        const results = await detectIDEs(ctx.deps.providerLoader);
+        ctx.deps.detectedIdes.value = results;
+        ctx.deps.providerLoader.setIdeDetectionResults(results, true);
+    } catch { /* ignore detection refresh errors */ }
+    if (result.success && resolvedWorkspace) {
+        try {
+            const next = appendRecentActivity(loadState(), {
+                kind: 'ide',
+                providerType: result.ideId || ideKey,
+                providerName: result.ideId || ideKey,
+                workspace: resolvedWorkspace,
+                title: result.ideId || ideKey,
+            });
+            saveState(next);
+        } catch { /* ignore activity persist errors */ }
+    } else if (result.success && (result.ideId || ideKey)) {
+        try {
+            saveState(appendRecentActivity(loadState(), {
+                kind: 'ide',
+                providerType: result.ideId || ideKey,
+                providerName: result.ideId || ideKey,
+                title: result.ideId || ideKey,
+            }));
+        } catch { /* ignore activity persist errors */ }
+    }
+    return { ...result };
+}
+
+export const ideHandlers: Record<string, MedFamilyHandler> = {
+    // ─── IDE stop ───
+    stop_ide: async (ctx: MedFamilyContext, args: any) => {
+        const ideType = args?.ideType;
+        if (!ideType) throw new Error('ideType required');
+        const killProcess = args?.killProcess !== false; // default true
+        await ctx.stopIde(ideType, killProcess);
+        try {
+            const results = await detectIDEs(ctx.deps.providerLoader);
+            ctx.deps.detectedIdes.value = results;
+            ctx.deps.providerLoader.setIdeDetectionResults(results, true);
+        } catch { /* ignore detection refresh errors */ }
+        return { success: true, ideType, stopped: true, processKilled: killProcess };
+    },
+
+    // ─── IDE restart ───
+    restart_ide: async (ctx: MedFamilyContext, args: any) => {
+        const ideType = args?.ideType;
+        if (!ideType) throw new Error('ideType required');
+        await ctx.stopIde(ideType, true); // always kill process on restart
+        const launchResult = await ctx.launchIde({ ideType, enableCdp: true, workspace: args?.workspace });
+        return { success: true, ideType, restarted: true, launch: launchResult };
+    },
+
+    // ─── IDE launch + CDP connect ───
+    launch_ide: async (ctx: MedFamilyContext, args: any) => {
+        return launchIde(ctx, args);
+    },
+
+    // ─── Detect providers ───
+    detect_provider: async (ctx: MedFamilyContext, args: any) => {
+        const providerType = typeof args?.providerType === 'string' ? args.providerType.trim() : '';
+        if (!providerType) return { success: false, error: 'providerType is required' };
+        const normalizedType = ctx.deps.providerLoader.resolveAlias(providerType);
+        const provider = ctx.deps.providerLoader.getByAlias(providerType);
+        if (!provider) return { success: false, error: `Provider not found: ${providerType}` };
+        if (provider.category !== 'cli' && provider.category !== 'acp') {
+            return { success: false, error: `Provider detection is only supported for CLI/ACP providers: ${providerType}` };
+        }
+        if (!ctx.deps.providerLoader.isMachineProviderEnabled(normalizedType)) {
+            return { success: false, error: `Provider is disabled on this machine: ${providerType}` };
+        }
+        const detected = await detectCLI(normalizedType, ctx.deps.providerLoader, { includeVersion: false });
+        ctx.deps.providerLoader.setCliDetectionResults([{
+            id: normalizedType,
+            installed: !!detected,
+            path: detected?.path,
+        }], false);
+        ctx.deps.onStatusChange?.();
+        return {
+            success: true,
+            providerType: normalizedType,
+            detected: !!detected,
+            path: detected?.path || null,
+        };
+    },
+
+    // ─── Detect IDEs ───
+    detect_ides: async (ctx: MedFamilyContext, _args: any) => {
+        const results = await detectIDEs(ctx.deps.providerLoader);
+        ctx.deps.detectedIdes.value = results;
+        ctx.deps.providerLoader.setIdeDetectionResults(results, true);
+        return { success: true, detectedInfo: results };
+    },
+};

package/src/commands/med-family/index.ts

@@ -0,0 +1,37 @@
+/**
+ * RF-ROUTER MED family — command registry.
+ *
+ * Aggregates the medium-coupling command handlers extracted from
+ * DaemonCommandRouter.executeDaemonCommand into a single cmd → handler map. The
+ * router consults this registry after the LOW-family registry and before its
+ * switch (registry hit → return the handler result; miss → fall through to the
+ * remaining switch / CommandHandler delegation), so the facade and dispatch
+ * semantics are unchanged.
+ *
+ * MED handlers differ from LOW handlers in that they need router-private
+ * collaborators (mesh resolution, owner gating, inline-cache mutation, worktree /
+ * session cleanup, refine job starters, IDE launch). The router binds those onto
+ * MedFamilyContext at dispatch — see types.ts.
+ */
+import { cliAgentHandlers } from './cli-agent.js';
+import { ideHandlers } from './ide.js';
+import { meshCrudHandlers } from './mesh-crud.js';
+import { meshHostPairingHandlers } from './mesh-host-pairing.js';
+import { meshQueueHandlers } from './mesh-queue.js';
+import { fastForwardHandlers } from './fast-forward.js';
+import { meshRestartHandlers } from './mesh-restart.js';
+import type { MedFamilyRegistry } from './types.js';
+
+export type { MedFamilyContext, MedFamilyHandler, MedFamilyRegistry } from './types.js';
+
+export const medFamilyRegistry: MedFamilyRegistry = new Map(
+    Object.entries({
+        ...cliAgentHandlers,
+        ...ideHandlers,
+        ...meshCrudHandlers,
+        ...meshHostPairingHandlers,
+        ...meshQueueHandlers,
+        ...fastForwardHandlers,
+        ...meshRestartHandlers,
+    }),
+);