everything-dev 1.12.4 → 1.14.0

package/src/service-descriptor.ts

@@ -205,6 +205,29 @@ export function buildServiceDescriptorMap(
         defaultPort: resolvedPort,
         readinessPath: "/remoteEntry.js",
       });
+
+      if (pluginConfig.ui?.localPath && pluginConfig.ui.source === "local") {
+        const uiKey = `plugin-ui:${pluginId}`;
+        const uiPort = pluginConfig.ui.port ?? pluginBasePort;
+        pluginBasePort = uiPort + 1;
+
+        map.set(uiKey, {
+          key: uiKey,
+          source: pluginConfig.ui.source,
+          url: pluginConfig.ui.url,
+          entry: pluginConfig.ui.entry,
+          name: pluginConfig.ui.name,
+          localPath: pluginConfig.ui.localPath,
+          port: uiPort,
+          integrity: pluginConfig.ui.integrity,
+          command: "bun",
+          args: ["run", "dev"],
+          readyPatterns: PLUGIN_READY_PATTERNS,
+          errorPatterns: PLUGIN_ERROR_PATTERNS,
+          defaultPort: uiPort,
+          readinessPath: "/remoteEntry.js",
+        });
+      }
     }
   }
 

package/src/shared.ts

@@ -1,7 +1,22 @@
 import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { type BosEnv, type ResolvedConfigMeta, rebuildOrderedConfig } from "./merge";
 import type { BosConfig, SharedDepConfig } from "./types";
