@geraldmaron/construct 1.0.21 → 1.0.24

package/lib/service-manager.mjs

@@ -1,8 +1,8 @@
 /**
  * lib/service-manager.mjs — start, stop, and describe Construct runtime services.
  *
- * Manages the dashboard process, local Postgres (Docker), memory server (cm),
- * and OpenCode. startServices() is the single entry point for `construct up` —
+ * Manages the dashboard process, memory server (cm), and OpenCode. 
+ * startServices() is the single entry point for `construct up` —
  * spawns whatever is available and returns a result per service.
  */
 import { spawn, spawnSync } from 'node:child_process';
@@ -10,30 +10,17 @@ import fs from 'node:fs';
 import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 import { findAvailablePort } from './host-capabilities.mjs';
 import { getUserEnvPath, loadConstructEnv, parseEnvFile, writeEnvValues } from './env-config.mjs';
-import { detectDockerCompose } from './setup.mjs';
-import { stashConstructDb, restoreConstructDb } from './storage/postgres-backup.mjs';
 import { runPressureRelease } from './runtime-pressure.mjs';
-import {
-  pruneStashDir,
-  verifyTelemetryKeys,
-  isRemoteTelemetry,
-} from './services/local-postgres.mjs';
 import { resolveTraceBackend, telemetryProviderLabel } from './telemetry/client.mjs';
-
-const CONSTRUCT_PG_COMPOSE_DIR = 'services/postgres';
-const CONSTRUCT_PG_CONTAINER = 'construct-postgres';
-const CONSTRUCT_PG_PORT = 54329;
-const CONSTRUCT_PG_HEALTH_RETRIES = 12;
-const CONSTRUCT_PG_HEALTH_INTERVAL_MS = 2000;
+import { memoryPort as derivedMemoryPort } from './home-namespace.mjs';
 
 const DASHBOARD_STATE_FILE = 'dashboard.json';
 
