moflo 4.10.7 → 4.10.8

package/dist/src/cli/services/daemon-port.js

@@ -0,0 +1,217 @@
+/**
+ * Daemon port resolution — single source of truth for the moflo daemon's
+ * HTTP port.
+ *
+ * Before #1145, `DEFAULT_DASHBOARD_PORT` in `daemon-dashboard.ts` and
+ * `DEFAULT_DAEMON_PORT` in `daemon-write-client.ts` were two separate `3117`
+ * literals. The server tried 3117 → 3126 on `EADDRINUSE`; the client always
+ * POSTed to 3117. When a second moflo project's daemon bound 3118+, that
+ * project's clients still hit 3117 → silent cross-project read/write
+ * routing. See `docs/internal/1145-daemon-port-collision-analysis.md`.
+ *
+ * This module collapses both literals into one resolver. Every entry point
+ * MUST go through `resolveProjectPort()` (or read the `port` field a
+ * already-bound daemon recorded in `.moflo/daemon.lock`).
+ *
+ * Resolution precedence — server and client agree:
+ *   1. `MOFLO_DAEMON_PORT` env override (consumer pin / smoke harness — wins)
+ *   2. Lock-file `port` field (client-only — server WRITES this after bind)
+ *   3. `resolveProjectPort(projectRoot)` — sha256(path) → 33000+(hash%1000)
+ *   4. `LEGACY_DEFAULT_PORT` (3117) — read-only fallback for ancient locks
+ *      with no port field and no env override; warns once via stderr
+ *
+ * @module cli/services/daemon-port
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import * as http from 'node:http';
+/**
+ * Deterministic port range. 33000-33999 — clear of every common dev-server
+ * port (3000, 3001, 4000, 5000, 5173, 8000, 8080), every well-known service
+ * (≤ 1024), and the moflo legacy default (3117). Collision probability across
+ * N active projects is ~N/1000; the identity check (`isDaemonIdentityMatch`)
+ * is the safety net when collisions do hit.
+ */
+export const PORT_RANGE_BASE = 33000;
+export const PORT_RANGE_SIZE = 1000;
+/**
+ * Legacy default port — used by daemons that haven't been upgraded past
+ * 4.10.7 and locks that never recorded a port field. Kept as a read-only
+ * fallback so a fresh client probing an old daemon still finds it; clients
+ * that fall through to this path emit a one-time deprecation warn.
+ *
+ * NEW code must NEVER reference this constant outside `daemon-port.ts`. The
+ * regression guard at `tests/system/no-fixed-3117.test.ts` enforces.
+ */
+export const LEGACY_DEFAULT_PORT = 3117;
+/**
+ * Resolve the canonical port for a given project root.
+ *
+ * Pure function — no I/O. Same project path → same port across daemon
+ * restarts, across processes, across machines (the hash is deterministic).
+ *
+ * @param projectRoot absolute path to the project root (use `findProjectRoot()`)
+ * @returns port in `[PORT_RANGE_BASE, PORT_RANGE_BASE + PORT_RANGE_SIZE)`
+ */
+export function resolveProjectPort(projectRoot) {
+    const envPort = readEnvPortOverride();
+    if (envPort != null)
+        return envPort;
+    const hash = createHash('sha256').update(projectRoot).digest();
+    return PORT_RANGE_BASE + (hash.readUInt16BE(0) % PORT_RANGE_SIZE);
+}
+/**
+ * Read `MOFLO_DAEMON_PORT` from the environment. Returns the parsed port
+ * (1-65535) or `null` if unset/invalid.
+ *
+ * Exported so callers can short-circuit lock-file reads when the env is
+ * pinned — useful in the smoke harness and CI where the env is the
+ * authoritative pin.
+ */
+export function readEnvPortOverride() {
+    const raw = process.env.MOFLO_DAEMON_PORT;
+    if (!raw)
+        return null;
+    const n = parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 1 || n > 65535)
+        return null;
+    return n;
+}
+/**
+ * Resolve the daemon port a CLIENT should connect to for a given project.
+ *
+ * Reads `.moflo/daemon.lock` to discover the actual bound port — if the
+ * daemon collided with another project in its deterministic-range bucket
+ * and the dashboard retry loop bumped it forward, the lock reflects reality
+ * and the client follows. Falls back to `resolveProjectPort` when the lock
+ * is absent (daemon not yet started), the lock has no `port` field (old
+ * daemon predating #1145), or the port reads as invalid.
+ *
+ * Never throws — every I/O failure degrades to the deterministic fallback.
+ */
+export function resolveClientPort(projectRoot) {
+    const envPort = readEnvPortOverride();
+    if (envPort != null)
+        return envPort;
+    try {
+        const lockFile = join(projectRoot, '.moflo', 'daemon.lock');
+        if (existsSync(lockFile)) {
+            const raw = readFileSync(lockFile, 'utf-8');
+            const lock = JSON.parse(raw);
+            const lockPort = typeof lock?.port === 'number' ? lock.port : null;
+            if (lockPort && Number.isFinite(lockPort) && lockPort > 0 && lockPort < 65536) {
+                return lockPort;
+            }
+        }
+    }
+    catch {
+        // Corrupt or unreadable lock — fall through to deterministic port.
+    }
+    return resolveProjectPort(projectRoot);
+}
+/**
+ * Build the list of ports the SERVER should try, in order, when starting
+ * the daemon. First entry is the deterministic port; the rest are the
+ * collision-fallback range. Capped at `PORT_RANGE_SIZE` so the loop can
+ * never wrap past the bucket.
+ *
+ * If the env override is set, the list collapses to that single port —
+ * the consumer pinned it on purpose; respect their choice and hard-fail
+ * if it's already in use.
+ */
+export function serverPortCandidates(projectRoot, maxAttempts = 10) {
+    const envPort = readEnvPortOverride();
+    if (envPort != null)
+        return [envPort];
+    const base = resolveProjectPort(projectRoot);
+    const attempts = Math.min(Math.max(1, maxAttempts), PORT_RANGE_SIZE);
+    const ports = [];
+    for (let i = 0; i < attempts; i++) {
+        ports.push(PORT_RANGE_BASE + ((base - PORT_RANGE_BASE + i) % PORT_RANGE_SIZE));
+    }
+    return ports;
+}
+// ============================================================================
+// Identity probe — shared by client + healer (#1145)
+// ============================================================================
+/**
+ * Normalize project root paths for identity comparison.
+ *
+ *   - Resolve symlinks via `realpathSync`. macOS aliases `/var/folders`
+ *     → `/private/var/folders`; one side of the daemon/client pair may
+ *     resolve the symlink and the other may not, producing false-positive
+ *     identity mismatches on otherwise-matching project roots (caught by
+ *     the consumer-smoke harness on macOS + Ubuntu after the original
+ *     #1145 fix). Ubuntu hits the same shape via `/tmp` symlinks under
+ *     certain mount configurations.
+ *   - Lowercase on Windows so `C:\Users\...` and `c:\users\...` compare
+ *     equal. POSIX is case-sensitive — pass through.
+ *
+ * Never throws — a path that doesn't exist (or that we lack permission
+ * to stat) falls back to the input string. The fallback case is safe
+ * because the symlink-mismatch class only fires on paths that DO exist
+ * (both daemon and client just resolved them).
+ */
+export function normalizeProjectRoot(p) {
+    let resolved = p;
+    try {
+        resolved = realpathSync(p);
+    }
+    catch { /* path doesn't exist / EACCES — use input */ }
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+/**
+ * Send `GET /api/health` to `127.0.0.1:<port>` and parse the daemon's
+ * identity payload. Never throws — every failure mode maps to a
+ * `DaemonIdentityProbe` variant.
+ *
+ * Shared by `daemon-write-client.ts` (per-request safety net) and
+ * `doctor-checks-config.ts` (`checkDaemonIdentity` subcheck).
+ */
+export function probeDaemonHealth(port, timeoutMs) {
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = (r) => {
+            if (done)
+                return;
+            done = true;
+            resolve(r);
+        };
+        const req = http.get({ host: '127.0.0.1', port, path: '/api/health', timeout: timeoutMs }, (res) => {
+            const status = res.statusCode ?? 0;
+            if (status === 404) {
+                res.resume();
+                finish({ kind: 'legacy' });
+                return;
+            }
+            if (status !== 200) {
+                res.resume();
+                finish({ kind: 'unreachable' });
+                return;
+            }
+            let buf = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { buf += chunk; });
+            res.on('end', () => {
+                try {
+                    const data = JSON.parse(buf);
+                    if (typeof data?.projectRoot === 'string' && data.projectRoot.length > 0) {
+                        finish({ kind: 'identity', projectRoot: data.projectRoot });
+                        return;
+                    }
+                    // 200 but no identity field — pre-#1145 daemon that 200s on
+                    // every URL. Same handling as a 404.
+                    finish({ kind: 'legacy' });
+                }
+                catch {
+                    finish({ kind: 'legacy' });
+                }
+            });
+            res.on('error', () => finish({ kind: 'unreachable' }));
+        });
+        req.on('error', () => finish({ kind: 'unreachable' }));
+        req.on('timeout', () => { req.destroy(); finish({ kind: 'unreachable' }); });
+    });
+}
+//# sourceMappingURL=daemon-port.js.map

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.10.7';
+export const VERSION = '4.10.8';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.10.7",
+  "version": "4.10.8",
   "description": "MoFlo — AI agent orchestration for Claude Code. A standalone, opinionated toolkit with semantic memory, learned routing, gates, spells, and the /flo issue-execution skill.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -95,7 +95,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.10.6",
