everything-dev 1.16.3 → 1.17.0

package/src/config.ts

@@ -3,6 +3,7 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fetchBosConfigFromFastKv } from "./fastkv";
 import {
   type BosEnv,
+  bosConfigMerger,
   isPlainObject,
   mergeBosConfigWithExtends,
   type ResolvedConfigMeta,
@@ -18,7 +19,6 @@ import type {
   PluginEntryValue,
   RuntimeConfig,
   RuntimePluginConfig,
-  SharedDepConfig,
 } from "./types";
 import { BosConfigSchema } from "./types";
 
@@ -74,6 +74,18 @@ export interface ConfigResult {
   };
 }
 
+export interface ResolvedComposableReference {
+  entry: BosPluginRef;
+  providerBaseDir: string;
+  targetPath: string;
+  associatedUi?: Record<string, unknown>;
+}
+
+interface ParsedExtendsTarget {
+  configPath: string;
+  targetPath?: string;
+}
+
 export async function loadConfig(options?: {
   cwd?: string;
   path?: string;
@@ -98,7 +110,11 @@ export async function loadConfig(options?: {
       extendedChain,
       env,
     );
-    const config = BosConfigSchema.parse(parsed);
+    const config = await resolveRootComposableEntries(
+      BosConfigSchema.parse(parsed),
+      baseDir,
+      runtimeEnv,
+    );
 
     cachedConfig = config;
     projectRoot = baseDir;
@@ -144,6 +160,31 @@ export async function buildRuntimePluginsForConfig(
   return Object.keys(plugins).length > 0 ? plugins : undefined;
 }
 
+async function resolveRootComposableEntries(
+  config: BosConfig,
+  baseDir: string,
+  env: BosEnv,
+): Promise<BosConfig> {
+  const resolvedApi = await resolveComposableReference(
+    config.app.api as BosPluginRef,
+    baseDir,
+    env,
+    "app.api",
+  );
+  const resolvedAuth = config.app.auth
+    ? await resolveComposableReference(config.app.auth as BosPluginRef, baseDir, env, "app.auth")
+    : undefined;
+
+  return {
+    ...config,
+    app: {
+      ...config.app,
+      api: resolvedApi.entry,
+      auth: resolvedAuth?.entry,
+    },
+  };
+}
+
 export function getResolvedConfigPath(configDir: string): string {
   return join(configDir, ".bos", RESOLVED_CONFIG_FILENAME);
 }
@@ -216,6 +257,173 @@ export function readBosConfigForBuild(configDir: string): Record<string, unknown
   return JSON.parse(readFileSync(bosConfigPath, "utf-8")) as Record<string, unknown>;
 }
 
+function parseExtendsTarget(ref: string): ParsedExtendsTarget {
+  const hashIndex = ref.indexOf("#");
+  if (hashIndex === -1) {
+    return { configPath: ref };
+  }
+
+  const configPath = ref.slice(0, hashIndex);
+  const targetPath = ref.slice(hashIndex + 1);
+  return {
+    configPath,
+    targetPath: targetPath.length > 0 ? targetPath : undefined,
+  };
+}
+
+function getConfigBaseDir(configPath: string, baseDir: string): string {
+  if (configPath.startsWith("bos://")) return baseDir;
+  return dirname(isAbsolute(configPath) ? configPath : resolve(baseDir, configPath));
+}
+
+function asComposableEntry(value: unknown): BosPluginRef {
+  if (typeof value === "string") {
+    return { extends: value };
+  }
+  if (!isPlainObject(value)) {
+    throw new Error(`Expected config entry object, received ${typeof value}`);
+  }
+  return value as BosPluginRef;
+}
+
+function getTargetedEntry(config: BosConfigInput, targetPath: string): BosPluginRef {
+  if (targetPath === "app.api") {
+    return asComposableEntry(config.app?.api);
+  }
+
+  if (targetPath === "app.auth") {
+    return asComposableEntry(config.app?.auth);
+  }
+
+  if (targetPath.startsWith("plugins.")) {
+    const pluginId = targetPath.slice("plugins.".length);
+    if (pluginId.length === 0) {
+      throw new Error(`Invalid plugin target path: ${targetPath}`);
+    }
+    return asComposableEntry(config.plugins?.[pluginId]);
+  }
+
+  throw new Error(`Unsupported extends target path: ${targetPath}`);
+}
+
+function getAssociatedUi(
+  config: BosConfigInput,
+  _targetPath: string,
+): Record<string, unknown> | undefined {
+  return isPlainObject(config.app?.ui) ? (config.app.ui as Record<string, unknown>) : undefined;
+}
+
+function mergeComposableEntries(
+  parent: Partial<BosPluginRef>,
+  child: Partial<BosPluginRef>,
+): BosPluginRef {
+  return bosConfigMerger({ ...child }, parent) as BosPluginRef;
+}
+
+function stripUnsafeLocalDevelopment<T extends Record<string, unknown> | undefined>(
+  entry: T,
+  allowLocalPaths: boolean,
+): T {
+  if (!entry || allowLocalPaths) {
+    return entry;
+  }
+
+  if (typeof entry.development === "string" && entry.development.startsWith(LOCAL_PREFIX)) {
+    const { development: _ignored, ...rest } = entry;
+    return rest as T;
+  }
+
+  return entry;
+}
+
+export async function resolveComposableReference(
+  source: BosPluginRef,
+  baseDir: string,
+  env: BosEnv,
+  defaultTargetPath: string,
+): Promise<ResolvedComposableReference> {
+  let resolvedEntry: BosPluginRef = {};
+  let providerBaseDir = baseDir;
+  let targetPath = defaultTargetPath;
+  let associatedUi: Record<string, unknown> | undefined;
+  let allowLocalPaths = false;
+  let extendsError: unknown;
+
+  const extendsRef = source.extends ? resolveExtendsRef(source.extends, env) : undefined;
+  if (extendsRef) {
+    const parsed = parseExtendsTarget(extendsRef);
+    targetPath = parsed.targetPath ?? defaultTargetPath;
+    const extendsBaseDir = getConfigBaseDir(parsed.configPath, baseDir);
+    try {
+      const extendedConfig = await resolveConfigWithExtends(
+        parsed.configPath,
+        extendsBaseDir,
+        new Set(),
+        [],
+        env,
+      );
+      resolvedEntry = mergeComposableEntries(
+        resolvedEntry,
+        getTargetedEntry(extendedConfig, targetPath),
+      );
+      providerBaseDir = extendsBaseDir;
+      associatedUi = getAssociatedUi(extendedConfig, targetPath);
+    } catch (error) {
+      extendsError = error;
+    }
+  }
+
+  const localDevelopment =
+    typeof source.development === "string" && source.development.startsWith(LOCAL_PREFIX)
+      ? source.development
+      : undefined;
+
+  if (localDevelopment) {
+    const localPath = resolve(baseDir, localDevelopment.slice(LOCAL_PREFIX.length).trim());
+    const localConfigPath = join(localPath, "bos.config.json");
+    if (existsSync(localConfigPath)) {
+      const localConfig = await resolveConfigWithExtends(
+        localConfigPath,
+        localPath,
+        new Set(),
+        [],
+        env,
+      );
+      resolvedEntry = mergeComposableEntries(
+        resolvedEntry,
+        getTargetedEntry(localConfig, targetPath),
+      );
+      providerBaseDir = localPath;
+      associatedUi = getAssociatedUi(localConfig, targetPath);
+      allowLocalPaths = true;
+    }
+  }
+
+  const sourceOverrides = { ...source };
+  if (allowLocalPaths && localDevelopment) {
+    delete sourceOverrides.development;
+  }
+
+  resolvedEntry = mergeComposableEntries(resolvedEntry, sourceOverrides);
+
+  if (
+    extendsError &&
+    !allowLocalPaths &&
+    typeof resolvedEntry.development !== "string" &&
+    typeof resolvedEntry.production !== "string" &&
+    typeof resolvedEntry.name !== "string"
+  ) {
+    throw extendsError;
+  }
+
+  return {
+    entry: stripUnsafeLocalDevelopment(resolvedEntry, allowLocalPaths || Boolean(localDevelopment)),
+    providerBaseDir,
+    targetPath,
+    associatedUi: stripUnsafeLocalDevelopment(associatedUi, allowLocalPaths),
+  };
+}
+
 function resolveDevelopmentTarget(
   development: string | undefined,
   production: string | undefined,
@@ -225,6 +433,9 @@ function resolveDevelopmentTarget(
   if (forceSource === "remote") {
     return resolveRuntimeTarget(production, baseDir, "remote");
   }
+  if (!development) {
+    return resolveRuntimeTarget(production, baseDir, "remote");
+  }
   const devTarget = resolveRuntimeTarget(development, baseDir);
   if (devTarget.source === "local" && (!devTarget.localPath || !existsSync(devTarget.localPath))) {
     return resolveRuntimeTarget(production, baseDir, "remote");
@@ -298,6 +509,7 @@ export function buildRuntimeConfig(
   const hostIsRemote = hostRuntime.source === "remote";
   const uiIsRemote = uiRuntime.source === "remote";
   const apiIsRemote = apiRuntime.source === "remote";
+  const resolvedApiName = resolvePluginRuntimeName(apiConfig.name, apiRuntime.localPath, "api");
 
   return {
     env,
@@ -331,7 +543,7 @@ export function buildRuntimeConfig(
       source: uiRuntime.source,
     },
     api: {
-      name: apiConfig.name,
+      name: resolvedApiName,
       url: apiRuntime.url,
       entry: apiRuntime.url ? `${apiRuntime.url}/mf-manifest.json` : "/mf-manifest.json",
       localPath: apiRuntime.localPath,
@@ -345,7 +557,7 @@ export function buildRuntimeConfig(
     auth: (() => {
       if (!authConfig || !authRuntime) return undefined;
       return {
-        name: resolvePluginRuntimeName(undefined, authRuntime.localPath, authConfig.name),
+        name: resolvePluginRuntimeName(authConfig.name, authRuntime.localPath, "auth"),
         url: authRuntime.url,
         entry: authRuntime.url ? `${authRuntime.url}/mf-manifest.json` : "/mf-manifest.json",
         localPath: authRuntime.localPath,
@@ -399,14 +611,18 @@ async function resolveConfigWithExtends(
     return config;
   }
 
+  const parsedParentRef = parseExtendsTarget(extendsRef);
+
   const nextVisited = new Set(visited);
   nextVisited.add(configPath);
-  const parentBaseDir = extendsRef.startsWith("bos://")
-    ? baseDir
-    : isAbsolute(extendsRef)
-      ? dirname(extendsRef)
-      : baseDir;
-  const parent = await resolveConfigWithExtends(extendsRef, parentBaseDir, nextVisited, chain, env);
+  const parentBaseDir = getConfigBaseDir(parsedParentRef.configPath, baseDir);
+  const parent = await resolveConfigWithExtends(
+    parsedParentRef.configPath,
+    parentBaseDir,
+    nextVisited,
+    chain,
+    env,
+  );
 
   return mergeBosConfigWithExtends(parent, config);
 }
@@ -432,82 +648,20 @@ async function resolveRuntimePlugins(
     const normalized = normalizePluginEntry(rawInput);
     if (normalized === null || normalized === false) continue;
 
-    let resolvedConfig: BosConfigInput = {};
-    let pluginBaseDir = baseDir;
-
-    if (normalized.extends) {
-      try {
-        const extendsUrl = resolveExtendsRef(normalized.extends, env);
-        if (extendsUrl) {
-          const remoteConfig = await fetchBosConfigFromFastKv<BosConfigInput>(extendsUrl);
-          resolvedConfig = remoteConfig;
-        }
-      } catch {
-        resolvedConfig = {};
-      }
-    }
-
-    if (normalized.development?.startsWith(LOCAL_PREFIX)) {
-      const localPath = resolve(baseDir, normalized.development.slice(LOCAL_PREFIX.length).trim());
-      if (existsSync(localPath)) {
-        const localConfigPath = join(localPath, "bos.config.json");
-        if (existsSync(localConfigPath)) {
-          try {
-            const localRaw = JSON.parse(readFileSync(localConfigPath, "utf-8")) as BosConfigInput;
-            resolvedConfig = mergeBosConfigWithExtends(resolvedConfig, localRaw);
-            pluginBaseDir = localPath;
-          } catch {}
-        }
-      }
-    }
-
-    if (normalized.app && isPlainObject(normalized.app)) {
-      const mergedApp: Record<string, unknown> = {
-        ...((resolvedConfig.app as Record<string, unknown>) ?? {}),
-        ...(normalized.app as Record<string, unknown>),
-      };
-      resolvedConfig = { ...resolvedConfig, app: mergedApp as BosConfigInput["app"] };
-    }
-    if (normalized.shared && isPlainObject(normalized.shared)) {
-      const mergedShared: Record<string, Record<string, SharedDepConfig>> = {
-        ...(resolvedConfig.shared ?? {}),
-        ...(normalized.shared as Record<string, Record<string, SharedDepConfig>>),
-      };
-      resolvedConfig = { ...resolvedConfig, shared: mergedShared };
-    }
-    if (normalized.sidebar) {
-      resolvedConfig = { ...resolvedConfig, sidebar: normalized.sidebar };
-    }
-    if (normalized.routes) {
-      resolvedConfig = { ...resolvedConfig, routes: normalized.routes };
-    }
-
-    const pluginRuntime = await buildRuntimePluginConfig(
-      pluginId,
-      resolvedConfig,
-      pluginBaseDir,
-      env,
+    const resolvedReference = await resolveComposableReference(
       normalized,
+      baseDir,
+      env,
+      `plugins.${pluginId}`,
     );
-    if (
-      normalized.name &&
-      typeof normalized.name === "string" &&
-      !pluginRuntime.name.includes("/")
-    ) {
-      pluginRuntime.name = normalized.name;
-    }
 
-    const integrity = normalized.integrity;
-    if (env === "production" && integrity) {
-      pluginRuntime.integrity = integrity;
-    }
+    const pluginRuntime = buildRuntimePluginConfig(pluginId, env, resolvedReference);
 
     if (
       pluginRuntime.source === "remote" &&
       pluginRuntime.url &&
       !pluginRuntime.localPath &&
-      typeof resolvedConfig.app?.api?.name !== "string" &&
-      !normalized.name
+      typeof resolvedReference.entry.name !== "string"
     ) {
       pluginRuntime.name = await resolveRemotePluginRuntimeName(
         pluginRuntime.url,
@@ -546,22 +700,14 @@ async function resolveRemotePluginRuntimeName(baseUrl: string, fallback: string)
   }
 }
 
-async function buildRuntimePluginConfig(
+function buildRuntimePluginConfig(
   pluginId: string,
-  config: BosConfigInput,
-  baseDir: string,
   env: BosEnv,
-  source: BosPluginRef,
-): Promise<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 development = apiDevelopment ?? sourceDevelopment;
-  const production = apiProduction ?? sourceProduction;
+  resolved: ResolvedComposableReference,
+): RuntimePluginConfig {
+  const source = resolved.entry;
+  const development = typeof source.development === "string" ? source.development : undefined;
+  const production = typeof source.production === "string" ? source.production : undefined;
 
   if (production?.startsWith("bos://")) {
     throw new Error(
@@ -571,32 +717,28 @@ async function buildRuntimePluginConfig(
 
   const runtimeTarget =
     env === "development"
-      ? resolveDevelopmentTarget(development, production, baseDir)
-      : resolveRuntimeTarget(production, baseDir, "remote");
-  const apiName = resolvePluginRuntimeName(
-    typeof apiConfig.name === "string" ? apiConfig.name : undefined,
-    runtimeTarget.localPath,
-    pluginId,
-  );
+      ? resolveDevelopmentTarget(development, production, resolved.providerBaseDir)
+      : resolveRuntimeTarget(production, resolved.providerBaseDir, "remote");
+  const apiName = resolvePluginRuntimeName(source.name, runtimeTarget.localPath, pluginId);
 
-  const uiConfig = config.app?.ui;
+  const uiConfig = resolved.associatedUi;
   const uiDevelopment =
     typeof uiConfig?.development === "string" ? uiConfig.development : undefined;
   const uiProduction = typeof uiConfig?.production === "string" ? uiConfig.production : undefined;
   const uiRuntime =
     uiConfig && (uiDevelopment || uiProduction)
       ? env === "development"
-        ? resolveDevelopmentTarget(uiDevelopment, uiProduction, baseDir)
-        : resolveRuntimeTarget(uiProduction, baseDir, "remote")
+        ? resolveDevelopmentTarget(uiDevelopment, uiProduction, resolved.providerBaseDir)
+        : resolveRuntimeTarget(uiProduction, resolved.providerBaseDir, "remote")
       : undefined;
 
-  const sidebar = (config.sidebar ?? source.sidebar)?.map((item) => ({
+  const sidebar = source.sidebar?.map((item) => ({
     ...item,
     to: item.to ?? `/${pluginId}`,
     roleRequired: item.roleRequired ?? ("member" as const),
   }));
 
-  const routes = config.routes ?? source.routes;
+  const routes = source.routes;
 
   return {
     name: apiName,
@@ -607,9 +749,10 @@ async function buildRuntimePluginConfig(
     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),
+    proxy: typeof source.proxy === "string" ? source.proxy : undefined,
+    variables: normalizeStringRecord(source.variables),
+    secrets: normalizeStringArray(source.secrets),
+    integrity: runtimeTarget.source === "remote" ? source.integrity : undefined,
     ui: uiRuntime
       ? {
           name: typeof uiConfig?.name === "string" ? uiConfig.name : `${apiName}-ui`,

package/src/plugin.ts

@@ -236,8 +236,6 @@ async function generateCodeArtifacts(
     runtimeConfig?: RuntimeConfig;
   },
 ): Promise<GeneratedArtifacts | null> {
-  writePluginSidebarGen(configDir, config);
-
   if (opts?.env) {
     writeResolvedConfig(configDir, config, opts.env, opts.extendsChain);
   }
@@ -245,6 +243,8 @@ async function generateCodeArtifacts(
   const runtimeConfig = opts?.runtimeConfig ?? (await loadConfig({ cwd: configDir }))?.runtime;
   if (!runtimeConfig) return null;
 
+  writePluginSidebarGen(configDir, runtimeConfig);
+
   const bridge = await syncApiContractBridge({
     configDir,
     runtimeConfig,
@@ -653,18 +653,22 @@ export default createPlugin({
               string,
               unknown
             >;
-            if (!pluginConfig.app) pluginConfig.app = {};
-            const app = pluginConfig.app as Record<string, unknown>;
-            if (!app.api) app.api = {};
-            const api = app.api as Record<string, unknown>;
-            api.production = publishedUrl;
+            if (!pluginConfig.plugins || typeof pluginConfig.plugins !== "object") {
+              pluginConfig.plugins = {};
+            }
+            const plugins = pluginConfig.plugins as Record<string, unknown>;
+            if (!plugins[input.key] || typeof plugins[input.key] !== "object") {
+              plugins[input.key] = {};
+            }
+            const entry = plugins[input.key] as Record<string, unknown>;
+            entry.production = publishedUrl;
             if (integrity) {
-              api.integrity = integrity;
+              entry.integrity = integrity;
             } else {
-              delete api.integrity;
+              delete entry.integrity;
             }
             writeFileSync(pluginConfigPath, `${JSON.stringify(pluginConfig, null, 2)}\n`);
-            console.log(`   ✅ Updated ${pluginConfigPath}: app.api.production`);
+            console.log(`   ✅ Updated ${pluginConfigPath}: plugins.${input.key}.production`);
           } catch (err) {
             console.error(
               `   ❌ Failed to update plugin bos.config.json:`,
@@ -1382,12 +1386,14 @@ export default createPlugin({
           }
 
           const pluginRoutes: Record<string, string[]> = {};
-          if (parentConfig.plugins) {
-            for (const [key, entry] of Object.entries(parentConfig.plugins)) {
-              const entryRef = getPluginRef(entry);
-              if (entryRef?.routes && entryRef.routes.length > 0) {
-                pluginRoutes[key] = entryRef.routes;
-              }
+          const parentRuntimePlugins = await buildRuntimePluginsForConfig(
+            parentConfig as BosConfig,
+            sourceDir,
+            "production",
+          );
+          for (const [key, plugin] of Object.entries(parentRuntimePlugins ?? {})) {
+            if (plugin.routes && plugin.routes.length > 0) {
+              pluginRoutes[key] = plugin.routes;
             }
           }
 

package/src/sidebar.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { BosConfig, SidebarItem } from "./types";
+import type { RuntimeConfig, SidebarItem } from "./types";
 
 const ICON_IMPORTS: Record<string, string> = {
   Home: "lucide-react",
@@ -51,11 +51,11 @@ function collectIconImports(items: SidebarItem[]): Map<string, Set<string>> {
   return moduleMap;
 }
 
-export function generatePluginSidebarContent(config: BosConfig, configDir?: string): string {
+export function generatePluginSidebarContent(runtimeConfig: RuntimeConfig): string {
   const coreItems: SidebarItem[] = [{ icon: "Home", label: "home", to: "/", roleRequired: "anon" }];
 
-  if (config.app.auth?.sidebar) {
-    for (const item of config.app.auth.sidebar) {
+  if (runtimeConfig.auth?.sidebar) {
+    for (const item of runtimeConfig.auth.sidebar) {
       coreItems.push({
         ...item,
         to: item.to ?? "/auth",
@@ -65,31 +65,9 @@ export function generatePluginSidebarContent(config: BosConfig, configDir?: stri
   }
 
   const pluginItems: SidebarItem[] = [];
-  if (config.plugins) {
-    for (const [key, entry] of Object.entries(config.plugins)) {
-      let sidebar: SidebarItem[] | undefined;
-
-      if (typeof entry === "object" && entry.sidebar) {
-        sidebar = entry.sidebar;
-      } else if (
-        typeof entry === "object" &&
-        entry.development?.startsWith("local:") &&
-        configDir
-      ) {
-        const localPath = join(configDir, entry.development.slice("local:".length).trim());
-        const pluginConfigPath = join(localPath, "bos.config.json");
-        if (existsSync(pluginConfigPath)) {
-          try {
-            const pluginConfig = JSON.parse(readFileSync(pluginConfigPath, "utf-8")) as {
-              sidebar?: SidebarItem[];
-            };
-            if (pluginConfig.sidebar) {
-              sidebar = pluginConfig.sidebar;
-            }
-          } catch {}
-        }
-      }
-
+  if (runtimeConfig.plugins) {
+    for (const [key, entry] of Object.entries(runtimeConfig.plugins)) {
+      const sidebar = entry.sidebar;
       if (!sidebar) continue;
       for (const item of sidebar) {
         pluginItems.push({
@@ -135,10 +113,10 @@ ${itemsCode}
 `;
 }
 
-export function writePluginSidebarGen(configDir: string, config: BosConfig): string {
+export function writePluginSidebarGen(configDir: string, runtimeConfig: RuntimeConfig): string {
   const outputPath = join(configDir, "ui/src/lib/plugin-sidebar.gen.ts");
 
-  const content = generatePluginSidebarContent(config, configDir);
+  const content = generatePluginSidebarContent(runtimeConfig);
 
   const outputDir = dirname(outputPath);
   if (!existsSync(outputDir)) {

package/src/types.ts

@@ -46,8 +46,9 @@ export const SidebarItemSchema = z.object({
 });
 export type SidebarItem = z.infer<typeof SidebarItemSchema>;
 
-export const ApiPluginConfigSchema = z.object({
-  name: z.string(),
+export const ComposableAppEntrySchema = z.object({
+  extends: ExtendsSchema.optional(),
+  name: z.string().optional(),
   development: z.string().optional(),
   production: z.string().optional(),
   integrity: z.string().optional(),
@@ -55,7 +56,11 @@ export const ApiPluginConfigSchema = z.object({
   variables: z.record(z.string(), z.string()).optional(),
   secrets: z.array(z.string()).optional(),
   sidebar: z.array(SidebarItemSchema).optional(),
+  routes: z.array(z.string()).optional(),
 });
+export type ComposableAppEntry = z.infer<typeof ComposableAppEntrySchema>;
+
+export const ApiPluginConfigSchema = ComposableAppEntrySchema;
 export type ApiPluginConfig = z.infer<typeof ApiPluginConfigSchema>;
 
 export const PluginUiConfigSchema = z.object({
@@ -66,18 +71,8 @@ export const PluginUiConfigSchema = z.object({
 });
 export type PluginUiConfig = z.infer<typeof PluginUiConfigSchema>;
 
-export const BosPluginRefSchema = z.object({
-  extends: ExtendsSchema.optional(),
-  development: z.string().optional(),
-  production: z.string().optional(),
-  integrity: z.string().optional(),
-  name: z.string().optional(),
+export const BosPluginRefSchema = ComposableAppEntrySchema.extend({
   version: z.string().optional(),
-  proxy: z.string().optional(),
-  variables: z.record(z.string(), z.string()).optional(),
-  secrets: z.array(z.string()).optional(),
-  routes: z.array(z.string()).optional(),
-  sidebar: z.array(SidebarItemSchema).optional(),
   app: z.record(z.string(), z.unknown()).optional(),
   shared: z.record(z.string(), z.record(z.string(), SharedConfigSchema)).optional(),
   plugins: z.record(z.string(), z.unknown()).optional(),
@@ -222,8 +217,8 @@ export const BosConfigSchema = z.object({
   app: z.object({
     host: HostConfigSchema,
     ui: UiConfigSchema,
-    api: ApiPluginConfigSchema,
-    auth: ApiPluginConfigSchema.optional(),
+    api: ComposableAppEntrySchema,
+    auth: ComposableAppEntrySchema.optional(),
   }),
 });
 export type BosConfig = z.infer<typeof BosConfigSchema>;