everything-dev 1.7.2 → 1.8.0

package/src/plugin.ts

@@ -23,8 +23,6 @@ import {
   getHostDevelopmentPort,
   getProjectRoot,
   loadConfig,
-  parsePort,
-  resolveDevelopmentHostUrl,
   resolveLocalDevelopmentPath,
 } from "./config";
 import {
@@ -43,7 +41,7 @@ import {
   type SyncOptions,
   type UpgradeOptions,
 } from "./contract";
-import { type AppConfig, type AppOrchestrator, startApp } from "./dev-session";
+import { devApp, startApp } from "./dev-session";
 import {
   buildRegistryConfigUrlForNetwork,
   fetchBosConfigFromFastKv,
@@ -58,6 +56,11 @@ import { computeSriHashForUrl } from "./integrity";
 import { addFunctionCallAccessKey, ensureNearCli, executeTransaction } from "./near-cli";
 import { getNetworkIdForAccount } from "./network";
 import { createPlugin, z } from "./sdk";
+import {
+  type AppOrchestrator,
+  buildDescription,
+  buildServiceDescriptorMap,
+} from "./service-descriptor";
 import { syncAndGenerateSharedUi } from "./shared";
 import type { BosConfig, RuntimeConfig, SourceMode } from "./types";
 import { run } from "./utils/run";
@@ -91,13 +94,6 @@ function ensureEnvFile(configDir: string): void {
   console.log(`[CLI] Created .env from .env.example with generated BETTER_AUTH_SECRET`);
 }
 
-const DEFAULT_DEV_CONFIG: AppConfig = {
-  host: "local",
-  ui: "local",
-  api: "local",
-  ssr: false,
-};
-
 const buildCommands: Record<string, { cmd: string; args: string[] }> = {
   host: { cmd: "bun", args: ["run", "build"] },
   ui: { cmd: "bun", args: ["run", "build"] },
@@ -119,35 +115,6 @@ function parseSourceMode(value: string | undefined, defaultValue: SourceMode): S
   return defaultValue;
 }
 
-function buildAppConfig(options: {
-  host?: string;
-  ui?: string;
-  api?: string;
-  proxy?: boolean;
-  ssr?: boolean;
-}): AppConfig {
-  return {
-    host: parseSourceMode(options.host, DEFAULT_DEV_CONFIG.host),
-    ui: parseSourceMode(options.ui, DEFAULT_DEV_CONFIG.ui),
-    api: parseSourceMode(options.api, DEFAULT_DEV_CONFIG.api),
-    proxy: options.proxy,
-    ssr: options.ssr ?? DEFAULT_DEV_CONFIG.ssr,
-  };
-}
-
-function buildDescription(config: AppConfig): string {
-  if (config.host === "local" && config.ui === "local" && config.api === "local" && !config.proxy) {
-    return "Full Local Development";
-  }
-
-  const parts: string[] = [];
-  parts.push(config.host === "remote" ? "Remote Host" : "Local Host");
-  if (config.ui === "remote") parts.push("Remote UI");
-  if (config.proxy) parts.push("Proxy API → Production");
-  else if (config.api === "remote") parts.push("Remote API");
-  return parts.join(" + ");
-}
-
 function buildConfigResult(bosConfig: BosConfig | null): BosConfigResult {
   const packages = bosConfig ? Object.keys(bosConfig.app) : [];
   const remotes = packages.filter((name) => name !== "host");
@@ -194,30 +161,6 @@ function resolveWorkspaceTarget(
   return null;
 }
 
-function determineProcesses(
-  config: AppConfig,
-  localPackages: string[],
-  runtimeConfig?: RuntimeConfig | null,
-): string[] {
-  const processes: string[] = [];
-  if (config.ssr && config.ui === "local") processes.push("ui-ssr");
-  if (config.ui === "local") processes.push("ui");
-  if (localPackages.includes("auth") && runtimeConfig?.auth?.source === "local") {
-    processes.push("auth");
-  }
-  if (config.api === "local" && !config.proxy) processes.push("api");
-  for (const pkg of localPackages) {
-    if (pkg.startsWith("plugin:")) {
-      const pluginId = pkg.slice("plugin:".length);
-      if (runtimeConfig?.plugins?.[pluginId]?.source === "local") {
-        processes.push(pkg);
-      }
-    }
-  }
-  processes.push("host");
-  return processes;
-}
-
 function isValidProxyUrl(url: string): boolean {
   try {
     const parsed = new URL(url);
@@ -318,39 +261,6 @@ function extractPublishedUrl(output: string): string | null {
   return match[match.length - 1] ?? null;
 }
 
-async function buildEnvVars(
-  config: AppConfig,
-  bosConfig?: BosConfig | null,
-): Promise<Record<string, string>> {
-  const env: Record<string, string> = {
-    HOST_SOURCE: config.host,
-    UI_SOURCE: config.ui,
-    API_SOURCE: config.api,
-  };
-
-  if (config.host === "remote") {
-    const remoteUrl = bosConfig?.app.host.production;
-    if (remoteUrl) env.HOST_REMOTE_URL = remoteUrl;
-  }
-
-  if (config.ui === "remote") {
-    const remoteUrl = bosConfig?.app.ui.production;
-    if (remoteUrl) env.UI_REMOTE_URL = remoteUrl;
-  }
-
-  if (config.api === "remote") {
-    const remoteUrl = bosConfig?.app.api.production;
-    if (remoteUrl) env.API_REMOTE_URL = remoteUrl;
-  }
-
-  if (config.proxy && bosConfig) {
-    const proxyUrl = resolveProxyUrl(bosConfig);
-    if (proxyUrl) env.API_PROXY = proxyUrl;
-  }
-
-  return env;
-}
-
 async function buildEveryPluginQuietly(cwd: string) {
   const packageDir = `${cwd}/packages/every-plugin`;
   const packageExists = await Bun.file(`${packageDir}/package.json`).exists();
@@ -876,24 +786,31 @@ export default createPlugin({
         deps.runtimeConfig ?? undefined,
       );
 
-      const appConfig = buildAppConfig({
-        host: localPackages.includes("host") ? (input.host as string) : "remote",
-        ui: localPackages.includes("ui") ? (input.ui as string) : "remote",
-        api: localPackages.includes("api") ? (input.api as string) : "remote",
-        proxy: input.proxy,
-        ssr: input.ssr,
-      });
+      const hostSource: SourceMode = localPackages.includes("host")
+        ? parseSourceMode(input.host as string, "local")
+        : "remote";
+      const uiSource: SourceMode = localPackages.includes("ui")
+        ? parseSourceMode(input.ui as string, "local")
+        : "remote";
+      const apiSource: SourceMode = localPackages.includes("api")
+        ? parseSourceMode(input.api as string, "local")
+        : "remote";
+      const authSource: SourceMode = localPackages.includes("auth")
+        ? parseSourceMode(input.auth as string, "local")
+        : "remote";
+      const ssr = input.ssr ?? false;
+      const proxy = input.proxy ?? false;
 
       const sharedSync = await syncAndGenerateSharedUi({
         configDir: deps.configDir,
-        hostMode: appConfig.host,
+        hostMode: hostSource,
         bosConfig: deps.bosConfig ?? undefined,
       });
       if (sharedSync.catalogChanged) {
         await run("bun", ["install"], { cwd: deps.configDir });
       }
       if (
-        (appConfig.api === "local" && !appConfig.proxy) ||
+        (apiSource === "local" && !proxy) ||
         localPackages.some((pkg) => pkg.startsWith("plugin:"))
       ) {
         await buildEveryPluginQuietly(deps.configDir);
@@ -913,7 +830,7 @@ export default createPlugin({
         };
       }
 
-      if (appConfig.proxy && !resolveProxyUrl(deps.bosConfig)) {
+      if (proxy && !resolveProxyUrl(deps.bosConfig)) {
         return {
           status: "error" as const,
           description: "No valid proxy URL configured in bos.config.json",
@@ -921,27 +838,29 @@ export default createPlugin({
         };
       }
 
-      const refreshedLocalPackages = detectLocalPackages(
-        deps.bosConfig ?? undefined,
-        deps.runtimeConfig ?? undefined,
-      );
-      const processes = determineProcesses(appConfig, refreshedLocalPackages, deps.runtimeConfig);
-      const env = await buildEnvVars(appConfig, deps.bosConfig);
       const hostPort = input.port ?? getHostDevelopmentPort(deps.bosConfig.app.host.development);
       const developmentRuntime = buildRuntimeConfig(deps.bosConfig, {
-        uiSource: appConfig.ui,
-        apiSource: appConfig.api,
-        authSource: refreshedLocalPackages.includes("auth") ? "local" : "remote",
-        hostUrl: `http://localhost:${hostPort}`,
-        proxy: env.API_PROXY,
+        uiSource,
+        apiSource,
+        authSource,
+        hostSource,
         env: "development",
         plugins: deps.runtimeConfig?.plugins,
       });
       const runtimeConfig = await prepareDevelopmentRuntimeConfig(developmentRuntime, {
         hostPort,
-        ssr: appConfig.ssr,
+        ssr,
       });
 
+      const services = buildServiceDescriptorMap(runtimeConfig, { ssr, proxy });
+      const packages = [...services.keys()];
+      const displayEnv: Record<string, string> = {};
+      const apiDescriptor = services.get("api");
+      if (apiDescriptor?.proxy) {
+        const proxyUrl = resolveProxyUrl(deps.bosConfig);
+        if (proxyUrl) displayEnv.API_PROXY = proxyUrl;
+      }
+
       await syncApiContractBridge({
         configDir: deps.configDir,
         runtimeConfig: runtimeConfig,
@@ -949,22 +868,19 @@ export default createPlugin({
       });
 
       const orchestrator: AppOrchestrator = {
-        packages: processes,
-        env,
-        description: buildDescription(appConfig),
-        appConfig,
-        bosConfig: deps.bosConfig,
-        runtimeConfig,
-        port: parsePort(runtimeConfig.hostUrl),
+        packages,
+        env: displayEnv,
+        description: buildDescription(services),
+        port: runtimeConfig.host.port,
         interactive: input.interactive,
       };
 
-      startApp(orchestrator);
+      devApp(orchestrator, services, runtimeConfig);
 
       return {
         status: "started" as const,
         description: orchestrator.description,
-        processes,
+        processes: packages,
       };
     }),
 
@@ -992,8 +908,6 @@ export default createPlugin({
       }
 
       const port = input.port ?? getHostDevelopmentPort(config.app.host.development);
-      const appConfig: AppConfig = { host: "remote", ui: "remote", api: "remote" };
-      const env = await buildEnvVars(appConfig, config);
       const isStaging = input.env === "staging";
       const runtimePlugins = remoteConfig
         ? await buildRuntimePluginsForConfig(config, deps.configDir, "production")
@@ -1002,11 +916,13 @@ export default createPlugin({
         uiSource: "remote",
         apiSource: "remote",
         authSource: "remote",
-        hostUrl: `http://localhost:${port}`,
+        hostSource: "remote",
         env: "production",
         plugins: runtimePlugins,
       });
 
+      const services = buildServiceDescriptorMap(runtimeConfig);
+
       await syncApiContractBridge({
         configDir: deps.configDir,
         runtimeConfig: runtimeConfig,
@@ -1021,19 +937,15 @@ export default createPlugin({
         packages: ["host"],
         env: {
           NODE_ENV: "production",
-          ...env,
           ...stagingEnvVars,
         },
         description: `${isStaging ? "Staging" : "Production"} Mode (${config.account})`,
-        appConfig,
-        bosConfig: config,
-        runtimeConfig,
         port,
         interactive: input.interactive,
         noLogs: true,
       };
 
-      startApp(orchestrator);
+      startApp(orchestrator, services, runtimeConfig);
       return {
         status: "running" as const,
         url: `http://localhost:${port}`,
@@ -1062,7 +974,7 @@ export default createPlugin({
         uiSource: deps.bosConfig.app.ui?.development ? "local" : "remote",
         apiSource: deps.bosConfig.app.api?.development ? "local" : "remote",
         authSource: deps.bosConfig.app.auth?.development ? "local" : "remote",
-        hostUrl: resolveDevelopmentHostUrl(deps.bosConfig.app.host.development),
+        hostSource: deps.bosConfig.app.host?.development ? "local" : "remote",
         env: "development",
         plugins: deps.runtimeConfig?.plugins,
       });

package/src/service-descriptor.ts

@@ -0,0 +1,258 @@
+import { Context, Layer } from "effect";
+import type { RuntimeConfig, SourceMode } from "./types";
+
+export interface ServiceDescriptor {
+  key: string;
+  source: SourceMode;
+  url: string;
+  remoteUrl?: string;
+  entry: string;
+  name: string;
+  localPath?: string;
+  port?: number;
+  readinessPath: string;
+  defaultPort: number;
+  integrity?: string;
+  proxy?: string;
+  variables?: Record<string, string>;
+  secrets?: string[];
+  ssr?: boolean;
+  command?: string;
+  args?: string[];
+  readyPatterns?: RegExp[];
+  errorPatterns?: RegExp[];
+}
+
+export class ServiceDescriptorMap extends Context.Tag("ServiceDescriptorMap")<
+  ServiceDescriptorMap,
+  Map<string, ServiceDescriptor>
+>() {}
+
+export class DevRuntimeConfig extends Context.Tag("DevRuntimeConfig")<
+  DevRuntimeConfig,
+  RuntimeConfig
+>() {}
+
+const PLUGIN_READY_PATTERNS = [/ready in/i, /compiled.*successfully/i, /listening/i, /started/i];
+
+const PLUGIN_ERROR_PATTERNS = [/error/i, /failed/i];
+
+const SERVICE_CONFIGS: Record<
+  string,
+  Pick<
+    ServiceDescriptor,
+    "command" | "args" | "readyPatterns" | "errorPatterns" | "defaultPort" | "readinessPath"
+  >
+> = {
+  host: {
+    command: "bun",
+    args: ["run", "dev"],
+    readyPatterns: [/Host (dev|production) server running at/i, /Server running at/i],
+    errorPatterns: [/error:/i, /failed/i, /exception/i],
+    defaultPort: 3000,
+    readinessPath: "/health",
+  },
+  auth: {
+    command: "bun",
+    args: ["run", "dev"],
+    readyPatterns: PLUGIN_READY_PATTERNS,
+    errorPatterns: PLUGIN_ERROR_PATTERNS,
+    defaultPort: 3002,
+    readinessPath: "/remoteEntry.js",
+  },
+  ui: {
+    command: "bun",
+    args: ["run", "dev"],
+    readyPatterns: [/\bready\s+built in\b/i, /\bLocal:\b/i, /\bcompiled\b.*successfully/i],
+    errorPatterns: [/error/i, /failed to compile/i],
+    defaultPort: 3003,
+    readinessPath: "/remoteEntry.js",
+  },
+  "ui-ssr": {
+    command: "bun",
+    args: ["run", "dev:ssr"],
+    readyPatterns: [/\bready\s+built in\b/i, /\bcompiled\b.*successfully/i],
+    errorPatterns: [/error/i, /failed/i],
+    defaultPort: 3004,
+    readinessPath: "/",
+  },
+  api: {
+    command: "bun",
+    args: ["run", "dev"],
+    readyPatterns: PLUGIN_READY_PATTERNS,
+    errorPatterns: PLUGIN_ERROR_PATTERNS,
+    defaultPort: 3001,
+    readinessPath: "/remoteEntry.js",
+  },
+};
+
+export function buildServiceDescriptorMap(
+  runtimeConfig: RuntimeConfig,
+  options?: { ssr?: boolean; proxy?: boolean },
+): Map<string, ServiceDescriptor> {
+  const map = new Map<string, ServiceDescriptor>();
+  const ssr = options?.ssr ?? false;
+
+  const hostIsRemote = runtimeConfig.host.source === "remote";
+  const hostProbeUrl = hostIsRemote
+    ? (runtimeConfig.host.remoteUrl ?? runtimeConfig.host.url)
+    : runtimeConfig.host.url;
+  map.set("host", {
+    key: "host",
+    source: runtimeConfig.host.source,
+    url: hostProbeUrl,
+    remoteUrl: runtimeConfig.host.remoteUrl,
+    entry: hostIsRemote
+      ? hostProbeUrl
+        ? `${hostProbeUrl}/mf-manifest.json`
+        : "/mf-manifest.json"
+      : runtimeConfig.host.entry,
+    name: runtimeConfig.host.name,
+    localPath: runtimeConfig.host.localPath,
+    port: runtimeConfig.host.port,
+    integrity: runtimeConfig.host.integrity,
+    secrets: runtimeConfig.host.secrets,
+    ...SERVICE_CONFIGS.host,
+  });
+
+  map.set("ui", {
+    key: "ui",
+    source: runtimeConfig.ui.source,
+    url: runtimeConfig.ui.url,
+    remoteUrl: runtimeConfig.ui.source === "remote" ? runtimeConfig.ui.url : undefined,
+    entry: runtimeConfig.ui.entry,
+    name: runtimeConfig.ui.name,
+    localPath: runtimeConfig.ui.localPath,
+    port: runtimeConfig.ui.port,
+    integrity: runtimeConfig.ui.integrity,
+    ssr,
+    ...SERVICE_CONFIGS.ui,
+  });
+
+  if (ssr && runtimeConfig.ui.source === "local") {
+    map.set("ui-ssr", {
+      key: "ui-ssr",
+      source: runtimeConfig.ui.source,
+      url: runtimeConfig.ui.ssrUrl ?? "",
+      entry: "",
+      name: "ui-ssr",
+      localPath: runtimeConfig.ui.localPath,
+      port: runtimeConfig.ui.ssrUrl
+        ? Number.parseInt(new URL(runtimeConfig.ui.ssrUrl).port, 10)
+        : (runtimeConfig.ui.port ?? 3003) + 1,
+      ...SERVICE_CONFIGS["ui-ssr"],
+    });
+  }
+
+  map.set("api", {
+    key: "api",
+    source: runtimeConfig.api.source,
+    url: runtimeConfig.api.url,
+    remoteUrl: runtimeConfig.api.source === "remote" ? runtimeConfig.api.url : undefined,
+    entry: runtimeConfig.api.entry,
+    name: runtimeConfig.api.name,
+    localPath: runtimeConfig.api.localPath,
+    port: runtimeConfig.api.port,
+    integrity: runtimeConfig.api.integrity,
+    proxy: runtimeConfig.api.proxy,
+    variables: runtimeConfig.api.variables,
+    secrets: runtimeConfig.api.secrets,
+    ...SERVICE_CONFIGS.api,
+  });
+
+  if (runtimeConfig.auth) {
+    map.set("auth", {
+      key: "auth",
+      source: runtimeConfig.auth.source,
+      url: runtimeConfig.auth.url,
+      remoteUrl: runtimeConfig.auth.source === "remote" ? runtimeConfig.auth.url : undefined,
+      entry: runtimeConfig.auth.entry,
+      name: runtimeConfig.auth.name,
+      localPath: runtimeConfig.auth.localPath,
+      port: runtimeConfig.auth.port,
+      integrity: runtimeConfig.auth.integrity,
+      proxy: runtimeConfig.auth.proxy,
+      variables: runtimeConfig.auth.variables,
+      secrets: runtimeConfig.auth.secrets,
+      ...SERVICE_CONFIGS.auth,
+    });
+  }
+
+  if (runtimeConfig.plugins) {
+    let pluginBasePort = 3010;
+    for (const [pluginId, pluginConfig] of Object.entries(runtimeConfig.plugins)) {
+      const pluginKey = `plugin:${pluginId}`;
+      const resolvedPort = pluginConfig.port ?? pluginBasePort;
+      pluginBasePort = resolvedPort + 1;
+
+      map.set(pluginKey, {
+        key: pluginKey,
+        source: pluginConfig.source,
+        url: pluginConfig.url,
+        remoteUrl: pluginConfig.source === "remote" ? pluginConfig.url : undefined,
+        entry: pluginConfig.entry,
+        name: pluginConfig.name,
+        localPath: pluginConfig.localPath,
+        port: resolvedPort,
+        integrity: pluginConfig.integrity,
+        proxy: pluginConfig.proxy,
+        variables: pluginConfig.variables,
+        secrets: pluginConfig.secrets,
+        command: "bun",
+        args: ["run", "dev"],
+        readyPatterns: PLUGIN_READY_PATTERNS,
+        errorPatterns: PLUGIN_ERROR_PATTERNS,
+        defaultPort: resolvedPort,
+        readinessPath: "/remoteEntry.js",
+      });
+    }
+  }
+
+  return map;
+}
+
+export interface AppOrchestrator {
+  packages: string[];
+  description: string;
+  env: Record<string, string>;
+  port?: number;
+  interactive?: boolean;
+  noLogs?: boolean;
+}
+
+export const ServiceDescriptorMapLive = (map: Map<string, ServiceDescriptor>) =>
+  Layer.succeed(ServiceDescriptorMap, map);
+
+export const DevRuntimeConfigLive = (config: RuntimeConfig) =>
+  Layer.succeed(DevRuntimeConfig, config);
+
+export function buildDescription(map: Map<string, ServiceDescriptor>): string {
+  const descriptors = [...map.values()].filter(
+    (d) => d.key !== "ui-ssr" && !d.key.startsWith("plugin:"),
+  );
+
+  const allLocal = descriptors.every((d) => d.source === "local");
+  const hasProxy = [...map.values()].some((d) => d.proxy && d.source === "local");
+  if (allLocal && !hasProxy) return "Full Local Development";
+
+  const parts: string[] = [];
+  for (const d of descriptors) {
+    if (d.source === "remote") {
+      const label =
+        d.key === "host"
+          ? "Remote Host"
+          : d.key === "ui"
+            ? "Remote UI"
+            : d.key === "api"
+              ? hasProxy
+                ? undefined
+                : "Remote API"
+              : d.key === "auth"
+                ? "Remote Auth"
+                : undefined;
+      if (label) parts.push(label);
+    }
+  }
+  if (hasProxy) parts.push("Proxy API → Production");
+  return parts.join(" + ") || "Remote Mode";
+}

package/src/types.ts

@@ -144,7 +144,12 @@ export const RuntimeConfigSchema = z.object({
   networkId: z.enum(["mainnet", "testnet"]),
   title: z.string().optional(),
   repository: z.string().optional(),
-  hostUrl: z.string(),
+  host: FederationEntrySchema.extend({
+    localPath: z.string().optional(),
+    port: z.number().optional(),
+    secrets: z.array(z.string()).optional(),
+    remoteUrl: z.string().optional(),
+  }),
   shared: z
     .object({
       ui: z.record(z.string(), SharedConfigSchema).optional(),
@@ -175,6 +180,7 @@ export const RuntimeConfigSchema = z.object({
 export type RuntimeConfig = z.infer<typeof RuntimeConfigSchema>;
 
 export const ClientRuntimeConfigSchema = z.object({
+  cspNonce: z.string().optional(),
   env: z.enum(["development", "production"]),
   account: z.string(),
   networkId: z.enum(["mainnet", "testnet"]),
@@ -183,6 +189,7 @@ export const ClientRuntimeConfigSchema = z.object({
   apiBase: z.string(),
   rpcBase: z.string(),
   repository: z.string().optional(),
+  authAvailable: z.boolean().optional(),
   runtime: ClientRuntimeInfoSchema.optional(),
   ui: z
     .object({

package/src/ui/runtime.ts

@@ -82,3 +82,8 @@ export function getRepository(config?: Partial<ClientRuntimeConfig>): string | u
   const cfg = config ?? getRuntimeConfig();
   return cfg?.repository;
 }
+
+export function getCspNonce(config?: Partial<ClientRuntimeConfig>): string | undefined {
+  const cfg = config ?? getRuntimeConfig();
+  return cfg?.cspNonce;
+}