everything-dev 0.2.0 → 0.3.0

package/src/types.ts

@@ -4,132 +4,231 @@ export const SourceModeSchema = z.enum(["local", "remote"]);
 export type SourceMode = z.infer<typeof SourceModeSchema>;
 
 export const HostConfigSchema = z.object({
-  development: z.string(),
-  production: z.string(),
-  secrets: z.array(z.string()).optional(),
-  template: z.string().optional(),
-  files: z.array(z.string()).optional(),
-  sync: z.lazy(() => SyncConfigSchema).optional(),
+	development: z.string(),
+	production: z.string(),
+	secrets: z.array(z.string()).optional(),
+	template: z.string().optional(),
+	files: z.array(z.string()).optional(),
+	sync: z.lazy(() => SyncConfigSchema).optional(),
 });
 export type HostConfig = z.infer<typeof HostConfigSchema>;
 
 export const RemoteConfigSchema = z.object({
-  name: z.string(),
-  development: z.string(),
-  production: z.string(),
-  ssr: z.string().optional(),
-  proxy: z.string().optional(),
-  variables: z.record(z.string(), z.string()).optional(),
-  secrets: z.array(z.string()).optional(),
-  template: z.string().optional(),
-  files: z.array(z.string()).optional(),
-  sync: z.lazy(() => SyncConfigSchema).optional(),
+	name: z.string(),
+	development: z.string(),
+	production: z.string(),
+	ssr: z.string().optional(),
+	proxy: z.string().optional(),
+	variables: z.record(z.string(), z.string()).optional(),
+	secrets: z.array(z.string()).optional(),
+	template: z.string().optional(),
+	files: z.array(z.string()).optional(),
+	sync: z.lazy(() => SyncConfigSchema).optional(),
 });
 export type RemoteConfig = z.infer<typeof RemoteConfigSchema>;
 
+/**
+ * Partial RemoteConfig for input configs (child configs that extend a base).
+ * Only 'name' is required; development/production can be inherited.
+ */
+export const PartialRemoteConfigSchema = z.object({
+	name: z.string(),
+	development: z.string().optional(),
+	production: z.string().optional(),
+	proxy: z.string().optional(),
+	variables: z.record(z.string(), z.string()).optional(),
+	secrets: z.array(z.string()).optional(),
+	template: z.string().optional(),
+	files: z.array(z.string()).optional(),
+	sync: z.lazy(() => SyncConfigSchema).optional(),
+});
+export type PartialRemoteConfig = z.infer<typeof PartialRemoteConfigSchema>;
+
 export const NovaConfigSchema = z.object({
-  account: z.string(),
+	account: z.string(),
 });
 export type NovaConfig = z.infer<typeof NovaConfigSchema>;
 
 export const GatewayConfigSchema = z.object({
-  development: z.string(),
-  production: z.string(),
-  account: z.string().optional(),
-  nova: NovaConfigSchema.optional(),
+	development: z.string(),
+	production: z.string(),
+	account: z.string().optional(),
+	nova: NovaConfigSchema.optional(),
 });
 export type GatewayConfig = z.infer<typeof GatewayConfigSchema>;
 
 export const SharedDepConfigSchema = z.object({
-  requiredVersion: z.string().optional(),
-  singleton: z.boolean().optional(),
-  eager: z.boolean().optional(),
-  strictVersion: z.boolean().optional(),
+	requiredVersion: z.string().optional(),
+	singleton: z.boolean().optional(),
+	eager: z.boolean().optional(),
+	strictVersion: z.boolean().optional(),
 });
 export type SharedDepConfig = z.infer<typeof SharedDepConfigSchema>;
 
 export const SyncConfigSchema = z.object({
-  scripts: z.union([z.array(z.string()), z.literal(true)]).optional(),
-  dependencies: z.boolean().default(true),
-  devDependencies: z.boolean().default(true),
+	scripts: z.union([z.array(z.string()), z.literal(true)]).optional(),
+	dependencies: z.boolean().default(true),
+	devDependencies: z.boolean().default(true),
 });
 export type SyncConfig = z.infer<typeof SyncConfigSchema>;
 
 export const BosConfigSchema = z.object({
-  account: z.string(),
-  testnet: z.string().optional(),
-  nova: NovaConfigSchema.optional(),
-  gateway: GatewayConfigSchema,
-  template: z.string().optional(),
-  cli: z.object({
-    version: z.string().optional(),
-  }).optional(),
-  shared: z.record(z.string(), z.record(z.string(), SharedDepConfigSchema)).optional(),
-  app: z.object({
-    host: HostConfigSchema,
-  }).catchall(z.union([HostConfigSchema, RemoteConfigSchema])),
+	extends: z.string().optional(),
+	account: z.string(),
+	testnet: z.string().optional(),
+	nova: NovaConfigSchema.optional(),
+	gateway: GatewayConfigSchema,
+	template: z.string().optional(),
+	cli: z
+		.object({
+			version: z.string().optional(),
+		})
+		.optional(),
+	shared: z
+		.record(z.string(), z.record(z.string(), SharedDepConfigSchema))
+		.optional(),
+	app: z
+		.object({
+			host: HostConfigSchema,
+		})
+		.catchall(z.union([RemoteConfigSchema, HostConfigSchema])),
 });
 export type BosConfig = z.infer<typeof BosConfigSchema>;
 
