// Starts local development processes, reuses ones that are already running and // stops everything it started when one of them exits. import { spawn } from 'node:child_process'; import { setTimeout as delay } from 'node:timers/promises'; /** * Loads the private settings: .env.local on the operator's machine, or the file a container is * given (WF_LOCAL_ENV_FILE), which holds only what that container's services need. */ export function loadLocalEnvironment(file = process.env.WF_LOCAL_ENV_FILE || '.env.local') { try { process.loadEnvFile(file); } catch { throw new Error(`${file} is missing; run npm run setup:local first`); } if (process.env.WF_DEPLOYMENT_MODE !== 'development') throw new Error('Local services need WF_DEPLOYMENT_MODE=development in .env.local; run npm run setup:local'); } const LOOPBACK = ['127.0.0.1', 'localhost', '::1']; /** * Where the web console listens, and the address its readiness is checked at. Only the production * build may listen beyond loopback, and only with local sign-in: the development server hands any * visitor its source maps and hot-reload channel. */ export function webListener(env = process.env) { const host = env.WF_WEB_HOST || '127.0.0.1'; const port = Number(env.WF_WEB_PORT || 3000); if (!Number.isSafeInteger(port) || port < 1 || port > 65535) throw new Error('WF_WEB_PORT must be a TCP port.'); if (!LOOPBACK.includes(host)) { if (env.WF_LOCAL_ACCESS !== 'true') throw new Error('A web listener beyond loopback requires local sign-in (WF_LOCAL_ACCESS=true).'); if (env.WF_WEB_SERVE_MODE !== 'production') throw new Error( 'Only the production web build may listen beyond loopback: run npm run local:build and set WF_WEB_SERVE_MODE=production.', ); } // A wildcard listener answers on loopback; one bound to a single address only there. const probe = ['0.0.0.0', '::'].includes(host) ? '127.0.0.1' : host.includes(':') ? `[${host}]` : host; return { host, port, probe }; } const inherited = () => Object.fromEntries( // Proxy variables in both spellings: macOS proxy tools usually export the lowercase ones. [ 'PATH', 'HOME', 'TMPDIR', 'LANG', 'TERM', 'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy', ] .filter(key => process.env[key]) .map(key => [key, process.env[key]]), ); /** * The ports of this machine's WishForge services, from their configured addresses: sandboxed host * checks may never reach them, even when they may use loopback (WF_HOST_CHECK_BLOCKED_PORTS). * Temporal's web interface (8233) is included; it can stop workflows like Temporal itself. */ export function platformPorts(env = process.env) { const ports = new Set([8233, Number(env.WF_WEB_PORT || 3000), Number(env.WF_GIT_PORT || 4504)]); const addresses = [ env.WF_API_URL, env.WF_CONTROL_PLANE_URL, env.DATABASE_URL, env.S3_ENDPOINT, env.WF_PROVISIONER_URL, env.WF_GIT_SERVICE_URL, env.TEMPORAL_ADDRESS && `grpc://${env.TEMPORAL_ADDRESS}`, ]; for (const address of addresses.filter(Boolean)) { try { const url = new URL(address.trim()); const port = Number(url.port || { 'http:': 80, 'https:': 443 }[url.protocol]); if (port) ports.add(port); } catch { // Not an address; nothing to block. } } for (const port of (env.WF_HOST_CHECK_BLOCKED_PORTS ?? '').split(',')) if (port.trim()) ports.add(Number(port)); return [...ports].filter(port => Number.isInteger(port) && port > 0 && port < 65536).sort((a, b) => a - b); } /** * The services this process starts: all of them, or those WF_LOCAL_SERVICES names (separated by * commas), where they run in separate containers of one Pod. An unknown name is an error. */ export function selectServices(services, env = process.env) { const wanted = (env.WF_LOCAL_SERVICES ?? '') .split(',') .map(name => name.trim()) .filter(Boolean); if (!wanted.length) return services; const known = new Set(services.map(service => service.name)); const unknown = wanted.filter(name => !known.has(name)); if (unknown.length) throw new Error(`WF_LOCAL_SERVICES names unknown services: ${unknown.join(', ')}`); return services.filter(service => wanted.includes(service.name)); } /** Each process sees only the settings matching its patterns, plus the deployment mode. */ export function environment(patterns, extra = {}) { return { ...inherited(), ...Object.fromEntries(Object.entries(process.env).filter(([key]) => patterns.some(pattern => pattern.test(key)))), WF_DEPLOYMENT_MODE: 'development', NODE_ENV: 'development', ...extra, }; } async function healthy(service) { try { const response = await fetch(service.url, { signal: AbortSignal.timeout(1000) }); if (!response.ok) return false; if (!service.identity) return true; return (await response.json()).service === service.identity; } catch { return false; } } /** * SIGTERM to a service's process group, so whatever it spawned stops with it; SIGKILL to what * remains of the group once the service exits or `graceMs` passes. */ function stopGroup(child, graceMs) { const signal = name => { try { process.kill(-child.pid, name); } catch { /* The group has no processes left. */ } }; return new Promise(resolve => { const done = () => { clearTimeout(timer); signal('SIGKILL'); resolve(); }; const timer = setTimeout(done, graceMs); if (child.exitCode !== null || child.signalCode !== null) return done(); child.once('exit', done); signal('SIGTERM'); }); } /** * `url` is a readiness check; a service that answers there already is reused, unless `reuse` * is false, as under the LaunchAgent supervisor, where it may be a leftover running old code. * Services without one (Temporal workers) count as ready once they stay up for a moment. Each * service runs in its own process group; stopping waits until every group is gone, within the * supervisor's 20 seconds. */ export async function startServices(services, banner, { reuse = true, graceMs = 10_000 } = {}) { const children = []; let stopping; const stop = (code = 0) => (stopping ??= (async () => { process.exitCode = code; await Promise.all(children.map(child => stopGroup(child, graceMs))); })()); for (const signal of ['SIGINT', 'SIGTERM']) process.once(signal, () => void stop()); for (const service of services) { if (stopping) return { stop }; if (service.url && (await healthy(service))) { if (!reuse) { await stop(1); throw new Error( `${service.name}: ${service.url} already answers; stop that process before starting these services.`, ); } console.log(`${service.name}: reusing the service already running at ${service.url}`); continue; } const child = spawn(process.execPath, service.args, { cwd: service.cwd, env: service.env, stdio: ['ignore', 'pipe', 'pipe'], detached: true, }); children.push(child); for (const output of [child.stdout, child.stderr]) output.on('data', bytes => String(bytes) .split('\n') .filter(Boolean) .forEach(line => console.log(`[${service.name}] ${line}`)), ); child.once('exit', code => { if (!stopping) { console.error(`${service.name} exited (${code}); stopping the services this command started.`); void stop(code || 1); } }); let ready = false; for (let attempt = 0; attempt < (service.url ? 90 : 2) && !stopping; attempt++) { if (service.url && (await healthy(service))) { ready = true; break; } await delay(1000); } if (!service.url && !stopping) ready = true; if (!ready) { await stop(1); throw new Error(`${service.name} did not become ready; check its output above.`); } } console.log(banner); if (!children.length) console.log('Every service was already running; nothing was started.'); return { stop }; }