+import { BosConfigSchema } from "./types";
+
+interface PackageJson {
+  name?: string;
+  private?: boolean;
+  version?: string;
+  workspaces?: {
+    packages?: string[];
+    catalog?: Record<string, string>;
+  };
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+}
 
 export interface SharedUiResolvedDep {
   name: string;
@@ -77,15 +92,24 @@ export async function syncAndGenerateSharedUi(opts: {
   configDir: string;
   hostMode: "local" | "remote";
   bosConfig?: BosConfig;
+  env?: BosEnv;
+  extendsChain?: string[];
 }): Promise<SharedSyncResult> {
   const bosConfigPath = join(opts.configDir, "bos.config.json");
+  const resolvedConfigPath = join(opts.configDir, ".bos", "bos.resolved-config.json");
   const packageJsonPath = join(opts.configDir, "package.json");
   const generatedPath = join(opts.configDir, ".bos", "generated", "shared-ui.json");
 
-  const bosConfig: BosConfig = opts.bosConfig ?? JSON.parse(readFileSync(bosConfigPath, "utf-8"));
-  let pkgJson: any = {};
+  let bosConfig: BosConfig;
+  if (opts.bosConfig) {
+    bosConfig = opts.bosConfig;
+  } else {
+    const raw = JSON.parse(readFileSync(bosConfigPath, "utf-8")) as Record<string, unknown>;
+    bosConfig = BosConfigSchema.parse(raw);
+  }
+  let pkgJson: PackageJson = {};
   try {
-    pkgJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    pkgJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as PackageJson;
   } catch {
     // package.json might not exist
   }
@@ -130,7 +154,26 @@ export async function syncAndGenerateSharedUi(opts: {
   const catalogChanged = nextPkg !== originalPkg;
 
   if (bosConfigChanged) {
-    writeFileIfChanged(bosConfigPath, `${JSON.stringify(bosConfig, null, 2)}\n`);
+    if (mode === "catalog->bos") {
+      const resolvedDir = dirname(resolvedConfigPath);
+      if (!existsSync(resolvedDir)) {
+        mkdirSync(resolvedDir, { recursive: true });
+      }
+      const ordered = rebuildOrderedConfig(bosConfig);
+      const meta: ResolvedConfigMeta = {
+        env: opts.env ?? "development",
+        resolvedAt: new Date().toISOString(),
+        extendsChain: opts.extendsChain ?? [],
+        source: "shared-sync",
+      };
+      const resolvedOutput = {
+        _resolved: meta,
+        ...ordered,
+      };
+      writeFileIfChanged(resolvedConfigPath, `${JSON.stringify(resolvedOutput, null, 2)}\n`);
+    } else {
+      writeFileIfChanged(bosConfigPath, `${JSON.stringify(bosConfig, null, 2)}\n`);
+    }
   }
   if (catalogChanged) {
     writeFileIfChanged(packageJsonPath, `${JSON.stringify(pkgJson, null, 2)}\n`);

package/src/sidebar.ts

@@ -0,0 +1,162 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { BosConfig, SidebarItem } from "./types";
+
+const ICON_IMPORTS: Record<string, string> = {
+  Home: "lucide-react",
+  Globe: "lucide-react",
+  FolderKanban: "lucide-react",
+  Building2: "lucide-react",
+  Settings: "lucide-react",
+  User: "lucide-react",
+  Users: "lucide-react",
+  Shield: "lucide-react",
+  LayoutDashboard: "lucide-react",
+  CreditCard: "lucide-react",
+  Bell: "lucide-react",
+  Key: "lucide-react",
+  FileText: "lucide-react",
+  Database: "lucide-react",
+  Activity: "lucide-react",
+  BarChart3: "lucide-react",
+  Zap: "lucide-react",
+  Terminal: "lucide-react",
+  Code: "lucide-react",
+  Package: "lucide-react",
+  Store: "lucide-react",
+  ShoppingBag: "lucide-react",
+  Wallet: "lucide-react",
+  Coins: "lucide-react",
+  Plug: "lucide-react",
+  Link: "lucide-react",
+  ExternalLink: "lucide-react",
+  Puzzle: "lucide-react",
+  Layers: "lucide-react",
+  Grid3X3: "lucide-react",
+  AppWindow: "lucide-react",
+};
+
+function resolveIconModule(iconName: string): string {
+  if (ICON_IMPORTS[iconName]) return ICON_IMPORTS[iconName];
+  return "lucide-react";
+}
+
+function collectIconImports(items: SidebarItem[]): Map<string, Set<string>> {
+  const moduleMap = new Map<string, Set<string>>();
+  for (const item of items) {
+    const module = resolveIconModule(item.icon);
+    if (!moduleMap.has(module)) moduleMap.set(module, new Set());
+    moduleMap.get(module)!.add(item.icon);
+  }
+  return moduleMap;
+}
+
+export function generatePluginSidebarContent(config: BosConfig, configDir?: string): string {
+  const coreItems: SidebarItem[] = [{ icon: "Home", label: "home", to: "/", roleRequired: "anon" }];
+
+  if (config.app.auth?.sidebar) {
+    for (const item of config.app.auth.sidebar) {
+      coreItems.push({
+        ...item,
+        to: item.to ?? "/auth",
+        roleRequired: item.roleRequired ?? "member",
+      });
+    }
+  }
+
+  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 (!sidebar) continue;
+      for (const item of sidebar) {
+        pluginItems.push({
+          ...item,
+          to: item.to ?? `/${key}`,
+          roleRequired: item.roleRequired ?? "member",
+        });
+      }
+    }
+  }
+
+  const allItems = [...coreItems, ...pluginItems];
+  const moduleMap = collectIconImports(allItems);
+
+  const importLines: string[] = [];
+  for (const [module, icons] of moduleMap) {
+    const iconList = [...icons].join(", ");
+    importLines.push(`import { ${iconList} } from "${module}";`);
+  }
+
+  const itemsCode = allItems
+    .map(
+      (item) =>
+        `  { icon: ${item.icon}, label: "${item.label}", to: "${item.to}" as const, roleRequired: "${item.roleRequired}" as const },`,
+    )
+    .join("\n");
+
+  return `// Auto-generated by bos sync/pluginAdd/pluginRemove. Do not edit.
+${importLines.join("\n")}
+
+export type SidebarRole = "anon" | "member" | "admin";
+
+export interface SidebarItem {
+  icon: React.ComponentType<{ className?: string }>;
+  label: string;
+  to: string;
+  roleRequired: SidebarRole;
+}
+
+export const pluginSidebarItems: SidebarItem[] = [
+${itemsCode}
+];
+`;
+}
+
+export function writePluginSidebarGen(configDir: string, config: BosConfig): string {
+  const outputPath = join(configDir, "ui/src/lib/plugin-sidebar.gen.ts");
+
+  const content = generatePluginSidebarContent(config, configDir);
+
+  const outputDir = dirname(outputPath);
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+
+  let existingContent: string | null = null;
+  try {
+    existingContent = existsSync(outputPath)
+      ? // eslint-disable-next-line no-restricted-syntax
+        readFileSync(outputPath, "utf-8")
+      : null;
+  } catch {
+    // file doesn't exist yet
+  }
+
+  if (existingContent === content) return outputPath;
+
+  writeFileSync(outputPath, content);
+  return outputPath;
+}

package/src/types.ts

@@ -1,28 +1,15 @@
 import { z } from "./sdk";
 
-export interface BosConfigInput extends Record<string, unknown> {
-  extends?: string;
-  account?: string;
-  domain?: string;
-  testnet?: string;
-  template?: string;
-  gateway?: {
-    development?: string;
-    production?: string;
-    account?: string;
-  };
-  development?: string;
-  production?: string;
-  integrity?: string;
-  name?: string;
-  version?: 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>;
-}
+export const ExtendsSchema = z.union([
+  z.string(),
+  z.object({
+    development: z.string().optional(),
+    production: z.string().optional(),
+    staging: z.string().optional(),
+  }),
+]);
+export type Extends = z.infer<typeof ExtendsSchema>;
+export type ExtendsConfig = Extract<Extends, Record<string, string | undefined>>;
 
 export const SourceModeSchema = z.enum(["local", "remote"]);
 export type SourceMode = z.infer<typeof SourceModeSchema>;
@@ -48,6 +35,17 @@ export const FederationEntrySchema = z.object({
 });
 export type FederationEntry = z.infer<typeof FederationEntrySchema>;
 
+export const SidebarRoleSchema = z.enum(["anon", "member", "admin"]);
+export type SidebarRole = z.infer<typeof SidebarRoleSchema>;
+
+export const SidebarItemSchema = z.object({
+  icon: z.string(),
+  label: z.string(),
+  to: z.string().optional(),
+  roleRequired: SidebarRoleSchema.optional(),
+});
+export type SidebarItem = z.infer<typeof SidebarItemSchema>;
+
 export const ApiPluginConfigSchema = z.object({
   name: z.string(),
   development: z.string().optional(),
@@ -56,11 +54,20 @@ export const ApiPluginConfigSchema = z.object({
   proxy: z.string().optional(),
   variables: z.record(z.string(), z.string()).optional(),
   secrets: z.array(z.string()).optional(),
+  sidebar: z.array(SidebarItemSchema).optional(),
 });
 export type ApiPluginConfig = z.infer<typeof ApiPluginConfigSchema>;
 
+export const PluginUiConfigSchema = z.object({
+  name: z.string(),
+  development: z.string().optional(),
+  production: z.string().optional(),
+  integrity: z.string().optional(),
+});
+export type PluginUiConfig = z.infer<typeof PluginUiConfigSchema>;
+
 export const BosPluginRefSchema = z.object({
-  extends: z.string().optional(),
+  extends: ExtendsSchema.optional(),
   development: z.string().optional(),
   production: z.string().optional(),
   integrity: z.string().optional(),
@@ -70,8 +77,25 @@ export const BosPluginRefSchema = z.object({
   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(),
 });
 export type BosPluginRef = z.infer<typeof BosPluginRefSchema>;
+export type PluginEntryValue = string | BosPluginRef;
+export type PluginEntries = Record<string, PluginEntryValue>;
+
+const PluginRuntimeUiSchema = z.object({
+  name: z.string(),
+  url: z.string(),
+  entry: z.string(),
+  source: SourceModeSchema,
+  localPath: z.string().optional(),
+  port: z.number().optional(),
+  integrity: z.string().optional(),
+});
+export type PluginRuntimeUi = z.infer<typeof PluginRuntimeUiSchema>;
 
 export const RuntimePluginConfigSchema = z.object({
   name: z.string(),
@@ -84,6 +108,9 @@ export const RuntimePluginConfigSchema = z.object({
   variables: z.record(z.string(), z.string()).optional(),
   secrets: z.array(z.string()).optional(),
   integrity: z.string().optional(),
+  ui: PluginRuntimeUiSchema.optional(),
+  sidebar: z.array(SidebarItemSchema).optional(),
+  routes: z.array(z.string()).optional(),
 });
 export type RuntimePluginConfig = z.infer<typeof RuntimePluginConfigSchema>;
 
@@ -119,15 +146,74 @@ export const BosStagingSchema = z.object({
 });
 export type BosStaging = z.infer<typeof BosStagingSchema>;
 
+const BosConfigInputAppEntrySchema = z.record(z.string(), z.unknown());
+export type BosConfigInputAppEntry = z.infer<typeof BosConfigInputAppEntrySchema>;
+
+export const BosConfigInputSchema: z.ZodType<BosConfigInput> = z.lazy(() =>
+  z.object({
+    extends: ExtendsSchema.optional(),
+    account: z.string().optional(),
+    domain: z.string().optional(),
+    testnet: z.string().optional(),
+    template: z.string().optional(),
+    gateway: z
+      .object({
+        development: z.string().optional(),
+        production: z.string().optional(),
+        account: z.string().optional(),
+      })
+      .optional(),
+    development: z.string().optional(),
+    production: z.string().optional(),
+    integrity: z.string().optional(),
+    name: z.string().optional(),
+    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(), BosConfigInputAppEntrySchema).optional(),
+    shared: z.record(z.string(), z.record(z.string(), SharedConfigSchema)).optional(),
+    plugins: z.record(z.string(), z.union([z.string(), BosConfigInputSchema])).optional(),
+  }),
+);
+
+export interface BosConfigInput {
+  extends?: string | ExtendsConfig;
+  account?: string;
+  domain?: string;
+  testnet?: string;
+  template?: string;
+  gateway?: {
+    development?: string;
+    production?: string;
+    account?: string;
+  };
+  development?: string;
+  production?: string;
+  integrity?: string;
+  name?: string;
+  version?: string;
+  proxy?: string;
+  variables?: Record<string, string>;
+  secrets?: string[];
+  routes?: string[];
+  sidebar?: SidebarItem[];
+  app?: Record<string, BosConfigInputAppEntry>;
+  shared?: Record<string, Record<string, SharedDepConfig>>;
+  plugins?: Record<string, string | BosConfigInput>;
+}
+
 export const BosConfigSchema = z.object({
   account: z.string(),
-  extends: z.string().optional(),
+  extends: ExtendsSchema.optional(),
   domain: z.string().optional(),
   testnet: z.string().optional(),
   staging: BosStagingSchema.optional(),
   repository: z.string().optional(),
   shared: z.record(z.string(), z.record(z.string(), SharedConfigSchema)).optional(),
-  plugins: z.record(z.string(), BosPluginRefSchema).optional(),
+  plugins: z.record(z.string(), z.union([z.string(), BosPluginRefSchema])).optional(),
   app: z.object({
     host: HostConfigSchema,
     ui: UiConfigSchema,
@@ -138,7 +224,7 @@ export const BosConfigSchema = z.object({
 export type BosConfig = z.infer<typeof BosConfigSchema>;
 
 export const RuntimeConfigSchema = z.object({
-  env: z.enum(["development", "production"]),
+  env: z.enum(["development", "production", "staging"]),
   account: z.string(),
   domain: z.string().optional(),
   networkId: z.enum(["mainnet", "testnet"]),
@@ -175,6 +261,7 @@ export const RuntimeConfigSchema = z.object({
     proxy: z.string().optional(),
     variables: z.record(z.string(), z.string()).optional(),
     secrets: z.array(z.string()).optional(),
+    sidebar: z.array(SidebarItemSchema).optional(),
   }).optional(),
   plugins: z.record(z.string(), RuntimePluginConfigSchema).optional(),
 });
@@ -182,7 +269,7 @@ export type RuntimeConfig = z.infer<typeof RuntimeConfigSchema>;
 
 export const ClientRuntimeConfigSchema = z.object({
   cspNonce: z.string().optional(),
-  env: z.enum(["development", "production"]),
+  env: z.enum(["development", "production", "staging"]),
   account: z.string(),
   networkId: z.enum(["mainnet", "testnet"]),
   hostUrl: z.string().optional(),
@@ -208,6 +295,15 @@ export const ClientRuntimeConfigSchema = z.object({
       integrity: z.string().optional(),
     })
     .optional(),
+  auth: z
+    .object({
+      name: z.string(),
+      url: z.string(),
+      entry: z.string(),
+      integrity: z.string().optional(),
+      sidebar: z.array(SidebarItemSchema).optional(),
+    })
+    .optional(),
   plugins: z
     .record(
       z.string(),
@@ -216,6 +312,16 @@ export const ClientRuntimeConfigSchema = z.object({
         url: z.string(),
         entry: z.string(),
         integrity: z.string().optional(),
+        ui: z
+          .object({
+            name: z.string(),
+            url: z.string(),
+            entry: z.string(),
+            source: SourceModeSchema,
+            integrity: z.string().optional(),
+          })
+          .optional(),
+        sidebar: z.array(SidebarItemSchema).optional(),
       }),
     )
     .optional(),

package/src/utils/path-match.ts

@@ -0,0 +1,16 @@
+export function isPathExcluded(filePath: string, excludePatterns: string[]): boolean {
+  if (excludePatterns.length === 0) return false;
+  for (const pattern of excludePatterns) {
+    if (pattern.endsWith("/**")) {
+      const prefix = pattern.slice(0, -3);
+      if (filePath.startsWith(`${prefix}/`) || filePath === prefix) return true;
+    } else if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      const slashIdx = filePath.indexOf("/", prefix.length + 1);
+      if (filePath.startsWith(`${prefix}/`) && slashIdx === -1) return true;
+    } else if (filePath === pattern || filePath.startsWith(`${pattern}/`)) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/utils/save-config.ts

@@ -0,0 +1,20 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { rebuildOrderedConfig } from "../merge";
+import type { BosConfig } from "../types";
+
+export async function saveBosConfig(
+  configDir: string,
+  config: BosConfig | Record<string, unknown>,
+): Promise<void> {
+  const filePath = join(configDir, "bos.config.json");
+  const ordered = rebuildOrderedConfig(config as Record<string, unknown>);
+  const next = `${JSON.stringify(ordered, null, 2)}\n`;
+  try {
+    if (readFileSync(filePath, "utf8") === next) return;
+  } catch {
+    // file does not exist yet
+  }
+
+  writeFileSync(filePath, next);
+}

package/cli.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env bun
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const distEntry = join(__dirname, "dist", "cli.js");
-const srcEntry = join(__dirname, "src", "cli.ts");
-
-await import(existsSync(distEntry) ? distEntry : srcEntry);