everything-dev 0.3.3 → 1.3.3

package/src/config.ts

@@ -1,573 +1,503 @@
-import { existsSync, statSync } from "node:fs";
-import { access, readFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
-import { Effect } from "every-plugin/effect";
-import { Graph } from "near-social-js";
-import type {
-	AppConfig,
-	BosConfig,
-	BosConfigInput,
-	PortConfig,
-	RemoteConfig,
-	RuntimeConfig,
-	SourceMode,
-} from "./types";
-import {
-	BosConfigInputSchema,
-	BosConfigSchema,
-	ConfigCircularExtendsError,
-	ConfigFetchError,
-	ConfigResolutionError,
-} from "./types";
-
-// Re-export types
-export type {
-	AppConfig,
-	BosConfig,
-	PortConfig,
-	RemoteConfig,
-	RuntimeConfig,
-	SourceMode,
-};
-
-// Constants
-export const DEFAULT_DEV_CONFIG: AppConfig = {
-	host: "local",
-	ui: "local",
-	api: "local",
-};
-
-// Global state (for caching)
-const configCache = new Map<string, { config: BosConfig; timestamp: number }>();
+import { fetchBosConfigFromFastKv } from "./fastkv";
+import { getNetworkIdForAccount } from "./network";
+import type { BosConfig, RuntimeConfig, RuntimePluginConfig } from "./types";
+import { BosConfigSchema } from "./types";
+
+interface BosConfigInput extends Record<string, unknown> {
+  extends?: string;
+  development?: string;
+  production?: string;
+  productionIntegrity?: string;
+  proxy?: string;
+  variables?: Record<string, string>;
+  secrets?: string[];
+  app?: Record<string, Record<string, unknown>>;
+  shared?: Record<string, Record<string, Record<string, unknown>>>;
+  plugins?: Record<string, BosConfigInput>;
+}
+
+const LOCAL_PREFIX = "local:";
+const DEFAULT_HOST_PORT = 3000;
+
+interface RuntimeTarget {
+  source: "local" | "remote";
+  url: string;
+  localPath?: string;
+  port?: number;
+}
+
 let cachedConfig: BosConfig | null = null;
 let projectRoot: string | null = null;
-let configLoaded = false;
-
-// ============================================================================
-// PUBLIC API (6 methods)
-// ============================================================================
 
-/**
- * Clear the config cache. Used by --force flag.
- */
 export function clearConfigCache(): void {
-	configCache.clear();
-	cachedConfig = null;
-	projectRoot = null;
-	configLoaded = false;
+  cachedConfig = null;
+  projectRoot = null;
 }
 
-/**
- * Find the path to bos.config.json by walking up the directory tree.
- */
 export function findConfigPath(cwd?: string): string | null {
-	let dir = cwd ?? process.cwd();
-	while (dir !== "/") {
-		const configPath = join(dir, "bos.config.json");
-		if (existsSync(configPath) && statSync(configPath).size > 0) {
-			return configPath;
-		}
-		dir = dirname(dir);
-	}
-	return null;
+  let dir = cwd ?? process.cwd();
+  while (dir !== "/") {
+    const configPath = join(dir, "bos.config.json");
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+    dir = dirname(dir);
+  }
+  return null;
 }
 
-/**
- * Get the cached config. Returns null if not loaded yet.
- */
 export function getConfig(): BosConfig | null {
-	return cachedConfig;
+  return cachedConfig;
 }
 
-/**
- * Get the project root directory (where bos.config.json is located).
- * Throws if config hasn't been loaded.
- */
 export function getProjectRoot(): string {
-	if (!configLoaded || !projectRoot) {
-		throw new Error("Config not loaded. Call loadConfig() first.");
-	}
-	return projectRoot;
+  if (!projectRoot) {
+    throw new Error("Config not loaded. Call loadConfig() first.");
+  }
+  return projectRoot;
 }
 
-/**
- * Result of loading config - includes everything needed by callers.
- */
 export interface ConfigResult {
-	/** The validated BosConfig */
-	config: BosConfig;
-	/** Environment-specific runtime config */
-	runtime: RuntimeConfig;
-	/** Information about where/how the config was loaded */
-	source: {
-		path: string;
-		extended?: string[];
-		remote?: boolean;
-	};
-	/** Package information */
-	packages: {
-		all: string[];
-		resolved: PackageResolution[];
-	};
+  config: BosConfig;
+  runtime: RuntimeConfig;
+  source: {
+    path: string;
+    extended?: string[];
+    remote?: boolean;
+  };
 }
 
-/**
- * Resolution info for a single package.
- */
-export interface PackageResolution {
-	name: string;
-	mode: SourceMode;
-	exists: boolean;
-	port: number;
-	url: string;
-}
-
-/**
- * Primary config loader - handles everything.
- * - Local config loading
- * - Config inheritance (extends)
- * - BOS URL fetching
- * - Caching
- * - Runtime config generation
- */
 export async function loadConfig(options?: {
-	cwd?: string;
-	path?: string;
-	force?: boolean;
-	env?: "development" | "production";
+  cwd?: string;
+  path?: string;
+  env?: "development" | "production";
 }): Promise<ConfigResult | null> {
-	// Return cached result if available and not forcing reload
-	if (configLoaded && cachedConfig && !options?.force) {
-		const runtime = buildRuntimeConfig(
-			cachedConfig,
-			options?.env ?? "development",
-		);
-		return {
-			config: cachedConfig,
-			runtime,
-			source: { path: join(projectRoot!, "bos.config.json") },
-			packages: {
-				all: Object.keys(cachedConfig.app),
-				resolved: [], // Will be populated by resolvePackages
-			},
-		};
-	}
-
-	// Find or use explicit config path
-	const configPath = options?.path ?? findConfigPath(options?.cwd);
-	if (!configPath) {
-		configLoaded = true;
-		projectRoot = options?.cwd ?? process.cwd();
-		return null;
-	}
-
-	const baseDir = dirname(configPath);
-
-	// Check cache for this specific file
-	const cached = configCache.get(configPath);
-	if (cached && !options?.force) {
-		projectRoot = baseDir;
-		cachedConfig = cached.config;
-		configLoaded = true;
-		const runtime = buildRuntimeConfig(
-			cached.config,
-			options?.env ?? "development",
-		);
-		return {
-			config: cached.config,
-			runtime,
-			source: { path: configPath },
-			packages: {
-				all: Object.keys(cached.config.app),
-				resolved: [],
-			},
-		};
-	}
-
-	try {
-		// Resolve config with extends
-		const extendedChain: string[] = [];
-		const rawConfig = await resolveConfigWithExtends(
-			configPath,
-			baseDir,
-			new Set(),
-			extendedChain,
-		);
-
-		// Validate with strict schema
-		const validated = BosConfigSchema.parse(rawConfig);
-
-		// Cache result
-		configCache.set(configPath, { config: validated, timestamp: Date.now() });
-		projectRoot = baseDir;
-		cachedConfig = validated;
-		configLoaded = true;
-
-		// Build runtime config
-		const runtime = buildRuntimeConfig(
-			validated,
-			options?.env ?? "development",
-		);
-
-		return {
-			config: validated,
-			runtime,
-			source: {
-				path: configPath,
-				extended: extendedChain.length > 0 ? extendedChain : undefined,
-				remote: extendedChain.some((e) => e.startsWith("bos://")),
-			},
-			packages: {
-				all: Object.keys(validated.app),
-				resolved: [],
-			},
-		};
-	} catch (error) {
-		if (error instanceof ConfigCircularExtendsError) {
-			throw error;
-		}
-		if (error instanceof ConfigFetchError) {
-			throw error;
-		}
-		if (error instanceof ConfigResolutionError) {
-			throw error;
-		}
-		throw new ConfigResolutionError(
-			`Failed to load config from ${configPath}: ${error}`,
-		);
-	}
+  const configPath = options?.path ?? findConfigPath(options?.cwd);
+  if (!configPath) {
+    projectRoot = options?.cwd ?? process.cwd();
+    return null;
+  }
+
+  const baseDir = dirname(configPath);
+
+  try {
+    const extendedChain: string[] = [];
+    const parsed = await resolveConfigWithExtends(configPath, baseDir, new Set(), extendedChain);
+    const config = BosConfigSchema.parse(parsed);
+
+    cachedConfig = config;
+    projectRoot = baseDir;
+
+    const pluginRuntime = await resolveRuntimePlugins(
+      config.plugins ?? {},
+      baseDir,
+      options?.env ?? "development",
+    );
+    const runtime = buildRuntimeConfig(config, baseDir, options?.env ?? "development", {
+      plugins: pluginRuntime,
+    });
+
+    return {
+      config,
+      runtime,
+      source: {
+        path: configPath,
+        extended: extendedChain.length > 0 ? extendedChain : undefined,
+        remote: extendedChain.some((entry) => entry.startsWith("bos://")),
+      },
+    };
+  } catch (error) {
+    throw new Error(`Failed to load config from ${configPath}: ${error}`);
+  }
 }
 
-/**
- * Resolve packages with modes, existence checks, and auto-remote detection.
- * Merges functionality of resolvePackageModes() and getExistingPackages().
- */
-export async function resolvePackages(
-	packages: string[],
-	requestedModes: Record<string, SourceMode>,
-): Promise<{
-	resolved: Record<string, PackageResolution>;
-	autoRemote: string[];
-}> {
-	const dir = getProjectRoot();
-	const resolved: Record<string, PackageResolution> = {};
-	const autoRemote: string[] = [];
-
-	// Get config for port calculations
-	const config = getConfig();
-
-	for (const pkg of packages) {
-		const exists = await fileExists(`${dir}/${pkg}/package.json`);
-		const requestedMode = requestedModes[pkg] ?? "local";
-
-		// Auto-switch to remote if package doesn't exist locally
-		const mode =
-			!exists && requestedMode === "local" ? "remote" : requestedMode;
-		if (!exists && requestedMode === "local") {
-			autoRemote.push(pkg);
-		}
-
-		// Calculate port and URL
-		let port = 0;
-		let url = "";
-
-		if (config && pkg in config.app) {
-			const pkgConfig = config.app[pkg];
-			if (pkg === "host") {
-				port = parsePort(pkgConfig.development);
-				url = mode === "remote" ? pkgConfig.production : pkgConfig.development;
-			} else {
-				// For ui/api and other packages, access via index signature
-				const devUrl = (pkgConfig as { development?: string }).development;
-				const prodUrl = (pkgConfig as { production?: string }).production;
-				if (devUrl) {
-					port = parsePort(devUrl);
-					url = mode === "remote" ? (prodUrl ?? devUrl) : devUrl;
-				}
-			}
-		}
-
-		resolved[pkg] = { name: pkg, mode, exists, port, url };
-	}
-
-	return { resolved, autoRemote };
+export async function loadBosConfig(options?: {
+  cwd?: string;
+  path?: string;
+  env?: "development" | "production";
+}): Promise<RuntimeConfig> {
+  const result = await loadConfig(options);
+  if (!result) {
+    throw new Error("No bos.config.json found");
+  }
+
+  return result.runtime;
 }
 
-// ============================================================================
-// INTERNAL HELPERS
-// ============================================================================
+export async function buildRuntimePluginsForConfig(
+  config: BosConfig,
+  baseDir: string,
+  env: "development" | "production",
+): Promise<Record<string, RuntimePluginConfig> | undefined> {
+  const plugins = await resolveRuntimePlugins(config.plugins ?? {}, baseDir, env);
+  return Object.keys(plugins).length > 0 ? plugins : undefined;
+}
 
-/**
- * Parse port from URL string.
- */
-export function parsePort(url: string): number {
-	try {
-		const parsed = new URL(url);
-		return parsed.port
-			? parseInt(parsed.port, 10)
-			: parsed.protocol === "https:"
-				? 443
-				: 80;
-	} catch {
-		return 3000;
-	}
+function buildRuntimeConfig(
+  config: BosConfig,
+  baseDir: string,
+  env: "development" | "production",
+  options?: { plugins?: Record<string, RuntimePluginConfig> },
+): RuntimeConfig {
+  const uiConfig = config.app.ui;
+  const apiConfig = config.app.api;
+  const uiRuntime =
+    env === "development"
+      ? resolveRuntimeTarget(uiConfig.development, baseDir)
+      : resolveRuntimeTarget(uiConfig.production, baseDir, "remote");
+  const apiRuntime =
+    env === "development"
+      ? resolveRuntimeTarget(apiConfig.development, baseDir)
+      : resolveRuntimeTarget(apiConfig.production, baseDir, "remote");
+
+  return {
+    env,
+    account: config.account,
+    domain: config.domain,
+    networkId: getNetworkIdForAccount(config.account),
+    repository: config.repository,
+    hostUrl:
+      env === "development"
+        ? resolveDevelopmentHostUrl(config.app.host.development)
+        : config.app.host.production,
+    shared: config.shared,
+    ui: {
+      name: uiConfig.name,
+      url: uiRuntime.url,
+      entry: uiRuntime.url ? `${uiRuntime.url}/mf-manifest.json` : "/mf-manifest.json",
+      localPath: uiRuntime.localPath,
+      port: uiRuntime.port,
+      ssrUrl: uiConfig.ssr,
+      ssrIntegrity: env === "production" ? uiConfig.ssrIntegrity : undefined,
+      integrity: env === "production" ? uiConfig.productionIntegrity : undefined,
+      source: uiRuntime.source,
+    },
+    api: {
+      name: apiConfig.name,
+      url: apiRuntime.url,
+      entry: apiRuntime.url ? `${apiRuntime.url}/mf-manifest.json` : "/mf-manifest.json",
+      localPath: apiRuntime.localPath,
+      port: apiRuntime.port,
+      source: apiRuntime.source,
+      proxy: apiConfig.proxy,
+      variables: apiConfig.variables,
+      secrets: apiConfig.secrets,
+      integrity: env === "production" ? apiConfig.productionIntegrity : undefined,
+    },
+    plugins:
+      options?.plugins && Object.keys(options.plugins).length > 0 ? options.plugins : undefined,
+  };
 }
 
-/**
- * Check if a file exists.
- */
-async function fileExists(path: string): Promise<boolean> {
-	return access(path)
-		.then(() => true)
-		.catch(() => false);
+async function loadConfigFile(configPath: string, baseDir: string): Promise<BosConfigInput> {
+  if (configPath.startsWith("bos://")) {
+    return fetchBosConfigFromFastKv<BosConfigInput>(configPath);
+  }
+
+  const resolvedPath = isAbsolute(configPath) ? configPath : resolve(baseDir, configPath);
+  return JSON.parse(readFileSync(resolvedPath, "utf-8")) as BosConfigInput;
 }
 
-/**
- * Resolve BOS URL to Graph path.
- * bos://{account}/{gateway} → {account}/bos/gateways/{gateway}/bos.config.json
- */
-function resolveBosUrl(bosUrl: string): string {
-	const match = bosUrl.match(/^bos:\/\/([^/]+)\/(.+)$/);
-	if (!match) {
-		throw new ConfigResolutionError(
-			`Invalid BOS URL format: ${bosUrl}. Expected: bos://{account}/{gateway}`,
-		);
-	}
-	const [, account, gateway] = match;
-	return `${account}/bos/gateways/${gateway}/bos.config.json`;
+async function resolveConfigWithExtends(
+  configPath: string,
+  baseDir: string,
+  visited: Set<string>,
+  chain: string[],
+): Promise<BosConfigInput> {
+  if (visited.has(configPath)) {
+    throw new Error(`Circular extends detected: ${[...visited, configPath].join(" -> ")}`);
+  }
+
+  const config = await loadConfigFile(configPath, baseDir);
+  if (configPath.startsWith("bos://")) {
+    chain.push(configPath);
+  }
+
+  if (!config.extends) {
+    return config;
+  }
+
+  const nextVisited = new Set(visited);
+  nextVisited.add(configPath);
+  const parentPath = config.extends;
+  const parentBaseDir = parentPath.startsWith("bos://")
+    ? baseDir
+    : isAbsolute(parentPath)
+      ? dirname(parentPath)
+      : baseDir;
+  const parent = await resolveConfigWithExtends(parentPath, parentBaseDir, nextVisited, chain);
+
+  return mergeConfigs(parent, config);
 }
 
-/**
- * Fetch config from NEAR Social (BOS URL) with 10s timeout.
- */
-async function fetchBosConfig(bosUrl: string): Promise<BosConfigInput> {
-	const configPath = resolveBosUrl(bosUrl);
-	const graph = new Graph();
-
-	try {
-		const data = await Effect.runPromise(
-			Effect.tryPromise({
-				try: () =>
-					Promise.race([
-						graph.get({ keys: [configPath] }),
-						new Promise<never>((_, reject) =>
-							setTimeout(() => reject(new Error("Timeout after 10s")), 10000),
-						),
-					]),
-				catch: (e) => new ConfigFetchError(bosUrl, e),
-			}),
-		);
-
-		if (!data) {
-			throw new ConfigFetchError(bosUrl, "No data returned");
-		}
-
-		// Navigate nested structure
-		const parts = configPath.split("/");
-		let current: unknown = data;
-		for (const part of parts) {
-			if (current && typeof current === "object" && part in current) {
-				current = (current as Record<string, unknown>)[part];
-			} else {
-				throw new ConfigFetchError(bosUrl, `Path not found: ${configPath}`);
-			}
-		}
-
-		if (typeof current !== "string") {
-			throw new ConfigFetchError(bosUrl, "Config is not a string");
-		}
-
-		return JSON.parse(current) as BosConfigInput;
-	} catch (error) {
-		if (error instanceof ConfigFetchError) {
-			throw error;
-		}
-		throw new ConfigFetchError(bosUrl, error);
-	}
+function mergeConfigs(parent: BosConfigInput, child: BosConfigInput): BosConfigInput {
+  const result = mergeValues(parent, child) as BosConfigInput;
+  if (child.plugins !== undefined) {
+    result.plugins = child.plugins;
+  }
+  return result;
 }
 
-/**
- * Load a single config file (local or BOS URL).
- */
-async function loadConfigFile(
-	configPath: string,
-	baseDir?: string,
-): Promise<BosConfigInput> {
-	// BOS URL
-	if (configPath.startsWith("bos://")) {
-		return fetchBosConfig(configPath);
-	}
-
-	// Local file
-	const resolvedPath = isAbsolute(configPath)
-		? configPath
-		: baseDir
-			? resolve(baseDir, configPath)
-			: resolve(process.cwd(), configPath);
-
-	const text = await readFile(resolvedPath, "utf-8");
-	return JSON.parse(text) as BosConfigInput;
+async function resolveRuntimePlugins(
+  plugins: Record<string, BosConfigInput>,
+  baseDir: string,
+  env: "development" | "production",
+  prefix: string[] = [],
+): Promise<Record<string, RuntimePluginConfig>> {
+  const out: Record<string, RuntimePluginConfig> = {};
+
+  for (const [pluginId, pluginInput] of Object.entries(plugins)) {
+    const runtimeKey = [...prefix, pluginId].join("/");
+    const { config: resolvedConfig, baseDir: pluginBaseDir } = await resolveBosConfigInput(
+      pluginInput,
+      baseDir,
+      new Set(),
+      [],
+    );
+
+    const pluginRuntime = buildRuntimePluginConfig(
+      runtimeKey,
+      resolvedConfig,
+      pluginBaseDir,
+      env,
+      pluginInput,
+    );
+    if (
+      pluginRuntime.source === "remote" &&
+      pluginRuntime.url &&
+      !pluginRuntime.localPath &&
+      typeof resolvedConfig.app?.api?.name !== "string"
+    ) {
+      pluginRuntime.name = await resolveRemotePluginRuntimeName(
+        pluginRuntime.url,
+        pluginRuntime.name,
+      );
+    }
+
+    const productionIntegrity = pluginInput.productionIntegrity;
+    if (env === "production" && productionIntegrity) {
+      pluginRuntime.integrity = productionIntegrity;
+    }
+
+    out[runtimeKey] = pluginRuntime;
+
+    if (resolvedConfig.plugins && Object.keys(resolvedConfig.plugins).length > 0) {
+      const nested = await resolveRuntimePlugins(resolvedConfig.plugins, pluginBaseDir, env, [
+        ...prefix,
+        pluginId,
+      ]);
+      Object.assign(out, nested);
+    }
+  }
+
+  return out;
 }
 
-/**
- * Deep merge configs with inheritance.
- * - Objects: recursive merge
- * - Arrays: child replaces parent
- * - Primitives: child wins
- */
-function mergeConfigs(
-	parent: BosConfigInput,
-	child: BosConfigInput,
-): BosConfigInput {
-	const merged: BosConfigInput = { ...parent, ...child };
-
-	// Merge app configs deeply
-	if (parent.app || child.app) {
-		merged.app = { ...parent.app, ...child.app };
-		const parentApps = parent.app || {};
-		const childApps = child.app || {};
-
-		for (const key of new Set([
-			...Object.keys(parentApps),
-			...Object.keys(childApps),
-		])) {
-			const parentApp = parentApps[key as keyof typeof parentApps];
-			const childApp = childApps[key as keyof typeof childApps];
-
-			if (parentApp && childApp) {
-				(merged.app as Record<string, unknown>)[key] = {
-					...parentApp,
-					...childApp,
-				};
-			} else if (childApp) {
-				(merged.app as Record<string, unknown>)[key] = childApp;
-			} else if (parentApp) {
-				(merged.app as Record<string, unknown>)[key] = parentApp;
-			}
-		}
-	}
-
-	// Merge shared deps deeply
-	if (parent.shared || child.shared) {
-		merged.shared = { ...parent.shared, ...child.shared };
-		const parentShared = parent.shared || {};
-		const childShared = child.shared || {};
-
-		// Deep merge each shared category (ui, api, etc.)
-		for (const category of new Set([
-			...Object.keys(parentShared),
-			...Object.keys(childShared),
-		])) {
-			const parentCategory =
-				parentShared[category as keyof typeof parentShared];
-			const childCategory = childShared[category as keyof typeof childShared];
-
-			if (parentCategory && childCategory) {
-				(merged.shared as Record<string, unknown>)[category] = {
-					...parentCategory,
-					...childCategory,
-				};
-			} else if (childCategory) {
-				(merged.shared as Record<string, unknown>)[category] = childCategory;
-			} else if (parentCategory) {
-				(merged.shared as Record<string, unknown>)[category] = parentCategory;
-			}
-		}
-	}
-
-	return merged;
+async function resolveRemotePluginRuntimeName(baseUrl: string, fallback: string): Promise<string> {
+  try {
+    const response = await fetch(`${baseUrl.replace(/\/$/, "")}/plugin.manifest.json`);
+    if (!response.ok) {
+      return fallback;
+    }
+
+    const manifest = (await response.json()) as {
+      plugin?: { name?: unknown };
+    };
+
+    return typeof manifest.plugin?.name === "string" && manifest.plugin.name.length > 0
+      ? manifest.plugin.name
+      : fallback;
+  } catch {
+    return fallback;
+  }
 }
 
-/**
- * Recursively resolve config with extends inheritance.
- */
-async function resolveConfigWithExtends(
-	configPath: string,
-	baseDir: string,
-	visited: Set<string>,
-	chain: string[],
-): Promise<BosConfigInput> {
-	// Check for circular dependencies
-	if (visited.has(configPath)) {
-		throw new ConfigCircularExtendsError([...visited, configPath]);
-	}
-
-	// Load current config
-	const config = await loadConfigFile(configPath, baseDir);
-
-	// Track in chain if it's a BOS URL
-	if (configPath.startsWith("bos://")) {
-		chain.push(configPath);
-	}
-
-	// If no extends, return as-is
-	if (!config.extends) {
-		return config;
-	}
-
-	// Mark as visited
-	const newVisited = new Set(visited);
-	newVisited.add(configPath);
-
-	// Resolve parent
-	const parentPath = config.extends;
-	const parentBaseDir = parentPath.startsWith("bos://")
-		? baseDir
-		: isAbsolute(parentPath)
-			? dirname(parentPath)
-			: baseDir;
-
-	const parentConfig = await resolveConfigWithExtends(
-		parentPath,
-		parentBaseDir,
-		newVisited,
-		chain,
-	);
-
-	// Merge and return
-	return mergeConfigs(parentConfig, config);
+function buildRuntimePluginConfig(
+  pluginId: string,
+  config: BosConfigInput,
+  baseDir: string,
+  env: "development" | "production",
+  source: BosConfigInput,
+): RuntimePluginConfig {
+  const apiConfig = config.app?.api ?? {};
+  const apiDevelopment =
+    typeof apiConfig.development === "string" ? apiConfig.development : undefined;
+  const apiProduction = typeof apiConfig.production === "string" ? apiConfig.production : undefined;
+  const sourceDevelopment = typeof source.development === "string" ? source.development : undefined;
+  const sourceProduction = typeof source.production === "string" ? source.production : undefined;
+  const proxy = typeof apiConfig.proxy === "string" ? apiConfig.proxy : undefined;
+  const runtimeTarget =
+    env === "development"
+      ? resolveRuntimeTarget(apiDevelopment ?? sourceDevelopment, baseDir)
+      : resolveRuntimeTarget(apiProduction ?? sourceProduction, baseDir, "remote");
+  const apiName = resolvePluginRuntimeName(
+    typeof apiConfig.name === "string" ? apiConfig.name : undefined,
+    runtimeTarget.localPath,
+    pluginId,
+  );
+
+  return {
+    name: apiName,
+    url: runtimeTarget.url,
+    entry: runtimeTarget.url
+      ? `${runtimeTarget.url.replace(/\/$/, "")}/mf-manifest.json`
+      : "/mf-manifest.json",
+    source: runtimeTarget.source,
+    localPath: runtimeTarget.localPath,
+    port: runtimeTarget.port,
+    proxy: proxy ?? (typeof source.proxy === "string" ? source.proxy : undefined),
+    variables: normalizeStringRecord(apiConfig.variables ?? source.variables),
+    secrets: normalizeStringArray(apiConfig.secrets ?? source.secrets),
+  };
 }
 
-/**
- * Build runtime config from BosConfig.
- */
-function buildRuntimeConfig(
-	config: BosConfig,
-	env: "development" | "production",
-): RuntimeConfig {
-	const uiConfig = config.app.ui as RemoteConfig | undefined;
-	const apiConfig = config.app.api as RemoteConfig | undefined;
-
-	// Extract properties from api config
-	const apiProxy = apiConfig?.proxy;
-	const apiVariables = apiConfig?.variables;
-	const apiSecrets = apiConfig?.secrets;
-
-	// Env var overrides
-	const uiUrlOverride = process.env.BOS_UI_URL;
-	const uiSsrUrlOverride = process.env.BOS_UI_SSR_URL;
-
-	return {
-		env,
-		account: config.account,
-		title: config.account,
-		hostUrl: config.app.host[env],
-		shared: config.shared,
-		ui: {
-			name: uiConfig?.name ?? "ui",
-			url: uiUrlOverride ?? uiConfig?.[env] ?? "",
-			entry: `${uiUrlOverride ?? uiConfig?.[env] ?? ""}/remoteEntry.js`,
-			ssrUrl: uiSsrUrlOverride ?? uiConfig?.ssr,
-			source: env === "development" ? "local" : "remote",
-		},
-		api: {
-			name: apiConfig?.name ?? "api",
-			url: apiConfig?.[env] ?? "",
-			entry: `${apiConfig?.[env] ?? ""}/remoteEntry.js`,
-			source: env === "development" ? "local" : "remote",
-			proxy: apiProxy,
-			variables: apiVariables,
-			secrets: apiSecrets,
-		},
-	};
+function resolvePluginRuntimeName(
+  explicitName: string | undefined,
+  localPath: string | undefined,
+  fallback: string,
+): string {
+  if (explicitName) {
+    return explicitName;
+  }
+
+  if (!localPath) {
+    return fallback;
+  }
+
+  try {
+    const packageJsonPath = join(localPath, "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as { name?: unknown };
+    if (typeof packageJson.name === "string" && packageJson.name.length > 0) {
+      return packageJson.name;
+    }
+  } catch {}
+
+  return fallback;
+}
+
+async function resolveBosConfigInput(
+  input: BosConfigInput,
+  baseDir: string,
+  visited: Set<string>,
+  chain: string[],
+): Promise<{ config: BosConfigInput; baseDir: string }> {
+  if (input.extends) {
+    const parentBaseDir = input.extends.startsWith("bos://")
+      ? baseDir
+      : isAbsolute(input.extends)
+        ? dirname(input.extends)
+        : baseDir;
+    const config = await resolveConfigWithExtends(input.extends, parentBaseDir, visited, chain);
+    return { config: mergeConfigs(config, input), baseDir: parentBaseDir };
+  }
+
+  return { config: input, baseDir };
+}
+
+function mergeValues(parent: unknown, child: unknown): unknown {
+  if (Array.isArray(parent) && Array.isArray(child)) {
+    return child;
+  }
+
+  if (isPlainObject(parent) && isPlainObject(child)) {
+    const merged: Record<string, unknown> = { ...parent };
+    for (const [key, value] of Object.entries(child)) {
+      merged[key] = key in merged ? mergeValues(merged[key], value) : value;
+    }
+    return merged;
+  }
+
+  return child ?? parent;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function normalizeStringRecord(value: unknown): Record<string, string> | undefined {
+  if (!isPlainObject(value)) return undefined;
+  const out: Record<string, string> = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string") {
+      out[key] = raw;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function normalizeStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const out = value.filter((item): item is string => typeof item === "string" && item.length > 0);
+  return out.length > 0 ? out : undefined;
+}
+
+function resolveRuntimeTarget(
+  value: string | undefined,
+  baseDir: string,
+  defaultSource: "local" | "remote" = "remote",
+): RuntimeTarget {
+  if (!value) {
+    return { source: defaultSource, url: "" };
+  }
+
+  if (value.startsWith(LOCAL_PREFIX)) {
+    const localTarget = value.slice(LOCAL_PREFIX.length).trim();
+    if (!localTarget) {
+      throw new Error(`Invalid local development target: ${value}`);
+    }
+
+    return {
+      source: "local",
+      url: "",
+      localPath: resolve(baseDir, localTarget),
+    };
+  }
+
+  return {
+    source: defaultSource,
+    url: value.replace(/\/$/, ""),
+    port: parsePort(value),
+  };
+}
+
+export function isLocalDevelopmentTarget(value: string | undefined): boolean {
+  return typeof value === "string" && value.startsWith(LOCAL_PREFIX);
 }
+
+export function resolveLocalDevelopmentPath(
+  value: string | undefined,
+  baseDir: string,
+): string | null {
+  if (!isLocalDevelopmentTarget(value)) {
+    return null;
+  }
+
+  const localTarget = value!.slice(LOCAL_PREFIX.length).trim();
+  return localTarget ? resolve(baseDir, localTarget) : null;
+}
+
+export function resolveDevelopmentHostUrl(value: string | undefined): string {
+  if (!value || isLocalDevelopmentTarget(value)) {
+    return `http://localhost:${DEFAULT_HOST_PORT}`;
+  }
+
+  return value.replace(/\/$/, "");
+}
+
+export function getHostDevelopmentPort(value: string | undefined): number {
+  return parsePort(resolveDevelopmentHostUrl(value));
+}
+
+export function parsePort(url: string): number {
+  try {
+    const parsed = new URL(url);
+    return parsed.port ? parseInt(parsed.port, 10) : parsed.protocol === "https:" ? 443 : 80;
+  } catch {
+    return 3000;
+  }
+}
+
+export type { BosConfig, RuntimeConfig } from "./types";
+export { BosConfigSchema } from "./types";