everything-dev 1.7.2 → 1.8.1

package/src/orchestrator.ts

@@ -1,20 +1,14 @@
 import { createConnection } from "node:net";
-import { Deferred, Effect, Fiber, Ref } from "effect";
-import { getHostDevelopmentPort, getProjectRoot, parsePort } from "./config";
+import { Command } from "@effect/platform";
+import type { ExitCode } from "@effect/platform/CommandExecutor";
+import { Deferred, Effect, Option, Ref, Stream } from "effect";
 import { patchManifestFetchForSsrPublicPath } from "./mf";
-import type { ProcessRegistry } from "./process-registry";
-import type { BosConfig, RuntimeConfig } from "./types";
-
-export interface DevProcess {
-  name: string;
-  command: string;
-  args: string[];
-  cwd: string;
-  env?: Record<string, string>;
-  port: number;
-  readyPatterns: RegExp[];
-  errorPatterns: RegExp[];
-}
+import {
+  DevRuntimeConfig,
+  type ServiceDescriptor,
+  ServiceDescriptorMap,
+} from "./service-descriptor";
+import type { RuntimeConfig } from "./types";
 
 export interface ProcessCallbacks {
   onStatus: (name: string, status: ProcessStatus, message?: string) => void;
@@ -26,148 +20,17 @@ export interface ProcessHandle {
   pid: number | undefined;
   kill: Effect.Effect<void, unknown>;
   waitForReady: Effect.Effect<void, Error>;
-  waitForExit: Effect.Effect<unknown>;
+  waitForExit: Effect.Effect<ExitCode, unknown>;
 }
 
 export type ProcessStatus = "pending" | "starting" | "ready" | "error";
 
-interface ProcessConfigBase {
+export interface ProcessState {
   name: string;
-  command: string;
-  args: string[];
-  cwd: string;
-  readyPatterns: RegExp[];
-  errorPatterns: RegExp[];
-}
-
-const processConfigBases: Record<string, ProcessConfigBase> = {
-  "host-build": {
-    name: "host-build",
-    command: "bun",
-    args: ["run", "build"],
-    cwd: "host",
-    readyPatterns: [/built in/i, /compiled.*successfully/i],
-    errorPatterns: [/error:/i, /failed/i, /exception/i],
-  },
-  host: {
-    name: "host",
-    command: "bun",
-    args: ["run", "dev"],
-    cwd: "host",
-    readyPatterns: [/Host (dev|production) server running at/i, /Server running at/i],
-    errorPatterns: [/error:/i, /failed/i, /exception/i],
-  },
-  ui: {
-    name: "ui",
-    command: "bun",
-    args: ["run", "dev"],
-    cwd: "ui",
-    readyPatterns: [/\bready\s+built in\b/i, /\bLocal:\b/i, /\bcompiled\b.*successfully/i],
-    errorPatterns: [/error/i, /failed to compile/i],
-  },
-  "ui-ssr": {
-    name: "ui-ssr",
-    command: "bun",
-    args: ["run", "dev:ssr"],
-    cwd: "ui",
-    readyPatterns: [/\bready\s+built in\b/i, /\bcompiled\b.*successfully/i],
-    errorPatterns: [/error/i, /failed/i],
-  },
-  api: {
-    name: "api",
-    command: "bun",
-    args: ["run", "dev"],
-    cwd: "api",
-    readyPatterns: [/ready in/i, /compiled.*successfully/i, /listening/i, /started/i],
-    errorPatterns: [/error/i, /failed/i],
-  },
-};
-
-export function getProcessConfig(
-  pkg: string,
-  env?: Record<string, string>,
-  portOverride?: number,
-  bosConfig?: BosConfig,
-  runtimeConfig?: RuntimeConfig,
-): DevProcess | null {
-  if (pkg === "auth") {
-    const authConfig = runtimeConfig?.auth;
-    if (!authConfig?.localPath || authConfig.source !== "local") return null;
-
-    const port =
-      portOverride ?? authConfig.port ?? (authConfig.url ? parsePort(authConfig.url) : 3020);
-
-    return {
-      name: "auth",
-      command: "bun",
-      args: ["run", "dev"],
-      cwd: authConfig.localPath,
-      port,
-      readyPatterns: [/ready in/i, /compiled.*successfully/i, /listening/i, /started/i],
-      errorPatterns: [/error/i, /failed/i],
-      env,
-    };
-  }
-
-  if (pkg.startsWith("plugin:")) {
-    const pluginId = pkg.slice("plugin:".length);
-    const pluginConfig = runtimeConfig?.plugins?.[pluginId] ?? null;
-    const localPath = pluginConfig?.localPath;
-
-    if (!localPath || pluginConfig?.source !== "local") return null;
-
-    const port =
-      portOverride ?? pluginConfig?.port ?? (pluginConfig?.url ? parsePort(pluginConfig.url) : 0);
-
-    return {
-      name: pkg,
-      command: "bun",
-      args: ["run", "dev"],
-      cwd: localPath,
-      port,
-      readyPatterns: [/ready in/i, /compiled.*successfully/i, /listening/i, /started/i],
-      errorPatterns: [/error/i, /failed/i],
-      env,
-    };
-  }
-
-  const base = processConfigBases[pkg];
-  if (!base) return null;
-
-  let port: number;
-  if (pkg === "host") {
-    port =
-      portOverride ??
-      (runtimeConfig?.hostUrl
-        ? parsePort(runtimeConfig.hostUrl)
-        : bosConfig
-          ? getHostDevelopmentPort(bosConfig.app.host.development)
-          : 3000);
-  } else if (pkg === "ui") {
-    port =
-      runtimeConfig?.ui.port ?? (runtimeConfig?.ui.url ? parsePort(runtimeConfig.ui.url) : 3002);
-  } else if (pkg === "ui-ssr") {
-    const uiPort = runtimeConfig?.ui.ssrUrl
-      ? parsePort(runtimeConfig.ui.ssrUrl)
-      : runtimeConfig?.ui.port
-        ? runtimeConfig.ui.port + 1
-        : 3003;
-    port = uiPort;
-  } else if (pkg === "api") {
-    port =
-      runtimeConfig?.api.port ?? (runtimeConfig?.api.url ? parsePort(runtimeConfig.api.url) : 3014);
-  } else {
-    port = 0;
-  }
-
-  const cwd =
-    pkg === "ui"
-      ? (runtimeConfig?.ui.localPath ?? base.cwd)
-      : pkg === "api"
-        ? (runtimeConfig?.api.localPath ?? base.cwd)
-        : base.cwd;
-
-  return { ...base, cwd, port, env };
+  status: ProcessStatus;
+  port: number;
+  message?: string;
+  source?: "local" | "remote";
 }
 
 const stripAnsi = (input: string): string => {
@@ -178,49 +41,54 @@ const stripAnsi = (input: string): string => {
     .replace(new RegExp(`${ESC}\\[[0-?]*[ -/]*[@-~]`, "g"), "");
 };
 
-const probeHttpOk = async (url: string, timeoutMs = 400): Promise<boolean> => {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const res = await fetch(url, { signal: controller.signal });
-    return res.ok;
-  } catch {
-    return false;
-  } finally {
-    clearTimeout(timer);
-  }
-};
+const probeHttpOk = (url: string, timeoutMs = 400) =>
+  Effect.tryPromise({
+    try: async () => {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const res = await fetch(url, { signal: controller.signal });
+        return res.ok;
+      } catch {
+        return false;
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+    catch: () => false,
+  });
 
-const probeTcpOpen = async (port: number, timeoutMs = 250): Promise<boolean> => {
-  return new Promise((resolve) => {
+const probeTcpOpen = (port: number, timeoutMs = 250) =>
+  Effect.async<boolean>((resume) => {
     const socket = createConnection({ host: "127.0.0.1", port });
     const timer = setTimeout(() => {
       socket.destroy();
-      resolve(false);
+      resume(Effect.succeed(false));
     }, timeoutMs);
     socket.once("connect", () => {
       clearTimeout(timer);
       socket.destroy();
-      resolve(true);
+      resume(Effect.succeed(true));
     });
     socket.once("error", () => {
       clearTimeout(timer);
-      resolve(false);
+      resume(Effect.succeed(false));
     });
   });
-};
 
 const detectStatus = (
   line: string,
-  config: DevProcess,
+  descriptor: ServiceDescriptor,
 ): { status: ProcessStatus; isError: boolean } | null => {
   const cleanLine = stripAnsi(line);
-  for (const pattern of config.errorPatterns) {
+  const errorPatterns = descriptor.errorPatterns ?? [];
+  const readyPatterns = descriptor.readyPatterns ?? [];
+  for (const pattern of errorPatterns) {
     if (pattern.test(cleanLine)) {
       return { status: "error", isError: true };
     }
   }
-  for (const pattern of config.readyPatterns) {
+  for (const pattern of readyPatterns) {
     if (pattern.test(cleanLine)) {
       return { status: "ready", isError: false };
     }
@@ -228,46 +96,6 @@ const detectStatus = (
   return null;
 };
 
-const killProcessTree = (pid: number) =>
-  Effect.gen(function* () {
-    const killSignal = (signal: NodeJS.Signals) =>
-      Effect.try({
-        try: () => {
-          process.kill(-pid, signal);
-        },
-        catch: () => null,
-      }).pipe(Effect.ignore);
-
-    const killDirect = (signal: NodeJS.Signals) =>
-      Effect.try({
-        try: () => {
-          process.kill(pid, signal);
-        },
-        catch: () => null,
-      }).pipe(Effect.ignore);
-
-    const isRunning = () =>
-      Effect.try({
-        try: () => {
-          process.kill(pid, 0);
-          return true;
-        },
-        catch: () => false,
-      });
-
-    yield* killSignal("SIGTERM");
-    yield* killDirect("SIGTERM");
-
-    yield* Effect.sleep("200 millis");
-
-    const stillRunning = yield* isRunning();
-    if (stillRunning) {
-      yield* killSignal("SIGKILL");
-      yield* killDirect("SIGKILL");
-      yield* Effect.sleep("100 millis");
-    }
-  });
-
 interface ServerHandle {
   ready: Promise<void>;
   shutdown: () => Promise<void>;
@@ -310,27 +138,18 @@ const patchConsole = (name: string, callbacks: ProcessCallbacks): (() => void) =
   };
 };
 
-export const spawnRemoteHost = (
-  config: DevProcess,
-  callbacks: ProcessCallbacks,
-  runtimeConfig: RuntimeConfig,
-) =>
+const spawnRemoteHost = (descriptor: ServiceDescriptor, callbacks: ProcessCallbacks) =>
   Effect.gen(function* () {
-    const remoteUrl = config.env?.HOST_REMOTE_URL;
+    const runtimeConfig = yield* DevRuntimeConfig;
+    const remoteUrl = descriptor.remoteUrl;
     if (!remoteUrl) {
-      return yield* Effect.fail(new Error("HOST_REMOTE_URL not provided for remote host"));
+      return yield* Effect.fail(new Error("remoteUrl not provided on host descriptor"));
     }
 
-    if (config.env) {
-      for (const [key, value] of Object.entries(config.env)) {
-        process.env[key] = value;
-      }
-    }
-
-    callbacks.onStatus(config.name, "starting");
-    callbacks.onLog(config.name, `Remote: ${remoteUrl}`);
-    const restoreConsole = patchConsole(config.name, callbacks);
-    callbacks.onLog(config.name, "Loading Module Federation runtime...");
+    callbacks.onStatus(descriptor.key, "starting");
+    callbacks.onLog(descriptor.key, `Remote: ${remoteUrl}`);
+    const restoreConsole = patchConsole(descriptor.key, callbacks);
+    callbacks.onLog(descriptor.key, "Loading Module Federation runtime...");
 
     const mfRuntime = yield* Effect.tryPromise({
       try: () => import("@module-federation/enhanced/runtime"),
@@ -378,7 +197,7 @@ export const spawnRemoteHost = (
     });
 
     (mf as any).registerRemotes([{ name: "host", entry: entryUrl }]);
-    callbacks.onLog(config.name, `Loading host from ${entryUrl}...`);
+    callbacks.onLog(descriptor.key, `Loading host from ${entryUrl}...`);
 
     const hostModule = yield* Effect.tryPromise({
       try: () =>
@@ -392,20 +211,20 @@ export const spawnRemoteHost = (
       return yield* Effect.fail(new Error("Host module does not export runServer function"));
     }
 
-    callbacks.onLog(config.name, "Starting server...");
+    callbacks.onLog(descriptor.key, "Starting server...");
     const serverHandle = hostModule.runServer({ config: runtimeConfig });
     yield* Effect.tryPromise({
       try: () => serverHandle.ready,
       catch: (e) => new Error(`Server failed to start: ${e}`),
     });
 
-    callbacks.onStatus(config.name, "ready");
+    callbacks.onStatus(descriptor.key, "ready");
 
     return {
-      name: config.name,
+      name: descriptor.key,
       pid: process.pid,
       kill: Effect.gen(function* () {
-        callbacks.onLog(config.name, "Shutting down remote host...");
+        callbacks.onLog(descriptor.key, "Shutting down remote host...");
         restoreConsole();
         yield* Effect.tryPromise({
           try: () => serverHandle.shutdown(),
@@ -417,55 +236,53 @@ export const spawnRemoteHost = (
     } satisfies ProcessHandle;
   });
 
-export const spawnDevProcess = (
-  config: DevProcess,
-  callbacks: ProcessCallbacks,
-  runtimeConfig?: RuntimeConfig,
-  registry?: ProcessRegistry,
-) =>
+const spawnDevProcess = (descriptor: ServiceDescriptor, callbacks: ProcessCallbacks) =>
   Effect.gen(function* () {
-    let configDir: string;
-    try {
-      configDir = getProjectRoot();
-    } catch {
-      configDir = process.cwd();
+    const runtimeConfig = yield* DevRuntimeConfig;
+
+    if (!descriptor.localPath) {
+      return yield* Effect.fail(new Error(`No localPath for local service: ${descriptor.key}`));
     }
-    const fullCwd = config.cwd.startsWith("/") ? config.cwd : `${configDir}/${config.cwd}`;
+
+    const fullCwd = descriptor.localPath;
+    const command = descriptor.command ?? "bun";
+    const args = descriptor.args ?? ["run", "dev"];
+    const port = descriptor.port ?? descriptor.defaultPort;
+    const name = descriptor.key;
+
     const readyDeferred = yield* Deferred.make<void, Error>();
     const statusRef = yield* Ref.make<ProcessStatus>("starting");
 
-    callbacks.onStatus(config.name, "starting");
+    callbacks.onStatus(name, "starting");
 
     const envVars: Record<string, string> = {
       ...(process.env as Record<string, string>),
-      ...config.env,
       FORCE_COLOR: "1",
-      ...(config.port > 0 ? { PORT: String(config.port) } : {}),
+      ...(port > 0 ? { PORT: String(port) } : {}),
     };
 
-    if (runtimeConfig && config.name === "host") {
+    if (name === "host") {
       envVars.BOS_RUNTIME_CONFIG = JSON.stringify(runtimeConfig);
     }
 
-    const proc = Bun.spawn({
-      cmd: [config.command, ...config.args],
-      cwd: fullCwd,
-      env: envVars,
-      stdio: ["inherit", "pipe", "pipe"],
-    });
+    const cmd = Command.make(command, ...args).pipe(
+      Command.workingDirectory(fullCwd),
+      Command.env(envVars),
+    );
+
+    const proc = yield* Command.start(cmd);
 
     const markReady = Effect.gen(function* () {
       const currentStatus = yield* Ref.get(statusRef);
       if (currentStatus === "ready" || currentStatus === "error") return;
       yield* Ref.set(statusRef, "ready");
-      callbacks.onStatus(config.name, "ready");
+      callbacks.onStatus(name, "ready");
       yield* Deferred.succeed(readyDeferred, undefined).pipe(Effect.ignore);
     });
 
-    if (config.port > 0) {
-      const readinessPath =
-        config.name === "host" ? "/health" : config.name === "ui-ssr" ? "/" : "/remoteEntry.js";
-      const url = `http://127.0.0.1:${config.port}${readinessPath}`;
+    if (port > 0) {
+      const readinessPath = descriptor.readinessPath;
+      const url = `http://127.0.0.1:${port}${readinessPath}`;
 
       yield* Effect.forkScoped(
         Effect.gen(function* () {
@@ -473,74 +290,61 @@ export const spawnDevProcess = (
           while (Date.now() < deadline) {
             const status = yield* Ref.get(statusRef);
             if (status === "ready" || status === "error") return;
-            const ok = url
-              ? yield* Effect.tryPromise({
-                  try: () => probeHttpOk(url),
-                  catch: () => false,
-                })
-              : yield* Effect.tryPromise({
-                  try: () => probeTcpOpen(config.port),
-                  catch: () => false,
-                });
+            const ok = yield* probeHttpOk(url);
             if (ok) {
               yield* markReady;
               return;
             }
+            const tcpOk = yield* probeTcpOpen(port);
+            if (tcpOk) {
+              yield* markReady;
+              return;
+            }
             yield* Effect.sleep("200 millis");
           }
         }),
       );
     }
 
-    if (registry && proc.pid) {
-      yield* registry.track({
-        pid: proc.pid,
-        name: config.name,
-        port: config.port,
-        startedAt: Date.now(),
-        command: [config.command, ...config.args].join(" "),
-      });
-    }
+    const pid = Number(proc.pid);
 
     yield* Effect.forkScoped(
-      Effect.promise(() => proc.exited).pipe(
-        Effect.andThen((code) =>
-          Effect.gen(function* () {
-            if (registry && proc.pid) {
-              yield* registry.untrack(proc.pid).pipe(Effect.ignore);
-            }
-            const currentStatus = yield* Ref.get(statusRef);
-            if (currentStatus === "ready") return;
-            callbacks.onLog(config.name, `Process exited before ready (exit code: ${code})`, true);
-            yield* Ref.set(statusRef, "error");
-            callbacks.onStatus(config.name, "error");
-            yield* Deferred.fail(
-              readyDeferred,
-              new Error(`Process exited before ready: ${config.name}`),
-            ).pipe(Effect.ignore);
-          }),
-        ),
-      ),
+      Effect.gen(function* () {
+        const exitCode = yield* proc.exitCode;
+        const currentStatus = yield* Ref.get(statusRef);
+        if (currentStatus === "ready") return;
+        callbacks.onLog(name, `Process exited before ready (exit code: ${exitCode})`, true);
+        yield* Ref.set(statusRef, "error");
+        callbacks.onStatus(name, "error");
+        yield* Deferred.fail(readyDeferred, new Error(`Process exited before ready: ${name}`)).pipe(
+          Effect.ignore,
+        );
+      }),
     );
 
     const handleLine = (line: string, isStderr: boolean) =>
       Effect.gen(function* () {
         if (!line.trim()) return;
 
-        callbacks.onLog(config.name, line, isStderr);
+        const cleanLine = stripAnsi(line);
+        const looksLikeError =
+          isStderr &&
+          /^(error|fail|fatal|exception|unhandled|reject)/i.test(cleanLine) &&
+          !/^\$/.test(cleanLine);
+        callbacks.onLog(name, line, looksLikeError);
 
         const currentStatus = yield* Ref.get(statusRef);
         if (currentStatus === "ready") return;
 
-        const detected = detectStatus(line, config);
+        const detected = detectStatus(line, descriptor);
         if (detected) {
           yield* Ref.set(statusRef, detected.status);
-          callbacks.onStatus(config.name, detected.status);
+          callbacks.onStatus(name, detected.status);
           if (detected.status === "ready" || detected.status === "error") {
             if (detected.status === "ready") {
               yield* Deferred.succeed(readyDeferred, undefined).pipe(Effect.ignore);
             } else {
-              yield* Deferred.fail(readyDeferred, new Error(`Process failed: ${config.name}`)).pipe(
+              yield* Deferred.fail(readyDeferred, new Error(`Process failed: ${name}`)).pipe(
                 Effect.ignore,
               );
             }
@@ -548,131 +352,148 @@ export const spawnDevProcess = (
         }
       });
 
-    const decoder = new TextDecoder();
+    yield* Effect.forkScoped(
+      Stream.runForEach((line: string) => handleLine(line, false))(
+        Stream.splitLines(Stream.decodeText(proc.stdout, "utf-8")),
+      ),
+    );
+
+    yield* Effect.forkScoped(
+      Stream.runForEach((line: string) => handleLine(line, true))(
+        Stream.splitLines(Stream.decodeText(proc.stderr, "utf-8")),
+      ),
+    );
 
-    const stdoutFiber = yield* Effect.forkScoped(
-      Effect.async<void>((resume) => {
-        if (!proc.stdout) {
-          resume(Effect.void);
-          return;
+    return {
+      name,
+      pid,
+      kill: Effect.gen(function* () {
+        const result = yield* proc.kill("SIGTERM").pipe(Effect.timeout("3 seconds"), Effect.option);
+        if (Option.isNone(result)) {
+          const pid = Number(proc.pid);
+          yield* Effect.try(() => process.kill(-pid, "SIGKILL")).pipe(Effect.ignore);
+          yield* Effect.sleep("250 millis");
         }
-        const reader = proc.stdout.getReader();
-        let buffer = "";
-        let active = true;
-
-        const pump = (): Promise<void> =>
-          reader.read().then(({ done, value }) => {
-            if (!active) return;
-            if (done) {
-              if (buffer) Effect.runSync(handleLine(buffer, false));
-              return;
-            }
-            buffer += decoder
-              .decode(value, { stream: true })
-              .replace(/\r\n/g, "\n")
-              .replace(/\r/g, "\n");
-            const lines = buffer.split("\n");
-            buffer = lines.pop() ?? "";
-            for (const line of lines) {
-              Effect.runSync(handleLine(line, false));
-            }
-            return pump();
-          });
+      }).pipe(Effect.ignore),
+      waitForReady: Deferred.await(readyDeferred),
+      waitForExit: proc.exitCode,
+    } satisfies ProcessHandle;
+  });
 
-        pump().then(() => {
-          if (active) resume(Effect.void);
-        });
+const spawnRemoteProbe = (
+  pkg: string,
+  descriptor: ServiceDescriptor,
+  callbacks: ProcessCallbacks,
+) =>
+  Effect.gen(function* () {
+    callbacks.onStatus(pkg, "starting");
+    const readyDeferred = yield* Deferred.make<void, Error>();
+    const statusRef = yield* Ref.make<ProcessStatus>("starting");
 
-        return Effect.sync(() => {
-          active = false;
-          reader.cancel();
-        });
-      }),
-    );
+    const markReady = Effect.gen(function* () {
+      yield* Ref.set(statusRef, "ready");
+      yield* Deferred.succeed(readyDeferred, undefined);
+      callbacks.onStatus(pkg, "ready", "loaded");
+    });
 
-    const stderrFiber = yield* Effect.forkScoped(
-      Effect.async<void>((resume) => {
-        if (!proc.stderr) {
-          resume(Effect.void);
-          return;
-        }
-        const reader = proc.stderr.getReader();
-        let buffer = "";
-        let active = true;
-
-        const pump = (): Promise<void> =>
-          reader.read().then(({ done, value }) => {
-            if (!active) return;
-            if (done) {
-              if (buffer) Effect.runSync(handleLine(buffer, true));
-              return;
-            }
-            buffer += decoder
-              .decode(value, { stream: true })
-              .replace(/\r\n/g, "\n")
-              .replace(/\r/g, "\n");
-            const lines = buffer.split("\n");
-            buffer = lines.pop() ?? "";
-            for (const line of lines) {
-              Effect.runSync(handleLine(line, true));
-            }
-            return pump();
-          });
+    const markError = Effect.gen(function* () {
+      yield* Ref.set(statusRef, "error");
+      yield* Deferred.fail(readyDeferred, new Error(`Remote ${pkg} unreachable`));
+      callbacks.onStatus(pkg, "error", "unreachable");
+    });
+
+    const baseUrl = descriptor.url.replace(/\/$/, "");
+    const manifestUrl = `${baseUrl}/mf-manifest.json`;
+    const entryUrl = `${baseUrl}${descriptor.readinessPath}`;
+    const probeUrl = descriptor.readinessPath === "/health" ? `${baseUrl}/health` : manifestUrl;
+
+    yield* Effect.forkScoped(
+      Effect.gen(function* () {
+        const deadline = Date.now() + 60_000;
+        while (Date.now() < deadline) {
+          const status = yield* Ref.get(statusRef);
+          if (status === "ready" || status === "error") return;
+
+          const ok = yield* probeHttpOk(probeUrl, 400);
 
-        pump().then(() => {
-          if (active) resume(Effect.void);
-        });
+          if (ok) {
+            yield* markReady;
+            return;
+          }
 
-        return Effect.sync(() => {
-          active = false;
-          reader.cancel();
-        });
+          const fallbackOk = yield* probeHttpOk(entryUrl, 400);
+
+          if (fallbackOk) {
+            yield* markReady;
+            return;
+          }
+
+          yield* Effect.sleep("500 millis");
+        }
+
+        const status = yield* Ref.get(statusRef);
+        if (status !== "ready") {
+          yield* markError;
+        }
       }),
     );
 
-    const handle: ProcessHandle = {
-      name: config.name,
-      pid: proc.pid,
-      kill: proc.pid
-        ? killProcessTree(proc.pid)
-        : Effect.gen(function* () {
-            proc.kill("SIGTERM");
-            yield* Effect.sleep("100 millis");
-            try {
-              proc.kill("SIGKILL");
-            } catch {}
-          }),
-      waitForReady: Deferred.await(readyDeferred),
-      waitForExit: Effect.gen(function* () {
-        yield* Fiber.joinAll([stdoutFiber, stderrFiber]);
-        return yield* Effect.promise(() => proc.exited);
+    return {
+      name: pkg,
+      pid: undefined,
+      kill: Effect.gen(function* () {
+        yield* Ref.set(statusRef, "error");
+        yield* Deferred.fail(readyDeferred, new Error("Killed")).pipe(Effect.ignore);
       }),
-    };
-
-    return handle;
+      waitForReady: Deferred.await(readyDeferred),
+      waitForExit: Effect.never,
+    } satisfies ProcessHandle;
   });
 
-export const makeDevProcess = (
-  pkg: string,
-  env: Record<string, string> | undefined,
-  callbacks: ProcessCallbacks,
-  portOverride?: number,
-  bosConfig?: BosConfig,
-  runtimeConfig?: RuntimeConfig,
-  registry?: ProcessRegistry,
-) =>
+export const makeDevProcess = (pkg: string, callbacks: ProcessCallbacks, portOverride?: number) =>
   Effect.gen(function* () {
-    const config = getProcessConfig(pkg, env, portOverride, bosConfig, runtimeConfig);
-    if (!config) {
-      return yield* Effect.fail(new Error(`Unknown package: ${pkg}`));
+    const services = yield* ServiceDescriptorMap;
+    const descriptor = services.get(pkg);
+
+    if (!descriptor) {
+      callbacks.onStatus(pkg, "ready", "Remote");
+      return {
+        name: pkg,
+        pid: undefined,
+        kill: Effect.void,
+        waitForReady: Effect.void,
+        waitForExit: Effect.never,
+      } satisfies ProcessHandle;
     }
 
-    if (pkg === "host" && runtimeConfig) {
-      if (env?.HOST_SOURCE === "remote") {
-        return yield* spawnRemoteHost(config, callbacks, runtimeConfig);
-      }
-      return yield* spawnDevProcess(config, callbacks, runtimeConfig, registry);
+    if (pkg === "host" && descriptor.source === "remote") {
+      return yield* spawnRemoteHost(descriptor, callbacks);
+    }
+
+    if (descriptor.source === "remote" || !descriptor.localPath) {
+      return yield* spawnRemoteProbe(pkg, descriptor, callbacks);
     }
 
-    return yield* spawnDevProcess(config, callbacks, runtimeConfig, registry);
+    const resolvedDescriptor = portOverride ? { ...descriptor, port: portOverride } : descriptor;
+
+    return yield* spawnDevProcess(resolvedDescriptor, callbacks);
+  });
+
+export function getProcessStates(
+  packages: string[],
+  services: Map<string, ServiceDescriptor>,
+  portOverride?: number,
+): ProcessState[] {
+  return packages.map((pkg) => {
+    const descriptor = services.get(pkg);
+    return {
+      name: pkg,
+      status: "pending" as const,
+      port:
+        portOverride && pkg === "host"
+          ? portOverride
+          : (descriptor?.port ?? descriptor?.defaultPort ?? 0),
+      source: descriptor?.source,
+    };
   });
+}