+/**
+ * BosConfigInputSchema - permissive schema for parsing input configs.
+ * Supports extends and allows partial app configs (child overrides only what it needs).
+ * After resolving extends, the result must be validated against the strict BosConfigSchema.
+ */
+export const BosConfigInputSchema = z.object({
+	extends: z.string().optional(),
+	account: z.string().optional(),
+	testnet: z.string().optional(),
+	nova: NovaConfigSchema.optional(),
+	gateway: GatewayConfigSchema.optional(),
+	template: z.string().optional(),
+	cli: z
+		.object({
+			version: z.string().optional(),
+		})
+		.optional(),
+	shared: z
+		.record(z.string(), z.record(z.string(), SharedDepConfigSchema))
+		.optional(),
+	app: z
+		.object({
+			host: HostConfigSchema.optional(),
+			ui: PartialRemoteConfigSchema.optional(),
+			api: PartialRemoteConfigSchema.optional(),
+		})
+		.partial()
+		.catchall(z.union([HostConfigSchema, PartialRemoteConfigSchema])),
+});
+export type BosConfigInput = z.infer<typeof BosConfigInputSchema>;
+
 export const AppConfigSchema = z.object({
-  host: SourceModeSchema,
-  ui: SourceModeSchema,
-  api: SourceModeSchema,
-  proxy: z.boolean().optional(),
+	host: SourceModeSchema,
+	ui: SourceModeSchema,
+	api: SourceModeSchema,
+	proxy: z.boolean().optional(),
 });
 export type AppConfig = z.infer<typeof AppConfigSchema>;
 
 export const PortConfigSchema = z.object({
-  host: z.number(),
-  ui: z.number(),
-  api: z.number(),
+	host: z.number(),
+	ui: z.number(),
+	api: z.number(),
 });
 export type PortConfig = z.infer<typeof PortConfigSchema>;
 
 export const SharedConfigSchema = z.object({
-  requiredVersion: z.string().optional(),
-  singleton: z.boolean().optional(),
-  eager: z.boolean().optional(),
-  strictVersion: z.boolean().optional(),
-  shareScope: z.string().optional(),
+	requiredVersion: z.string().optional(),
+	singleton: z.boolean().optional(),
+	eager: z.boolean().optional(),
+	strictVersion: z.boolean().optional(),
+	shareScope: z.string().optional(),
 });
 export type SharedConfig = z.infer<typeof SharedConfigSchema>;
 
+/**
+ * Federation entry info - both base URL and computed manifest entry
+ */
+export const FederationEntrySchema = z.object({
+	name: z.string(),
+	url: z.string(), // Base/assets URL
+	entry: z.string(), // Computed federation entry (mf-manifest.json or remoteEntry.js)
+	source: SourceModeSchema,
+});
+export type FederationEntry = z.infer<typeof FederationEntrySchema>;
+
 export const RuntimeConfigSchema = z.object({
-  env: z.enum(["development", "production"]),
-  account: z.string(),
-  title: z.string().optional(),
-  hostUrl: z.string(),
-  shared: z.object({
-    ui: z.record(z.string(), SharedConfigSchema).optional(),
-  }).optional(),
-  ui: z.object({
-    name: z.string(),
-    url: z.string(),
-    ssrUrl: z.string().optional(),
-    source: SourceModeSchema,
-  }),
-  api: z.object({
-    name: z.string(),
-    url: z.string(),
-    source: SourceModeSchema,
-    proxy: z.string().optional(),
-    variables: z.record(z.string(), z.string()).optional(),
-    secrets: z.array(z.string()).optional(),
-  }),
+	env: z.enum(["development", "production"]),
+	account: z.string(),
+	title: z.string().optional(),
+	hostUrl: z.string(),
+	shared: z
+		.object({
+			ui: z.record(z.string(), SharedConfigSchema).optional(),
+		})
+		.optional(),
+	ui: FederationEntrySchema.extend({
+		ssrUrl: z.string().optional(),
+	}),
+	api: FederationEntrySchema.extend({
+		proxy: z.string().optional(),
+		variables: z.record(z.string(), z.string()).optional(),
+		secrets: z.array(z.string()).optional(),
+	}),
 });
 export type RuntimeConfig = z.infer<typeof RuntimeConfigSchema>;
 
