everything-dev 1.5.0 → 1.7.0

package/src/dev-session.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Deferred, Effect, Exit } from "effect";
 import {
   type DevViewHandle,
   type LogEntry,
@@ -14,7 +14,7 @@ import {
   type ProcessCallbacks,
   type ProcessHandle,
 } from "./orchestrator";
-import { makeProcessRegistry } from "./process-registry";
+import { makeProcessRegistry, type ProcessRegistry } from "./process-registry";
 import type { BosConfig, RuntimeConfig, SourceMode } from "./types";
 
 export interface AppConfig {
@@ -87,9 +87,23 @@ function formatLogLine(entry: LogEntry): string {
   return `[${ts}] [${entry.source}] [${prefix}] ${entry.line}`;
 }
 
+const scopedProcess = (
+  pkg: string,
+  env: Record<string, string> | undefined,
+  callbacks: ProcessCallbacks,
+  portOverride: number | undefined,
+  bosConfig: BosConfig | undefined,
+  runtimeConfig: RuntimeConfig | undefined,
+  registry: ProcessRegistry | undefined,
+) =>
+  Effect.acquireRelease(
+    makeDevProcess(pkg, env, callbacks, portOverride, bosConfig, runtimeConfig, registry),
+    (handle) => handle.kill.pipe(Effect.ignore),
+  );
+
 export const runDevSession = (
   orchestrator: AppOrchestrator,
-  onCleanupReady?: (cleanup: () => Promise<void>) => void,
+  onShutdownReady?: (requestShutdown: () => void) => void,
 ) =>
   Effect.gen(function* () {
     const configDir = getProjectRoot();
@@ -125,62 +139,36 @@ export const runDevSession = (
     const logger = yield* Effect.promise(() =>
       createDevLogger(configDir, orchestrator.description),
     );
-    const handles: ProcessHandle[] = [];
+
+    const shutdown = yield* Deferred.make<void>();
+
+    onShutdownReady?.(() => {
+      void Effect.runPromise(Deferred.succeed(shutdown, undefined));
+    });
+
     const allLogs: LogEntry[] = [];
     let view: DevViewHandle | null = null;
-    let shuttingDown = false;
-
-    const killAll = async () => {
-      const reversed = [...handles].reverse();
-      for (const handle of reversed) {
-        try {
-          await handle.kill();
-        } catch {}
-      }
-      await Effect.runPromise(registry.killAll(true)).catch(() => {});
-    };
-
-    const exportLogs = async () => {
-      console.log("\n");
-      console.log("═".repeat(70));
-      console.log(`  SESSION LOGS: ${orchestrator.description}`);
-      console.log(`  Started: ${new Date(allLogs[0]?.timestamp || Date.now()).toISOString()}`);
-      console.log(`  Total entries: ${allLogs.length}`);
-      console.log("═".repeat(70));
-      console.log("");
-      for (const entry of allLogs) {
-        console.log(formatLogLine(entry));
-      }
-      console.log("");
-      console.log("═".repeat(70));
-      console.log(`  Full logs saved to: ${logger.logFile}`);
-      console.log("═".repeat(70));
-      console.log("");
-    };
+    let shouldExportLogs = false;
 
-    const cleanup = async (showLogs = false) => {
-      if (shuttingDown) return;
-      shuttingDown = true;
-      view?.unmount();
-      await killAll();
-      if (showLogs) {
-        await exportLogs();
-      }
+    const requestShutdownAndExport = () => {
+      shouldExportLogs = true;
+      void Effect.runPromise(Deferred.succeed(shutdown, undefined));
     };
 
-    onCleanupReady?.(cleanup);
-
     const useInteractive = orchestrator.interactive ?? isInteractiveSupported();
     view = useInteractive
       ? renderDevView(
           initialProcesses,
           orchestrator.description,
           orchestrator.env,
-          () => cleanup(false),
-          () => cleanup(true),
+          () => void Effect.runPromise(Deferred.succeed(shutdown, undefined)),
+          requestShutdownAndExport,
         )
-      : renderStreamingView(initialProcesses, orchestrator.description, orchestrator.env, () =>
-          cleanup(false),
+      : renderStreamingView(
+          initialProcesses,
+          orchestrator.description,
+          orchestrator.env,
+          () => void Effect.runPromise(Deferred.succeed(shutdown, undefined)),
         );
 
     const callbacks: ProcessCallbacks = {
@@ -207,7 +195,7 @@ export const runDevSession = (
 
     const startProcess = (pkg: string) => {
       const portOverride = pkg === "host" ? orchestrator.port : undefined;
-      return makeDevProcess(
+      return scopedProcess(
         pkg,
         orchestrator.env,
         callbacks,
@@ -237,7 +225,6 @@ export const runDevSession = (
     const hostPackages = orderedPackages.filter((pkg) => pkg === "host");
 
     const nonHostHandles = yield* startGroup(nonHostPackages);
-    handles.push(...nonHostHandles);
 
     yield* Effect.forEach(
       nonHostHandles.map((handle, index) => ({
@@ -249,7 +236,6 @@ export const runDevSession = (
     );
 
     const hostHandles = yield* startGroup(hostPackages);
-    handles.push(...hostHandles);
 
     yield* Effect.forEach(
       hostHandles.map((handle, index) => ({ handle, pkg: hostPackages[index] ?? handle.name })),
@@ -257,16 +243,48 @@ export const runDevSession = (
       { concurrency: "unbounded" },
     );
 
-    yield* Effect.addFinalizer(() => Effect.promise(() => cleanup(false)));
-    yield* Effect.never;
+    yield* Effect.addFinalizer(() =>
+      Effect.gen(function* () {
+        view?.unmount();
+
+        if (shouldExportLogs) {
+          console.log("\n");
+          console.log("═".repeat(70));
+          console.log(`  SESSION LOGS: ${orchestrator.description}`);
+          console.log(`  Started: ${new Date(allLogs[0]?.timestamp || Date.now()).toISOString()}`);
+          console.log(`  Total entries: ${allLogs.length}`);
+          console.log("═".repeat(70));
+          console.log("");
+          for (const entry of allLogs) {
+            console.log(formatLogLine(entry));
+          }
+          console.log("");
+          console.log("═".repeat(70));
+          console.log(`  Full logs saved to: ${logger.logFile}`);
+          console.log("═".repeat(70));
+          console.log("");
+        }
+
+        yield* registry.killAll(true).pipe(Effect.ignore);
+      }),
+    );
+
+    yield* Deferred.await(shutdown);
   });
 
 export const startApp = (orchestrator: AppOrchestrator) => {
-  let activeCleanup: (() => Promise<void>) | null = null;
+  let requestShutdown: (() => void) | null = null;
+  let signalCount = 0;
+  let forceExitTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const forceExit = () => {
+    console.log("\n[Dev] Force exit");
+    process.exit(0);
+  };
 
   const program = Effect.scoped(
-    runDevSession(orchestrator, (cleanup) => {
-      activeCleanup = cleanup;
+    runDevSession(orchestrator, (shutdown) => {
+      requestShutdown = shutdown;
     }),
   ).pipe(
     Effect.catchAll((e) =>
@@ -281,38 +299,22 @@ export const startApp = (orchestrator: AppOrchestrator) => {
     ),
   );
 
-  const handleSignal = async () => {
-    if (activeCleanup) await activeCleanup();
-  };
-
-  const forceExit = () => {
-    console.log("\n[Dev] Force exit");
-    process.exit(0);
-  };
-
-  let signalCount = 0;
-  process.on("SIGINT", () => {
-    signalCount++;
-    if (signalCount > 1) {
-      forceExit();
-      return;
-    }
-    const timeout = setTimeout(forceExit, 5000);
-    void handleSignal().finally(() => {
-      clearTimeout(timeout);
-    });
-  });
-  process.on("SIGTERM", () => {
+  const handleSignal = () => {
     signalCount++;
     if (signalCount > 1) {
       forceExit();
       return;
     }
-    const timeout = setTimeout(forceExit, 5000);
-    void handleSignal().finally(() => {
-      clearTimeout(timeout);
-    });
-  });
+    console.log("\n[Dev] Shutting down...");
+    forceExitTimer = setTimeout(forceExit, 8000);
+    requestShutdown?.();
+  };
 
-  void Effect.runPromise(program);
+  process.on("SIGINT", handleSignal);
+  process.on("SIGTERM", handleSignal);
+
+  Effect.runPromiseExit(program).then((exit) => {
+    if (forceExitTimer) clearTimeout(forceExitTimer);
+    process.exit(Exit.isSuccess(exit) ? 0 : 0);
+  });
 };

package/src/fastkv.ts

@@ -127,6 +127,101 @@ export async function fetchBosConfigFromFastKv<T>(bosUrl: string): Promise<T> {
   return value as T;
 }
 
+export interface PluginManifest {
+  schemaVersion: number;
+  kind: string;
+  plugin: { name: string; version: string };
+  runtime: { remoteEntry: string };
+  contract: {
+    kind: string;
+    types: { path: string; exportName: string; typeName: string; sha256: string };
+  };
+  additionalExports?: Array<{ path: string; exports: string[]; sha256: string }>;
+}
+
+export interface PluginMetadata {
+  title: string | null;
+  description: string | null;
+  repoUrl: string | null;
+  version: string;
+  publishedAt: string;
+  cdnUrl: string;
+  integrity: string | null;
+}
+
+export interface PluginRegistryEntry {
+  manifest: PluginManifest;
+  metadata: PluginMetadata;
+}
+
+export function parsePluginBosUrl(
+  source: string,
+): { accountId: string; pluginName: string } | null {
+  if (!source.startsWith("bos://")) return null;
+  const match = source.match(/^bos:\/\/([^/]+)\/plugins\/([^/]+)$/);
+  if (!match?.[1] || !match[2]) return null;
+  return { accountId: match[1], pluginName: match[2] };
+}
+
+async function fetchKvValue(accountId: string, key: string): Promise<unknown | null> {
+  const payload = await fetchJson<FastKvListResponse>(
+    `${getFastKvBaseUrlForAccount(accountId)}/v0/latest/${encodeURIComponent(getRegistryNamespaceForAccount(accountId))}/${encodeURIComponent(accountId)}`,
+    {
+      method: "POST",
+      body: JSON.stringify({ key, limit: 1 }),
+    },
+  );
+  const value = payload?.entries?.find(Boolean)?.value;
+  if (value == null) return null;
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  return value;
+}
+
+export async function fetchPluginFromRegistry(
+  accountId: string,
+  pluginName: string,
+): Promise<PluginRegistryEntry | null> {
+  const manifestKey = `plugins/${accountId}/${pluginName}/manifest.json`;
+  const metadataKey = `plugins/${accountId}/${pluginName}/metadata`;
+
+  const [rawManifest, rawMetadata] = await Promise.all([
+    fetchKvValue(accountId, manifestKey),
+    fetchKvValue(accountId, metadataKey),
+  ]);
+
+  if (!rawManifest || typeof rawManifest !== "object") return null;
+
+  return {
+    manifest: rawManifest as PluginManifest,
+    metadata: (rawMetadata ?? {
+      title: null,
+      description: null,
+      repoUrl: null,
+      version: "",
+      publishedAt: "",
+      cdnUrl: "",
+      integrity: null,
+    }) as PluginMetadata,
+  };
+}
+
+export async function fetchRemotePluginManifest(cdnUrl: string): Promise<PluginManifest | null> {
+  try {
+    const baseUrl = cdnUrl.replace(/\/$/, "");
+    const response = await fetch(`${baseUrl}/plugin.manifest.json`);
+    if (!response.ok) return null;
+    return (await response.json()) as PluginManifest;
+  } catch {
+    return null;
+  }
+}
+
 async function fetchJson<T>(url: string, init?: RequestInit): Promise<T | null> {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), FASTKV_TIMEOUT_MS);

package/src/host.ts

@@ -258,7 +258,7 @@ async function runHostServer(opts: {
     }),
   );
 
-  app.use("*", secureHeaders());
+  app.use("*", secureHeaders({ crossOriginOpenerPolicy: "same-origin-allow-popups" }));
 
   app.get("/health", (c) => c.text("OK"));
   app.get("/ready", async (c) => {

package/src/orchestrator.ts

@@ -24,7 +24,7 @@ export interface ProcessCallbacks {
 export interface ProcessHandle {
   name: string;
   pid: number | undefined;
-  kill: () => Promise<void>;
+  kill: Effect.Effect<void, unknown>;
   waitForReady: Effect.Effect<void, Error>;
   waitForExit: Effect.Effect<unknown>;
 }
@@ -62,7 +62,6 @@ const processConfigBases: Record<string, ProcessConfigBase> = {
     command: "bun",
     args: ["run", "dev"],
     cwd: "ui",
-    // Wait for the client build (mf) specifically, not just SSR.
     readyPatterns: [/\bready\s+built in\b/i, /\bLocal:\b/i, /\bcompiled\b.*successfully/i],
     errorPatterns: [/error/i, /failed to compile/i],
   },
@@ -91,6 +90,25 @@ export function getProcessConfig(
   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;
@@ -386,11 +404,14 @@ export const spawnRemoteHost = (
     return {
       name: config.name,
       pid: process.pid,
-      kill: async () => {
+      kill: Effect.gen(function* () {
         callbacks.onLog(config.name, "Shutting down remote host...");
         restoreConsole();
-        await serverHandle.shutdown();
-      },
+        yield* Effect.tryPromise({
+          try: () => serverHandle.shutdown(),
+          catch: () => {},
+        }).pipe(Effect.ignore);
+      }),
       waitForReady: Effect.succeed(undefined),
       waitForExit: Effect.never,
     } satisfies ProcessHandle;
@@ -441,14 +462,12 @@ export const spawnDevProcess = (
       yield* Deferred.succeed(readyDeferred, undefined).pipe(Effect.ignore);
     });
 
-    // Prefer probe-based readiness to avoid brittle log regexes.
-    // This is best-effort and complements log detection.
     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}`;
 
-      yield* Effect.fork(
+      yield* Effect.forkScoped(
         Effect.gen(function* () {
           const deadline = Date.now() + 90_000;
           while (Date.now() < deadline) {
@@ -483,7 +502,7 @@ export const spawnDevProcess = (
       });
     }
 
-    yield* Effect.fork(
+    yield* Effect.forkScoped(
       Effect.promise(() => proc.exited).pipe(
         Effect.andThen((code) =>
           Effect.gen(function* () {
@@ -531,7 +550,7 @@ export const spawnDevProcess = (
 
     const decoder = new TextDecoder();
 
-    const stdoutFiber = yield* Effect.fork(
+    const stdoutFiber = yield* Effect.forkScoped(
       Effect.async<void>((resume) => {
         if (!proc.stdout) {
           resume(Effect.void);
@@ -539,13 +558,13 @@ export const spawnDevProcess = (
         }
         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));
-              }
+              if (buffer) Effect.runSync(handleLine(buffer, false));
               return;
             }
             buffer += decoder
@@ -560,11 +579,18 @@ export const spawnDevProcess = (
             return pump();
           });
 
-        pump().then(() => resume(Effect.void));
+        pump().then(() => {
+          if (active) resume(Effect.void);
+        });
+
+        return Effect.sync(() => {
+          active = false;
+          reader.cancel();
+        });
       }),
     );
 
-    const stderrFiber = yield* Effect.fork(
+    const stderrFiber = yield* Effect.forkScoped(
       Effect.async<void>((resume) => {
         if (!proc.stderr) {
           resume(Effect.void);
@@ -572,13 +598,13 @@ export const spawnDevProcess = (
         }
         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));
-              }
+              if (buffer) Effect.runSync(handleLine(buffer, true));
               return;
             }
             buffer += decoder
@@ -593,25 +619,29 @@ export const spawnDevProcess = (
             return pump();
           });
 
-        pump().then(() => resume(Effect.void));
+        pump().then(() => {
+          if (active) resume(Effect.void);
+        });
+
+        return Effect.sync(() => {
+          active = false;
+          reader.cancel();
+        });
       }),
     );
 
     const handle: ProcessHandle = {
       name: config.name,
       pid: proc.pid,
-      kill: async () => {
-        const pid = proc.pid;
-        if (pid) {
-          await Effect.runPromise(killProcessTree(pid));
-        } else {
-          proc.kill("SIGTERM");
-          await new Promise((r) => setTimeout(r, 100));
-          try {
-            proc.kill("SIGKILL");
-          } catch {}
-        }
-      },
+      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]);