@effectstream/orchestrator 0.100.20 → 0.100.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectstream/orchestrator",
-  "version": "0.100.20",
+  "version": "0.100.21",
   "license": "MIT",
   "homepage": "https://effectstream.github.io/docs/",
   "repository": {
@@ -32,7 +32,7 @@
     "start": "bun src/cli.ts start"
   },
   "dependencies": {
-    "@effectstream/db": "0.100.20"
+    "@effectstream/db": "0.100.21"
   },
   "description": "Multi-chain local development environment for EffectStream"
 }

package/scripts/launch-pglite.ts

@@ -8,21 +8,43 @@ export const DbNames = {
   PGLITE_WAIT: "pglite-wait",
 } as const;
 
+/**
+ * Spawns the embedded PGlite database used by e2e suites — unless
+ * `PGLITE=false` is set in the environment, in which case it assumes an
+ * external Postgres is already running on `DB_PORT` (or `port`) and emits a
+ * single wait task that other processes can still depend on via
+ * `DbNames.PGLITE_WAIT`. This keeps the launcher.cli.ts call sites unchanged
+ * while letting e2e_postgres.sh exercise the engine against a real Postgres
+ * (e.g. to verify the pg_ivm-optional fallback path).
+ */
 export function launchPglite(opts?: { port?: number }): ProcessConfig[] {
-  const port = opts?.port ?? 5432;
+  const defaultPort = opts?.port ?? 5432;
+
+  if (process.env.PGLITE === "false") {
+    const externalPort = process.env.DB_PORT ?? String(defaultPort);
+    return [
+      {
+        name: DbNames.PGLITE_WAIT,
+        description: `Wait for external Postgres on port ${externalPort}`,
+        args: [waitTcpScript, String(externalPort)],
+        waitToExit: true,
+      },
+    ];
+  }
+
   return [
     {
       name: DbNames.PGLITE,
-      description: `PGLite embedded database (port ${port})`,
-      args: [startPgliteScript, "--port", String(port)],
-      stopProcessAtPort: [port],
+      description: `PGLite embedded database (port ${defaultPort})`,
+      args: [startPgliteScript, "--port", String(defaultPort)],
+      stopProcessAtPort: [defaultPort],
       waitToExit: false,
       critical: true,
     },
     {
       name: DbNames.PGLITE_WAIT,
-      description: `Wait for PGLite on port ${port}`,
-      args: [waitTcpScript, String(port)],
+      description: `Wait for PGLite on port ${defaultPort}`,
+      args: [waitTcpScript, String(defaultPort)],
       waitToExit: true,
       dependsOn: [DbNames.PGLITE],
     },

package/src/api-server.ts

@@ -31,7 +31,15 @@ export type ApiServerOptions = {
   /** Called when the /shutdown endpoint is hit. */
   onShutdown: () => Promise<void>;
   /** Callback hooks for task events (used by both local and remote starts). */
-  runCallbacks?: Pick<RunOptions, "onTaskStart" | "onTaskRunning" | "onTaskDone" | "onTaskFailed" | "onShutdown">;
+  runCallbacks?: Pick<
+    RunOptions,
+    | "onTaskStart"
+    | "onTaskRunning"
+    | "onTaskDone"
+    | "onTaskFailed"
+    | "onWaitingForExit"
+    | "onShutdown"
+  >;
 };
 
 /**

package/src/commands/start.ts

@@ -17,6 +17,7 @@ import {
   logTaskRunning,
   logTaskDone,
   logTaskFailed,
+  logWaitingForExit,
   logInfo,
   logWarn,
   logError,
@@ -148,6 +149,7 @@ export async function runStartCommand(opts: StartOptions): Promise<void> {
     onTaskRunning: logTaskRunning,
     onTaskDone: logTaskDone,
     onTaskFailed: logTaskFailed,
+    onWaitingForExit: logWaitingForExit,
     onShutdown: undefined as ((reason: string) => void) | undefined,
   };
 

package/src/display.ts

@@ -188,3 +188,11 @@ export function logError(msg: string): void {
 export function logWarn(msg: string): void {
   console.warn(`${c.yellow}⚠${c.reset} ${msg}`);
 }
+
+export function logWaitingForExit(names: string[]): void {
+  const list = names.join(", ");
+  console.log(
+    `${c.gray}…${c.reset} ${c.dim}waiting on${c.reset} ${c.bold}${list}${c.reset}` +
+      `${c.dim}  (see logs/*.log — often midnight-indexer-wait or midnight-contract)${c.reset}`,
+  );
+}

package/src/process-manager.ts

@@ -87,12 +87,26 @@ export class ProcessManager {
     // Otherwise, pipe output so we can suppress silenced processes.
     const usesPipe = typeof outFd !== "number";
 
+    // Build child env. When writing to a file fd, suppress ANSI/TTY noise:
+    //   - Strip FORCE_COLOR (inherited from parent or set by orchestrator) so
+    //     children don't emit color escapes.
+    //   - Set NO_COLOR=1 (broadly respected) and CI=1 to coax bun's
+    //     `--filter` runner out of its live-redraw TTY mode, which would
+    //     otherwise leave cursor-move escapes and "[N lines elided]" in logs.
+    const childEnv: Record<string, string | undefined> = {
+      ...process.env,
+      ...config.env,
+    };
+    if (usesPipe) {
+      childEnv.FORCE_COLOR = "true";
+    } else {
+      delete childEnv.FORCE_COLOR;
+      childEnv.NO_COLOR = "1";
+      childEnv.CI = "1";
+    }
+
     const proc = Bun.spawn([command, ...config.args], {
-      env: {
-        ...process.env,
-        ...config.env,
-        FORCE_COLOR: "true",
-      },
+      env: childEnv,
       cwd: config.cwd ?? process.cwd(),
       stdout: usesPipe ? "pipe" : outFd,
       stderr: usesPipe ? "pipe" : outFd,

package/src/task-runner.ts

@@ -27,6 +27,8 @@ export type RunOptions = {
   onTaskRunning?: (name: string) => void;
   onTaskDone?: (name: string) => void;
   onTaskFailed?: (name: string, code: number) => void;
+  /** Called when the scheduler blocks until one or more waitToExit processes finish. */
+  onWaitingForExit?: (names: string[]) => void;
   /** Called when a critical process fails and the whole run should stop. */
   onShutdown?: (reason: string) => void;
 };
@@ -170,6 +172,7 @@ export async function runProcesses(
   };
 
   let shutdownRequested = false;
+  let lastWaitingForExitKey = "";
 
   while (pending.size > 0 || waitingToExit.size > 0) {
     if (shutdownRequested) break;
@@ -259,6 +262,11 @@ export async function runProcesses(
       );
     } else if (waitingToExit.size > 0) {
       // All ready tasks are launched; wait for a waitToExit one to finish
+      const waitingKey = [...waitingToExit].sort().join("\0");
+      if (waitingKey !== lastWaitingForExitKey) {
+        lastWaitingForExitKey = waitingKey;
+        options.onWaitingForExit?.([...waitingToExit].sort());
+      }
       await waitForWake();
     } else {
       // pending > 0 but nothing is ready and nothing is waiting — circular dep