+/**
+ * Client-side runtime config (injected via window.__RUNTIME_CONFIG__)
+ * Contains federation entry info so browser can load remotes via manifest
+ */
 export const ClientRuntimeConfigSchema = z.object({
-  env: z.enum(["development", "production"]),
-  account: z.string(),
-  hostUrl: z.string().optional(),
-  assetsUrl: z.string(),
-  apiBase: z.string(),
-  rpcBase: z.string(),
-  ui: z.object({
-    name: z.string(),
-    url: z.string(),
-  }).optional(),
+	env: z.enum(["development", "production"]),
+	account: z.string(),
+	hostUrl: z.string().optional(),
+	assetsUrl: z.string(), // Legacy: use ui.entry for MF loading
+	apiBase: z.string(),
+	rpcBase: z.string(),
+	ui: z
+		.object({
+			name: z.string(),
+			url: z.string(), // Base URL for assets
+			entry: z.string(), // Federation entry (mf-manifest.json)
+		})
+		.optional(),
 });
 export type ClientRuntimeConfig = z.infer<typeof ClientRuntimeConfigSchema>;
+
+/**
+ * Error thrown when a circular extends dependency is detected
+ */
+export class ConfigCircularExtendsError extends Error {
+	constructor(chain: string[]) {
+		super(`Circular extends detected: ${chain.join(" → ")}`);
+		this.name = "ConfigCircularExtendsError";
+	}
+}
+
+/**
+ * Error thrown when config fetching fails
+ */
+export class ConfigFetchError extends Error {
+	constructor(url: string, cause: unknown) {
+		super(`Failed to fetch config from ${url}: ${cause}`);
+		this.name = "ConfigFetchError";
+	}
+}
+
+/**
+ * Error thrown when config resolution fails
+ */
+export class ConfigResolutionError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "ConfigResolutionError";
+	}
+}

package/src/ui/head.ts