-// pruneStashDir and verifyTelemetryKeys now live in lib/services/telemetry-backend.mjs.
-// Re-exported below at module bottom for tests that already import from here.
-
+const INSTALL_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
 
 function runtimeStateDir(homeDir = os.homedir()) {
   return path.join(homeDir, '.construct', 'runtime');
@@ -108,17 +95,8 @@ export function buildRuntimeRecoverySummary({ rootDir, homeDir = os.homedir(), r
 }
 
 export function isManagedConstructPostgresUrl(databaseUrl = '') {
-  if (!databaseUrl) return false;
-  try {
-    const parsed = new URL(databaseUrl);
-    const host = parsed.hostname;
-    return (
-      parsed.port === String(CONSTRUCT_PG_PORT) &&
-      ['127.0.0.1', 'localhost', '::1'].includes(host)
-    ) || host === CONSTRUCT_PG_CONTAINER;
-  } catch {
-    return databaseUrl.includes(`:${CONSTRUCT_PG_PORT}/`);
-  }
+  // Construct no longer manages local Postgres containers.
+  return false;
 }
 
 function processExists(pid) {
@@ -260,7 +238,7 @@ export function startDoctor({ rootDir, homeDir = os.homedir() } = {}) {
   }
   const existing = readDoctorState(homeDir);
   if (existing) return { started: false, reused: true, pid: existing.pid };
-  const indexPath = path.join(rootDir, 'lib', 'doctor', 'index.mjs');
+  const indexPath = path.join(INSTALL_ROOT, 'lib', 'doctor', 'index.mjs');
   if (!fs.existsSync(indexPath)) return { started: false, reason: 'missing-binary' };
   const { logPath } = spawnDetached('node', [indexPath], homeDir, 'doctor.log', { cwd: rootDir, env: { ...process.env } });
   return { started: true, logPath };
@@ -279,13 +257,25 @@ export async function startDashboard({ rootDir, homeDir = os.homedir(), preferre
   fs.mkdirSync(path.dirname(outPath), { recursive: true });
   const out = fs.openSync(outPath, 'a');
   const err = fs.openSync(outPath, 'a');
-  const child = spawn(process.execPath, [path.join(rootDir, 'lib', 'server', 'index.mjs')], {
+  const child = spawn(process.execPath, [path.join(INSTALL_ROOT, 'lib', 'server', 'index.mjs')], {
     detached: true,
     stdio: ['ignore', out, err],
     env: { ...process.env, PORT: String(port) },
   });
   child.unref();
 
+  let ready = false;
+  for (let i = 0; i < 30; i += 1) {
+    if (await probeRuntimePort(port)) { ready = true; break; }
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+
+  if (!ready) {
+    let logTail = '';
+    try { logTail = fs.readFileSync(outPath, 'utf8').split('\n').slice(-12).join('\n'); } catch { /* log unreadable */ }
+    return { started: false, failed: true, port, logPath: outPath, error: `dashboard did not bind 127.0.0.1:${port} within 6s`, logTail };
+  }
+
   const state = {
     pid: child.pid,
     port,
@@ -297,10 +287,6 @@ export async function startDashboard({ rootDir, homeDir = os.homedir(), preferre
   return { started: true, reused: false, ...state };
 }
 
-/**
- * Resolve runtime ports. Re-uses ports from config.env when the service is
- * already listening there (avoids port drift on repeated `construct up`).
- */
 export async function getRuntimePorts(homeDir = os.homedir(), {
   dashboardProbeFn = isDashboardRunning,
   memoryProbeFn = isMemoryRunning,
@@ -320,7 +306,7 @@ export async function getRuntimePorts(homeDir = os.homedir(), {
 
   return {
     dashboard: dashboard?.port ?? await resolvePort('DASHBOARD_PORT', 4242, dashboardProbeFn),
-    memory: await resolvePort('MEMORY_PORT', 8765, memoryProbeFn),
+    memory: await resolvePort('MEMORY_PORT', derivedMemoryPort(), memoryProbeFn),
     bridge: await resolvePort('BRIDGE_PORT', 5173, openCodeProbeFn),
   };
 }
@@ -336,118 +322,12 @@ export async function describeRuntimeSupport() {
   }
   return {
     tmux: commandExists('tmux'),
-    docker: commandExists('docker'),
     cm: commandExists('cm'),
     opencode: commandExists('opencode'),
   };
 }
 
-// ── Construct Postgres management ──────────────────────────────────────────
-
-function constructPgComposePath(rootDir) {
-  return path.join(rootDir, CONSTRUCT_PG_COMPOSE_DIR, 'docker-compose.yml');
-}
-
-function isConstructPostgresRunning(spawnSyncFn = spawnSync) {
-  const result = spawnSyncFn('docker', ['inspect', '--format', '{{.State.Running}}', CONSTRUCT_PG_CONTAINER], {
-    encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
-  });
-  return result.stdout?.trim() === 'true';
-}
-
-function isConstructPostgresHealthy(spawnSyncFn = spawnSync) {
-  const result = spawnSyncFn('docker', ['exec', CONSTRUCT_PG_CONTAINER, 'pg_isready', '-U', 'construct'], {
-    encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
-  });
-  return result.status === 0;
-}
-
-async function waitForConstructPostgresHealthy({
-  spawnSyncFn = spawnSync,
-  maxRetries = CONSTRUCT_PG_HEALTH_RETRIES,
-  intervalMs = CONSTRUCT_PG_HEALTH_INTERVAL_MS,
-} = {}) {
-  for (let i = 0; i < maxRetries; i++) {
-    if (isConstructPostgresHealthy(spawnSyncFn)) return true;
-    await new Promise((r) => setTimeout(r, intervalMs));
-  }
-  return false;
-}
-
-function startConstructPostgres({ rootDir, homeDir = os.homedir(), spawnSyncFn = spawnSync, detectDockerComposeFn = detectDockerCompose } = {}) {
-  const composeRunner = detectDockerComposeFn();
-  if (!composeRunner) return { status: 'unavailable', note: 'Docker not available' };
-
-  const composeFile = constructPgComposePath(rootDir);
-  if (!fs.existsSync(composeFile)) return { status: 'unavailable', note: 'Postgres compose file not found — run construct init first' };
-
-  const args = [...composeRunner.argsPrefix, '-p', 'construct-postgres', '-f', composeFile, 'up', '-d'];
-  const r = spawnSyncFn(composeRunner.command, args, { stdio: 'pipe', encoding: 'utf8' });
-  if (r.status === 0) return { status: 'started' };
-  return { status: 'error', note: (r.stderr || '').trim().split('\n')[0] || 'compose up failed' };
-}
-
-function stopConstructPostgres({ rootDir, homeDir = os.homedir(), spawnSyncFn = spawnSync, detectDockerComposeFn = detectDockerCompose } = {}) {
-  const composeRunner = detectDockerComposeFn();
-  if (!composeRunner) return { status: 'skipped', note: 'Docker not available' };
-
-  const composeFile = constructPgComposePath(rootDir);
-  if (!fs.existsSync(composeFile)) return { status: 'skipped', note: 'no compose file' };
-
-  const args = [...composeRunner.argsPrefix, '-p', 'construct-postgres', '-f', composeFile, 'down'];
-  const r = spawnSyncFn(composeRunner.command, args, { stdio: 'pipe', encoding: 'utf8' });
-  if (r.status === 0) return { status: 'stopped' };
-  return { status: 'error', note: (r.stderr || '').trim().split('\n')[0] || 'compose down failed' };
-}
-
-function checkPgvectorEnabled(spawnSyncFn = spawnSync) {
-  const result = spawnSyncFn('docker', [
-    'exec', CONSTRUCT_PG_CONTAINER, 'psql', '-U', 'construct', '-d', 'construct',
-    '-tAc', "SELECT EXISTS(SELECT 1 FROM pg_extension WHERE extname = 'vector')",
-  ], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-  return result.stdout?.trim() === 't';
-}
-
-/**
- * On macOS, when the Docker CLI is installed but the daemon is down,
- * launch Docker Desktop and poll `docker info` up to `timeoutMs` for
- * the daemon to come up. Opt-out via `CONSTRUCT_DISABLE_DOCKER_AUTOSTART=1`
- * so users who keep Docker off aren't forced into it. No-ops on Linux
- * (systemd needs sudo) and Windows (different launcher).
- */
-async function tryStartDockerDaemon({
-  env = process.env,
-  spawnSyncFn = spawnSync,
-  timeoutMs = 60_000,
-  pollMs = 1500,
-} = {}) {
-  if (env.CONSTRUCT_DISABLE_DOCKER_AUTOSTART === '1') return false;
-  if (process.platform !== 'darwin') return false;
-
-  // CLI must be present; without it, nothing to start.
-  if (spawnSyncFn('command -v docker', { stdio: 'ignore', shell: true }).status !== 0) return false;
-
-  // If the daemon is already up, no work needed.
-  if (spawnSyncFn('docker', ['info'], { stdio: 'ignore' }).status === 0) return true;
-
-  // Best-effort launch. `open -a Docker` returns immediately; the daemon
-  // takes 5-30s to come fully up so we poll.
-  spawnSyncFn('open', ['-a', 'Docker'], { stdio: 'ignore' });
-
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, pollMs));
-    if (spawnSyncFn('docker', ['info'], { stdio: 'ignore' }).status === 0) return true;
-  }
-  return false;
-}
-
-// The optional services a user can pick from with `construct dev --select` /
-// `--only=`. Pressure Guard (cleanup) and Doctor (the L0 supervisor daemon)
-// are infrastructure, always on — they are intentionally not selectable.
-
 export const SELECTABLE_SERVICES = Object.freeze([
-  { key: 'postgres', label: 'Postgres', description: 'Managed pgvector container (or external DATABASE_URL).' },
   { key: 'dashboard', label: 'Dashboard', description: 'Local operations dashboard on http://127.0.0.1:4242.' },
   { key: 'telemetry', label: 'Telemetry', description: 'Trace export / local JSONL traces.' },
   { key: 'memory', label: 'Memory (cm)', description: 'Persistent memory service (cm).' },
@@ -461,36 +341,24 @@ export async function startServices({
   describeRuntimeSupportFn = describeRuntimeSupport,
   getRuntimePortsFn = getRuntimePorts,
   startDashboardFn = startDashboard,
-  detectDockerComposeFn = detectDockerCompose,
   loadConstructEnvFn = loadConstructEnv,
   spawnDetachedFn = spawnDetached,
-  verifyTelemetryKeysFn = verifyTelemetryKeys,
   memoryProbeFn = isMemoryRunning,
   openCodeProbeFn = isOpenCodeRunning,
   runPressureReleaseFn = runPressureRelease,
-  tryStartDockerDaemonFn = tryStartDockerDaemon,
 } = {}) {
   const support = await describeRuntimeSupportFn();
   const ports = await getRuntimePortsFn(homeDir);
   const envPath = getUserEnvPath(homeDir);
 
-  // A null selection means "start everything" (the default). A Set restricts
-  // startup to the chosen optional services; always-on infrastructure ignores it.
-
   const wants = (key) => selected === null || selected.has(key);
 
-  // On macOS, auto-launch Docker Desktop when the CLI is present but the
-  // daemon is down. Polls up to 60s so downstream Postgres startup sees a working
-  // compose runner instead of "Docker not available".
-  await tryStartDockerDaemonFn({ env: { ...process.env, HOME: homeDir }, timeoutMs: 5000 });
-
   writeEnvValues(envPath, {
     DASHBOARD_PORT: String(ports.dashboard),
     MEMORY_PORT: String(ports.memory),
     BRIDGE_PORT: String(ports.bridge),
   });
 
-  // Construct Postgres — start if DATABASE_URL points to managed container
   const liveEnv = loadConstructEnvFn({ rootDir, homeDir });
   const results = [];
   const pressureReport = runPressureReleaseFn({ env: { ...liveEnv, HOME: homeDir } });
@@ -502,86 +370,50 @@ export async function startServices({
       note: `terminated ${pressureReport.killed.length} stale process(es)`,
     });
   }
-  const databaseUrl = liveEnv.DATABASE_URL || '';
-  const usesManagedPostgres = isManagedConstructPostgresUrl(databaseUrl);
-
-  if (wants('postgres') && usesManagedPostgres) {
-    if (!isConstructPostgresRunning()) {
-      const pgStart = startConstructPostgres({ rootDir, homeDir, spawnSyncFn: spawnSync, detectDockerComposeFn: detectDockerComposeFn });
-      if (pgStart.status === 'started') {
-        const healthy = await waitForConstructPostgresHealthy();
-        if (healthy) {
-          const pgvector = checkPgvectorEnabled();
-          results.push({
-            name: 'Postgres',
-            url: `postgresql://127.0.0.1:${CONSTRUCT_PG_PORT}/construct`,
-            status: pgvector ? 'started' : 'degraded',
-            note: pgvector ? 'pgvector enabled' : 'pgvector not installed — semantic search unavailable',
-          });
-        } else {
-          results.push({ name: 'Postgres', status: 'degraded', note: 'container started but health check timed out' });
-        }
-      } else {
-        results.push({ name: 'Postgres', status: 'error', note: pgStart.note });
-      }
-    } else {
-      const pgvector = checkPgvectorEnabled();
-      results.push({
-        name: 'Postgres',
-        url: `postgresql://127.0.0.1:${CONSTRUCT_PG_PORT}/construct`,
-        status: 'reused',
-        note: pgvector ? 'pgvector enabled' : 'pgvector not installed',
-      });
-    }
-  } else if (wants('postgres') && databaseUrl) {
-    results.push({ name: 'Postgres', url: databaseUrl, status: 'configured', note: 'external database' });
-  }
 
   // Dashboard
   if (wants('dashboard')) {
     const dashboard = await startDashboardFn({ rootDir, homeDir, preferredPort: ports.dashboard });
-    results.push({
-      name: 'Dashboard',
-      url: dashboard.url,
-      status: dashboard.reused ? 'reused' : 'started',
-    });
+    results.push(dashboard.failed
+      ? { name: 'Dashboard', status: 'failed', note: `${dashboard.error} — see ${dashboard.logPath}` }
+      : { name: 'Dashboard', url: dashboard.url, status: dashboard.reused ? 'reused' : 'started' });
   }
 
   const telemetryUrl = liveEnv.CONSTRUCT_TELEMETRY_URL ?? '';
   const traceBackend = resolveTraceBackend(liveEnv);
   if (wants('telemetry')) {
-  if (traceBackend === 'local') {
-    results.push({
-      name: 'Telemetry',
-      url: path.join(rootDir, '.cx', 'traces'),
-      status: 'configured',
-      note: 'local JSONL traces; remote export not configured',
-    });
-  } else if (traceBackend === 'none') {
-    results.push({
-      name: 'Telemetry',
-      url: path.join(rootDir, '.cx', 'traces'),
-      status: 'configured',
-      note: 'remote export disabled; local JSONL traces preserved',
-    });
-  } else if (traceBackend === 'otel') {
-    const endpoint = liveEnv.CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT || '';
-    results.push({
-      name: 'Telemetry',
-      url: endpoint || undefined,
-      status: endpoint ? 'configured' : 'unavailable',
-      note: endpoint ? `OTLP export (${telemetryProviderLabel(liveEnv)})` : 'CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT not set',
-    });
-  } else if (telemetryUrl && (isRemoteTelemetry(telemetryUrl) || traceBackend === 'langfuse' || traceBackend === 'http')) {
-    results.push({
-      name: 'Telemetry',
-      url: telemetryUrl,
-      status: 'configured',
-      note: `${telemetryProviderLabel(liveEnv)} export — ${telemetryUrl}`,
-    });
-  } else {
-    results.push({ name: 'Telemetry', status: 'unavailable', note: 'remote export requested but endpoint is not configured' });
-  }
+    if (traceBackend === 'local') {
+      results.push({
+        name: 'Telemetry',
+        url: path.join(rootDir, '.cx', 'traces'),
+        status: 'configured',
+        note: 'local JSONL traces; remote export not configured',
+      });
+    } else if (traceBackend === 'none') {
+      results.push({
+        name: 'Telemetry',
+        url: path.join(rootDir, '.cx', 'traces'),
+        status: 'configured',
+        note: 'remote export disabled; local JSONL traces preserved',
+      });
+    } else if (traceBackend === 'otel') {
+      const endpoint = liveEnv.CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT || '';
+      results.push({
+        name: 'Telemetry',
+        url: endpoint || undefined,
+        status: endpoint ? 'configured' : 'unavailable',
+        note: endpoint ? `OTLP export (${telemetryProviderLabel(liveEnv)})` : 'CONSTRUCT_OTEL_EXPORTER_OTLP_ENDPOINT not set',
+      });
+    } else if (telemetryUrl && (traceBackend === 'langfuse' || traceBackend === 'http')) {
+      results.push({
+        name: 'Telemetry',
+        url: telemetryUrl,
+        status: 'configured',
+        note: `${telemetryProviderLabel(liveEnv)} export — ${telemetryUrl}`,
+      });
+    } else {
+      results.push({ name: 'Telemetry', status: 'unavailable', note: 'remote export requested but endpoint is not configured' });
+    }
   }
 
   // Memory (cm)
@@ -625,9 +457,6 @@ export async function startServices({
   };
 }
 
-// Surface service probe failures into the role-framework event bus so cx-sre
-// can be invoked when a critical service is down. Non-blocking, best effort.
-
 async function emitServiceFailures(results) {
   if (process.env.CONSTRUCT_ROLES === 'off') return;
   const failed = results.filter((r) => r.status === 'error');
@@ -645,17 +474,9 @@ async function emitServiceFailures(results) {
   } catch { /* best effort */ }
 }
 
-// Exported for testing only
-export { verifyTelemetryKeys as _verifyTelemetryKeys, pruneStashDir as _pruneStashDir };
-
-/**
- * Kill every process listening on a given TCP port (best-effort, non-fatal).
- * Returns true if at least one PID was killed.
- */
 function killPortOwners(port, spawnSyncFn = spawnSync) {
   if (!port || !Number.isInteger(port) || port <= 0) return false;
   try {
-    // lsof works on macOS and Linux; -t returns just PIDs
     const result = spawnSyncFn('lsof', ['-t', `-i:${port}`], { encoding: 'utf8' });
     const pids = (result.stdout || '').trim().split(/\s+/).filter(Boolean).map(Number).filter((n) => n > 0);
     if (pids.length === 0) return false;
@@ -670,21 +491,10 @@ function killPortOwners(port, spawnSyncFn = spawnSync) {
 
 export async function stopServices({
   homeDir = os.homedir(),
-  rootDir,
   spawnSyncFn = spawnSync,
-  detectDockerComposeFn = detectDockerCompose,
 } = {}) {
   const results = [];
 
-  // Stash construct Postgres data before any container is stopped so data
-  // survives Docker restarts and machine reboots.
-  const constructDbStash = stashConstructDb({ homeDir, spawnSyncFn });
-
-  // Construct Postgres
-  const pgStop = stopConstructPostgres({ rootDir, homeDir, spawnSyncFn, detectDockerComposeFn });
-  results.push({ name: 'Postgres', status: pgStop.status });
-
-  // Doctor (L0 daemon)
   const doctor = stopDoctor(homeDir);
   if (doctor.stopped) {
     results.push({ name: 'Doctor', status: 'stopped', note: `pid ${doctor.pid}` });
@@ -692,7 +502,6 @@ export async function stopServices({
     results.push({ name: 'Doctor', status: 'cleaned', note: 'stale state file removed' });
   }
 
-  // Dashboard
   const dashboard = stopDashboard(homeDir);
   if (dashboard.stopped) {
     results.push({ name: 'Dashboard', status: 'stopped', note: `pid ${dashboard.pid}, port ${dashboard.port}` });
@@ -702,18 +511,16 @@ export async function stopServices({
     results.push({ name: 'Dashboard', status: 'not-running' });
   }
 
-  // Memory (cm) — find port from config.env or fall back to default
   const envPath = getUserEnvPath(homeDir);
   const envValues = parseEnvFile(envPath);
-  const memoryPort = Number(envValues.MEMORY_PORT) || 8765;
+  const memoryPort = Number(envValues.MEMORY_PORT) || derivedMemoryPort();
   const cmKilled = killPortOwners(memoryPort, spawnSyncFn);
   results.push({ name: 'Memory (cm)', status: cmKilled ? 'stopped' : 'not-running' });
 
-  // OpenCode — find port from config.env or fall back to default
   const bridgePort = Number(envValues.BRIDGE_PORT) || 5173;
   const openCodeKilled = killPortOwners(bridgePort, spawnSyncFn);
   results.push({ name: 'OpenCode', status: openCodeKilled ? 'stopped' : 'not-running' });
 
   const stopped = results.filter((r) => r.status === 'stopped' || r.status === 'cleaned').map((r) => r.name);
-  return { stopped, results, constructDbStash };
+  return { stopped, results };
 }

package/lib/setup-prompts.mjs

@@ -29,6 +29,7 @@ export async function consentToInstall({
   alreadyConfigured = false,
   alreadyConfiguredNote = '',
   envPath,
+  question = '',
   defaultYes = true,
   readlineModule = readline,
   stdin = process.stdin,
@@ -64,7 +65,7 @@ export async function consentToInstall({
   }
 
   const answer = await promptYesNo({
-    question: `Install local ${name} via Docker?`,
+    question: question || `Install local ${name} via Docker?`,
     defaultYes,
     readlineModule,
     stdin,