+    "moflo": "^4.10.7",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"

package/dist/src/cli/config-adapter.js

@@ -1,182 +0,0 @@
-/**
- * Configuration Adapter
- * Converts between SystemConfig and V3Config types
- */
-/**
- * Convert SystemConfig to V3Config (CLI-specific format)
- */
-export function systemConfigToV3Config(systemConfig) {
-    return {
-        version: '3.0.0',
-        projectRoot: systemConfig.orchestrator?.session?.dataDir || process.cwd(),
-        // Agent configuration
-        agents: {
-            defaultType: 'coder',
-            autoSpawn: false, // Not in SystemConfig
-            maxConcurrent: systemConfig.orchestrator?.lifecycle?.maxConcurrentAgents ?? 15,
-            timeout: systemConfig.orchestrator?.lifecycle?.spawnTimeout ?? 300000,
-            providers: [],
-        },
-        // Swarm configuration
-        swarm: {
-            topology: normalizeTopology(systemConfig.swarm?.topology),
-            maxAgents: systemConfig.swarm?.maxAgents ?? 15,
-            autoScale: systemConfig.swarm?.autoScale?.enabled ?? false,
-            coordinationStrategy: systemConfig.swarm?.coordination?.consensusRequired ? 'consensus' : 'leader',
-            healthCheckInterval: systemConfig.swarm?.coordination?.timeoutMs ?? 10000,
-        },
-        // Memory configuration
-        memory: {
-            backend: normalizeMemoryBackend(systemConfig.memory?.type),
-            persistPath: systemConfig.memory?.path || './data/memory',
-            cacheSize: systemConfig.memory?.maxSize ?? 1000000,
-            enableHNSW: systemConfig.memory?.agentdb?.indexType === 'hnsw',
-            vectorDimension: systemConfig.memory?.agentdb?.dimensions ?? 1536,
-        },
-        // MCP configuration (only stdio transport is supported)
-        mcp: {
-            autoStart: false, // Not in SystemConfig
-            transportType: 'stdio',
-            tools: [], // Not in SystemConfig
-        },
-        // CLI preferences
-        cli: {
-            colorOutput: true,
-            interactive: true,
-            verbosity: 'normal',
-            outputFormat: 'text',
-            progressStyle: 'spinner',
-        },
-        // Hooks configuration
-        hooks: {
-            enabled: false,
-            autoExecute: false,
-            hooks: [],
-        },
-    };
-}
-/**
- * Convert V3Config to SystemConfig
- */
-export function v3ConfigToSystemConfig(v3Config) {
-    return {
-        orchestrator: {
-            lifecycle: {
-                maxConcurrentAgents: v3Config.agents.maxConcurrent,
-                spawnTimeout: v3Config.agents.timeout,
-                terminateTimeout: 10000,
-                maxSpawnRetries: 3,
-            },
-            session: {
-                dataDir: v3Config.projectRoot,
-                persistSessions: true,
-                sessionRetentionMs: 3600000,
-            },
-            health: {
-                checkInterval: v3Config.swarm.healthCheckInterval,
-                historyLimit: 100,
-                degradedThreshold: 1,
-                unhealthyThreshold: 2,
-            },
-        },
-        swarm: {
-            topology: denormalizeTopology(v3Config.swarm.topology),
-            maxAgents: v3Config.swarm.maxAgents,
-            autoScale: {
-                enabled: v3Config.swarm.autoScale,
-                minAgents: 1,
-                maxAgents: v3Config.swarm.maxAgents,
-                scaleUpThreshold: 0.8,
-                scaleDownThreshold: 0.3,
-            },
-            coordination: {
-                consensusRequired: v3Config.swarm.coordinationStrategy === 'consensus',
-                timeoutMs: v3Config.swarm.healthCheckInterval,
-                retryPolicy: {
-                    maxRetries: 3,
-                    backoffMs: 500,
-                },
-            },
-            communication: {
-                protocol: 'events',
-                batchSize: 10,
-                flushIntervalMs: 100,
-            },
-        },
-        memory: {
-            type: denormalizeMemoryBackend(v3Config.memory.backend),
-            path: v3Config.memory.persistPath,
-            maxSize: v3Config.memory.cacheSize,
-            agentdb: {
-                dimensions: v3Config.memory.vectorDimension,
-                indexType: v3Config.memory.enableHNSW ? 'hnsw' : 'flat',
-                efConstruction: 200,
-                m: 16,
-                quantization: 'none',
-            },
-        },
-        mcp: {
-            name: 'moflo',
-            version: '3.0.0',
-            transport: {
-                type: 'stdio',
-            },
-            capabilities: {
-                tools: true,
-                resources: true,
-                prompts: true,
-                logging: true,
-            },
-        },
-    };
-}
-/**
- * Normalize topology from SystemConfig to V3Config
- */
-function normalizeTopology(topology) {
-    switch (topology) {
-        case 'hierarchical':
-        case 'mesh':
-        case 'ring':
-        case 'star':
-        case 'hybrid':
-        case 'hierarchical-mesh':
-            return topology;
-        case 'adaptive':
-            return 'hybrid';
-        default:
-            return 'hierarchical';
-    }
-}
-/**
- * Denormalize topology from V3Config to SystemConfig
- */
-function denormalizeTopology(topology) {
-    if (topology === 'hybrid') {
-        return 'hierarchical-mesh';
-    }
-    return topology;
-}
-/**
- * Normalize memory backend from SystemConfig to V3Config
- */
-function normalizeMemoryBackend(backend) {
-    switch (backend) {
-        case 'memory':
-        case 'sqlite':
-        case 'agentdb':
-        case 'hybrid':
-            return backend;
-        case 'redis':
-            return 'memory'; // Redis maps to memory for CLI purposes
-        default:
-            return 'hybrid';
-    }
-}
-/**
- * Denormalize memory backend from V3Config to SystemConfig
- */
-function denormalizeMemoryBackend(backend) {
-    return backend;
-}
-//# sourceMappingURL=config-adapter.js.map