@@ -2,35 +2,46 @@ import type { ClientRuntimeConfig } from "../types";
 import type { HeadScript } from "./types";
 
 export interface RemoteScriptsOptions {
-  assetsUrl: string;
-  runtimeConfig?: ClientRuntimeConfig;
-  containerName?: string;
-  hydratePath?: string;
+	assetsUrl: string;
+	runtimeConfig?: ClientRuntimeConfig;
+	containerName?: string;
+	hydratePath?: string;
 }
 
 export function getRemoteEntryScript(assetsUrl: string): HeadScript {
-  return {
-    src: `${assetsUrl}/remoteEntry.js`,
-  };
+	return {
+		src: `${assetsUrl}/remoteEntry.js`,
+	};
 }
 
 export function getThemeInitScript(): HeadScript {
-  return {
-    children: `(function(){var t=localStorage.getItem('theme');if(t==='dark'||(!t&&window.matchMedia('(prefers-color-scheme: dark)').matches)){document.documentElement.classList.add('dark');}})();`,
-  };
+	return {
+		children: `(function(){var t=localStorage.getItem('theme');if(t==='dark'||(!t&&window.matchMedia('(prefers-color-scheme: dark)').matches)){document.documentElement.classList.add('dark');}})();`,
+	};
 }
 
 export function getHydrateScript(
-  runtimeConfig: ClientRuntimeConfig | undefined,
-  containerName = "ui",
-  hydratePath = "./Hydrate"
+	runtimeConfig: ClientRuntimeConfig | undefined,
+	containerName = "ui",
+	hydratePath = "./Hydrate",
 ): HeadScript {
-  return {
-    children: `
-window.__RUNTIME_CONFIG__=${JSON.stringify(runtimeConfig)};
-function __hydrate(){
+	return {
+		children: `
+ window.__RUNTIME_CONFIG__=${JSON.stringify(runtimeConfig)};
+ function __hydrate(){
   var container = window['${containerName}'];
-  if (!container) { console.error('[Hydrate] Container not found'); return; }
+  if (!container) {
+    console.warn('[Hydrate] Container not ready yet, waiting...');
+    window.__hydrateRetry = window.__hydrateRetry || 0;
+    if (window.__hydrateRetry < 10) {
+      window.__hydrateRetry++;
+      setTimeout(__hydrate, 100);
+      return;
+    }
+    console.error('[Hydrate] Container not found after 10 retries');
+    return;
+  }
+  console.log('[Hydrate] Container available, starting init...');
   container.init({}).then(function(){
     return container.get('${hydratePath}');
   }).then(function(mod){
@@ -41,21 +52,21 @@ function __hydrate(){
 }
 if(document.readyState==='loading'){document.addEventListener('DOMContentLoaded',__hydrate);}else{__hydrate();}
     `.trim(),
-  };
+	};
 }
 
 export function getRemoteScripts(options: RemoteScriptsOptions): HeadScript[] {
-  const { assetsUrl, runtimeConfig, containerName, hydratePath } = options;
+	const { assetsUrl, runtimeConfig, containerName, hydratePath } = options;
 
-  return [
-    getRemoteEntryScript(assetsUrl),
-    getThemeInitScript(),
-    getHydrateScript(runtimeConfig, containerName, hydratePath),
-  ];
+	return [
+		getRemoteEntryScript(assetsUrl),
+		getThemeInitScript(),
+		getHydrateScript(runtimeConfig, containerName, hydratePath),
+	];
 }
 
 export function getBaseStyles(): string {
-  return `
+	return `
 *, *::before, *::after { box-sizing: border-box; }
 html { height: 100%; height: 100dvh; -webkit-text-size-adjust: 100%; text-size-adjust: 100%; color-scheme: light dark; }
 body { min-height: 100%; min-height: 100dvh; margin: 0; background-color: var(--background); color: var(--foreground); -webkit-tap-highlight-color: transparent; touch-action: manipulation; }

package/src/utils/banner.ts

@@ -1,4 +1,4 @@
-import { gradients, colors, divider } from "./theme";
+import { colors, divider, gradients } from "./theme";
 
 const ASCII_BOS = `
   ██████╗  ██████╗ ███████╗
@@ -8,12 +8,10 @@ const ASCII_BOS = `
   ██████╔╝╚██████╔╝███████║
   ╚═════╝  ╚═════╝ ╚══════╝`;
 
-export function printBanner(title?: string, version = "1.0.0") {
-  console.log(gradients.cyber(ASCII_BOS));
-  console.log();
-  if (title) {
-    console.log(colors.dim(`  ${title} ${colors.cyan(`v${version}`)}`));
-    console.log(colors.dim(`  ${divider(30)}`));
-  }
-  console.log();
+export function printBanner(title = "everything-dev", version = "1.0.0") {
+	console.log(gradients.cyber(ASCII_BOS));
+	console.log();
+	console.log(colors.dim(`  ${title} ${colors.cyan(`v${version}`)}`));
+	console.log(colors.dim(`  ${divider(30)}`));
+	console.log();
 }

package/src/utils/run.ts

@@ -1,21 +1,32 @@
-import { execa, type Options as ExecaOptions } from "execa";
 import chalk from "chalk";
-import { getConfigDir } from "../config";
+import { type Options as ExecaOptions, execa } from "execa";
+import { getProjectRoot } from "../config";
 
 export async function run(
-  cmd: string,
-  args: string[],
-  options: { cwd?: string; env?: Record<string, string> } = {}
+	cmd: string,
+	args: string[],
+	options: { cwd?: string; env?: Record<string, string> } = {},
 ) {
-  console.log(chalk.dim(`$ ${cmd} ${args.join(" ")}`));
-  const execaOptions: ExecaOptions = {
-    cwd: options.cwd ?? getConfigDir(),
-    stdio: "inherit",
-    reject: false,
-    env: options.env ? { ...process.env, ...options.env } : undefined,
-  };
-  const result = await execa(cmd, args, execaOptions);
-  if (result.exitCode !== 0) {
-    process.exit(result.exitCode);
-  }
+	console.log(chalk.dim(`$ ${cmd} ${args.join(" ")}`));
+
+	// Get project root, fallback to cwd if config not loaded
+	let cwd = options.cwd;
+	if (!cwd) {
+		try {
+			cwd = getProjectRoot();
+		} catch {
+			cwd = process.cwd();
+		}
+	}
+
+	const execaOptions: ExecaOptions = {
+		cwd,
+		stdio: "inherit",
+		reject: false,
+		env: options.env ? { ...process.env, ...options.env } : undefined,
+	};
+	const result = await execa(cmd, args, execaOptions);
+	if (result.exitCode !== 0) {
+		process.exit(result.exitCode);
+	}
 }

package/src/lib/secrets.ts

@@ -1,29 +0,0 @@
-import { loadConfig } from "../config";
-
-export function loadSecretsFor(component: string): Record<string, string> {
-  const config = loadConfig();
-  if (!config) return {};
-  const componentConfig = config.app[component];
-  if (!componentConfig) return {};
-
-  const secretNames = ("secrets" in componentConfig ? componentConfig.secrets : undefined) ?? [];
-  if (secretNames.length === 0) return {};
-
-  const secrets: Record<string, string> = {};
-  for (const name of secretNames) {
-    const value = process.env[name];
-    if (value) secrets[name] = value;
-  }
-
-  return secrets;
-}
-
-export function loadAllSecrets(): {
-  host: Record<string, string>;
-  api: Record<string, string>;
-} {
-  return {
-    host: loadSecretsFor("host"),
-    api: loadSecretsFor("api"),
-  };
-}