everything-dev 1.16.0 → 1.16.2

package/src/cli/infra.ts

@@ -0,0 +1,190 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as p from "@clack/prompts";
+import type { RuntimeConfig } from "../types";
+
+const POSTGRES_USER = "everythingdev";
+const POSTGRES_PASSWORD = "everythingdev";
+const API_DATABASE_SECRET = "API_DATABASE_URL";
+const AUTH_DATABASE_SECRET = "AUTH_DATABASE_URL";
+const BASE_DATABASE_PORT = 5434;
+
+interface DatabaseSecretConfig {
+  secret: string;
+  slug: string;
+  port: number;
+  serviceName: string;
+  databaseName: string;
+  volumeName: string;
+  url: string;
+}
+
+function uniqueSecrets(values: Array<string | undefined>): string[] {
+  const secrets: string[] = [];
+  const seen = new Set<string>();
+
+  for (const value of values) {
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    secrets.push(value);
+  }
+
+  return secrets;
+}
+
+function getRuntimeSecrets(runtimeConfig: RuntimeConfig): string[] {
+  const pluginSecrets = Object.values(runtimeConfig.plugins ?? {}).flatMap(
+    (plugin) => plugin.secrets ?? [],
+  );
+
+  return uniqueSecrets([
+    API_DATABASE_SECRET,
+    AUTH_DATABASE_SECRET,
+    ...(runtimeConfig.api.secrets ?? []),
+    ...(runtimeConfig.auth?.secrets ?? []),
+    ...pluginSecrets,
+  ]);
+}
+
+function normalizeDatabaseSlug(secret: string): string {
+  return secret.replace(/_DATABASE_URL$/, "").toLowerCase();
+}
+
+function buildDatabaseConfigs(secrets: string[]): DatabaseSecretConfig[] {
+  const databaseSecrets = uniqueSecrets(
+    secrets.filter((secret) => secret.endsWith("_DATABASE_URL")),
+  );
+
+  const additionalSecrets = databaseSecrets
+    .filter((secret) => secret !== API_DATABASE_SECRET && secret !== AUTH_DATABASE_SECRET)
+    .sort((a, b) => a.localeCompare(b));
+
+  const orderedSecrets = [API_DATABASE_SECRET, AUTH_DATABASE_SECRET, ...additionalSecrets];
+
+  return orderedSecrets.map((secret, index) => {
+    const slug = normalizeDatabaseSlug(secret);
+    const port =
+      secret === API_DATABASE_SECRET
+        ? 5432
+        : secret === AUTH_DATABASE_SECRET
+          ? 5433
+          : BASE_DATABASE_PORT + index - 2;
+
+    return {
+      secret,
+      slug,
+      port,
+      serviceName: `postgres-${slug.replace(/_/g, "-")}`,
+      databaseName: `${slug}_db`,
+      volumeName: `postgres_${slug}_data`,
+      url: `postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@localhost:${port}/${slug}_db`,
+    };
+  });
+}
+
+function defaultSecretValue(
+  secret: string,
+  databases: Map<string, DatabaseSecretConfig>,
+  options: { forExample: boolean },
+): string {
+  if (secret === "BETTER_AUTH_SECRET") {
+    return options.forExample ? "" : randomBytes(32).toString("base64url");
+  }
+
+  if (secret === "CORS_ORIGIN") {
+    return "http://localhost:3000";
+  }
+
+  return databases.get(secret)?.url ?? "";
+}
+
+function renderEnvFile(
+  secrets: string[],
+  databases: DatabaseSecretConfig[],
+  options: { forExample: boolean },
+): string {
+  const databaseMap = new Map(databases.map((entry) => [entry.secret, entry]));
+  const lines = [
+    "# Generated from configured bos secrets",
+    "# Update values as needed for your local environment",
+    "",
+  ];
+
+  for (const secret of secrets) {
+    lines.push(`${secret}=${defaultSecretValue(secret, databaseMap, options)}`);
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+function renderDockerCompose(databases: DatabaseSecretConfig[]): string {
+  const lines = [
+    "x-pg-common: &pg-common",
+    "  image: postgres:17-alpine",
+    "  environment: &pg-env",
+    `    POSTGRES_USER: ${POSTGRES_USER}`,
+    `    POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}`,
+    "  healthcheck:",
+    '    test: ["CMD-SHELL", "pg_isready -U everythingdev"]',
+    "    interval: 3s",
+    "    timeout: 3s",
+    "    retries: 5",
+    "",
+    "services:",
+  ];
+
+  for (const database of databases) {
+    lines.push(`  ${database.serviceName}:`);
+    lines.push("    <<: *pg-common");
+    lines.push("    environment:");
+    lines.push("      <<: *pg-env");
+    lines.push(`      POSTGRES_DB: ${database.databaseName}`);
+    lines.push("    ports:");
+    lines.push(`      - "${database.port}:5432"`);
+    lines.push("    volumes:");
+    lines.push(`      - ${database.volumeName}:/var/lib/postgresql/data`);
+    lines.push("");
+  }
+
+  lines.push("volumes:");
+  for (const database of databases) {
+    lines.push(`  ${database.volumeName}:`);
+  }
+
+  return `${lines.join("\n")}\n`;
+}
+
+export function writeGeneratedInfra(configDir: string, runtimeConfig: RuntimeConfig): string[] {
+  const secrets = getRuntimeSecrets(runtimeConfig);
+  const databases = buildDatabaseConfigs(secrets);
+  const envExamplePath = join(configDir, ".env.example");
+  const dockerComposePath = join(configDir, "docker-compose.yml");
+
+  writeFileSync(envExamplePath, renderEnvFile(secrets, databases, { forExample: true }));
+  writeFileSync(dockerComposePath, renderDockerCompose(databases));
+
+  return secrets;
+}
+
+export function ensureEnvFile(configDir: string): void {
+  const envPath = join(configDir, ".env");
+  const examplePath = join(configDir, ".env.example");
+
+  if (existsSync(envPath) || !existsSync(examplePath)) return;
+
+  const content = readFileSync(examplePath, "utf-8");
+  const lines = content.split("\n");
+  const secret = randomBytes(32).toString("base64url");
+  const updated = lines
+    .map((line) => {
+      if (/^BETTER_AUTH_SECRET=/.test(line)) {
+        return `BETTER_AUTH_SECRET=${secret}`;
+      }
+      return line;
+    })
+    .join("\n");
+
+  writeFileSync(envPath, updated);
+  p.log.info("Created .env from generated .env.example with generated BETTER_AUTH_SECRET");
+}

package/src/cli/init.ts

@@ -609,6 +609,10 @@ export async function runTypesGen(destination: string): Promise<void> {
   await execCommand("node_modules/.bin/bos", ["types", "gen"], destination);
 }
 
+export async function runDockerComposeUp(destination: string): Promise<void> {
+  await execCommand("docker", ["compose", "up", "-d", "--wait"], destination);
+}
+
 const WORKSPACE_LOCAL_PATHS: Record<string, string> = {
   "everything-dev": "packages/everything-dev",
   "every-plugin": "packages/every-plugin",

package/src/cli/sync.ts

@@ -9,6 +9,7 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 import { glob } from "glob";
+import { loadConfig } from "../config";
 import type { SyncOptions, SyncResult } from "../contract";
 import {
   isPlainObject as isPlainObjectFromMerge,
@@ -17,6 +18,7 @@ import {
 } from "../merge";
 import type { BosPluginRef } from "../types";
 import { isPathExcluded } from "../utils/path-match";
+import { writeGeneratedInfra } from "./infra";
 import {
   personalizeConfig,
   readTemplatekeep,
@@ -27,10 +29,12 @@ import {
 import { readSnapshot, writeSnapshot } from "./snapshot";
 
 const FRAMEWORK_OWNED_SYNC_FILES = new Set([
+  ".env.example",
   ".gitignore",
   "biome.json",
   "bos.config.json",
   "package.json",
+  "docker-compose.yml",
   ".github/renovate.json",
   ".github/workflows/ci.yml",
   ".github/workflows/release-sync.yml",
@@ -494,6 +498,11 @@ export async function syncTemplate(projectDir: string, options: SyncOptions): Pr
       mode: "sync",
     });
 
+    const syncedConfig = await loadConfig({ cwd: projectDir });
+    if (syncedConfig?.runtime) {
+      writeGeneratedInfra(projectDir, syncedConfig.runtime);
+    }
+
     if (!options.noInstall) {
       await runBunInstall(projectDir);
       await runTypesGen(projectDir);

package/src/cli/upgrade.ts

@@ -1,9 +1,13 @@
 import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import process from "node:process";
+import * as p from "@clack/prompts";
 import { glob } from "glob";
 import type { UpgradeOptions, UpgradeResult } from "../contract";
+import { resolveExtendsRef } from "../merge";
+import { saveBosConfig } from "../utils/save-config";
 import { readInstalledFrameworkVersion } from "./framework-version";
-import { runBunInstall, runTypesGen } from "./init";
+import { fetchParentConfig, runBunInstall, runTypesGen } from "./init";
 import { syncTemplate } from "./sync";
 
 const FRAMEWORK_PACKAGES = ["everything-dev", "every-plugin"];
@@ -47,6 +51,105 @@ interface NpmPackageInfo {
   version: string;
 }
 
+function getExtendsRef(config: Record<string, unknown>): string | undefined {
+  if (typeof config.extends === "string") {
+    return config.extends;
+  }
+
+  if (config.extends && typeof config.extends === "object") {
+    return resolveExtendsRef(config.extends as Record<string, string>, "production");
+  }
+
+  return undefined;
+}
+
+function parseBosRef(ref: string): { account: string; gateway: string } | null {
+  const match = ref.match(/^bos:\/\/([^/]+)\/(.+)$/);
+  if (!match?.[1] || !match[2]) return null;
+  return { account: match[1], gateway: match[2] };
+}
+
+async function loadParentPluginOptions(projectDir: string): Promise<{
+  localConfig: Record<string, unknown>;
+  parentPlugins: Record<string, unknown>;
+  newPluginKeys: string[];
+} | null> {
+  const configPath = join(projectDir, "bos.config.json");
+  if (!existsSync(configPath)) {
+    return null;
+  }
+
+  const localConfig = JSON.parse(readFileSync(configPath, "utf-8")) as Record<string, unknown>;
+  const extendsRef = getExtendsRef(localConfig);
+  if (!extendsRef?.startsWith("bos://")) {
+    return null;
+  }
+
+  const parsed = parseBosRef(extendsRef);
+  if (!parsed) {
+    return null;
+  }
+
+  let parentConfig: Record<string, unknown>;
+  try {
+    parentConfig = await fetchParentConfig(parsed.account, parsed.gateway);
+  } catch {
+    return null;
+  }
+
+  const parentPlugins =
+    parentConfig.plugins && typeof parentConfig.plugins === "object"
+      ? (parentConfig.plugins as Record<string, unknown>)
+      : {};
+  const localPlugins =
+    localConfig.plugins && typeof localConfig.plugins === "object"
+      ? (localConfig.plugins as Record<string, unknown>)
+      : {};
+
+  const newPluginKeys = Object.keys(parentPlugins).filter((key) => !(key in localPlugins));
+  return { localConfig, parentPlugins, newPluginKeys };
+}
+
+async function addSelectedParentPlugins(projectDir: string): Promise<string[]> {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return [];
+  }
+
+  const pluginOptions = await loadParentPluginOptions(projectDir);
+  if (!pluginOptions || pluginOptions.newPluginKeys.length === 0) {
+    return [];
+  }
+
+  const selectedValue = await p.multiselect({
+    message: "Select new plugins from parent:",
+    options: pluginOptions.newPluginKeys.map((key) => ({ value: key, label: key })),
+    required: false,
+  });
+
+  if (p.isCancel(selectedValue)) {
+    process.exit(0);
+  }
+
+  const selected = selectedValue as string[];
+  if (selected.length === 0) {
+    return [];
+  }
+
+  const localPlugins =
+    pluginOptions.localConfig.plugins && typeof pluginOptions.localConfig.plugins === "object"
+      ? (pluginOptions.localConfig.plugins as Record<string, unknown>)
+      : {};
+  const nextPlugins = { ...localPlugins };
+  for (const key of selected) {
+    nextPlugins[key] = pluginOptions.parentPlugins[key];
+  }
+
+  pluginOptions.localConfig.plugins = nextPlugins;
+  await saveBosConfig(projectDir, pluginOptions.localConfig);
+
+  return selected;
+}
+
 async function fetchLatestNpmVersion(packageName: string): Promise<string | null> {
   try {
     const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
@@ -269,6 +372,7 @@ export async function upgradeTemplate(
 
   if (options.dryRun) {
     let changelogUrl: string | undefined;
+    const pluginOptions = options.noSync ? null : await loadParentPluginOptions(projectDir);
     if (hasUpdates) {
       const configPath = join(projectDir, "bos.config.json");
       let parentConfig: Record<string, unknown> | null = null;
@@ -289,6 +393,7 @@ export async function upgradeTemplate(
         ...packages,
         ...catalogVersionUpdates.map((u) => ({ name: u.name, from: u.from, to: u.to })),
       ],
+      availablePlugins: pluginOptions?.newPluginKeys,
       changelogUrl,
     };
   }
@@ -315,13 +420,13 @@ export async function upgradeTemplate(
     }
   }
 
-  if (hasUpdates && !options.noInstall) {
-    await runBunInstall(projectDir);
-    await runTypesGen(projectDir);
-  }
-
   let syncResult: UpgradeResult["sync"];
+  let addedPlugins: string[] = [];
   if (!options.noSync) {
+    if (!options.dryRun) {
+      addedPlugins = await addSelectedParentPlugins(projectDir);
+    }
+
     syncResult = await syncTemplate(projectDir, {
       dryRun: false,
       force: options.force,
@@ -329,6 +434,11 @@ export async function upgradeTemplate(
     });
   }
 
+  if ((hasUpdates || addedPlugins.length > 0) && !options.noInstall) {
+    await runBunInstall(projectDir);
+    await runTypesGen(projectDir);
+  }
+
   const migratedFiles = await rewriteLegacyUiImports(projectDir);
   for (const file of OBSOLETE_FILES) {
     const filePath = join(projectDir, file);
@@ -359,6 +469,7 @@ export async function upgradeTemplate(
     ],
     sync: syncResult,
     migrated: migratedFiles.length > 0 ? migratedFiles : undefined,
+    selectedPlugins: addedPlugins.length > 0 ? addedPlugins : undefined,
     changelogUrl,
   };
 }

package/src/cli.ts

@@ -240,6 +240,12 @@ async function main() {
       if (result.changelogUrl) {
         console.log(`  ${colors.dim("Changelog:")} ${result.changelogUrl}`);
       }
+      if (result.availablePlugins && result.availablePlugins.length > 0) {
+        console.log(`  ${colors.dim("New parent plugins:")} ${result.availablePlugins.join(", ")}`);
+      }
+      if (result.selectedPlugins && result.selectedPlugins.length > 0) {
+        console.log(`  ${colors.dim("Added plugins:")} ${result.selectedPlugins.join(", ")}`);
+      }
       if (result.sync) {
         const sync = result.sync;
         if (sync.updated.length > 0) {

package/src/config.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
-import { fetchBosConfigFromFastKv, fetchPluginFromRegistry, parsePluginBosUrl } from "./fastkv";
+import { fetchBosConfigFromFastKv } from "./fastkv";
 import {
   type BosEnv,
   isPlainObject,
@@ -546,31 +546,6 @@ async function resolveRemotePluginRuntimeName(baseUrl: string, fallback: string)
   }
 }
 
-interface ResolvedBosPlugin {
-  url: string;
-  integrity?: string;
-}
-
-async function resolveBosPluginUrl(bosUrl: string): Promise<ResolvedBosPlugin | null> {
-  const parsed = parsePluginBosUrl(bosUrl);
-  if (!parsed) return null;
-
-  try {
-    const entry = await fetchPluginFromRegistry(parsed.accountId, parsed.pluginName);
-    if (!entry) return null;
-
-    const cdnUrl = entry.metadata.cdnUrl;
-    if (!cdnUrl) return null;
-
-    return {
-      url: cdnUrl,
-      integrity: entry.metadata.integrity ?? undefined,
-    };
-  } catch {
-    return null;
-  }
-}
-
 async function buildRuntimePluginConfig(
   pluginId: string,
   config: BosConfigInput,
@@ -586,16 +561,12 @@ async function buildRuntimePluginConfig(
   const sourceProduction = typeof source.production === "string" ? source.production : undefined;
   const proxy = typeof apiConfig.proxy === "string" ? apiConfig.proxy : undefined;
   const development = apiDevelopment ?? sourceDevelopment;
-  let production = apiProduction ?? sourceProduction;
+  const production = apiProduction ?? sourceProduction;
 
   if (production?.startsWith("bos://")) {
-    const resolved = await resolveBosPluginUrl(production);
-    if (resolved) {
-      production = resolved.url;
-      if (resolved.integrity && env === "production") {
-        source.integrity = resolved.integrity;
-      }
-    }
+    throw new Error(
+      `Plugin "${pluginId}" has unsupported production target "${production}". Use extends: "bos://account/domain" for plugin configs or a CDN URL for production.`,
+    );
   }
 
   const runtimeTarget =

package/src/contract.meta.ts

@@ -44,7 +44,7 @@ export const cliCommandMeta = {
     fields: {
       source: {
         positional: true,
-        description: "Plugin source (local:path, bos://account/plugins/name, or URL)",
+        description: "Plugin source (local:path, bos://account/domain, or URL)",
       },
       as: { description: "Plugin alias" },
       production: { description: "Production URL override" },
@@ -113,7 +113,7 @@ export const cliCommandMeta = {
   upgrade: {
     commandPath: ["upgrade"],
     summary: "Upgrade framework packages and sync template files",
-    interactive: false,
+    interactive: true,
     fields: {
       dryRun: { description: "Preview changes without writing" },
       force: { description: "Overwrite user-modified files during sync" },

package/src/contract.ts

@@ -201,6 +201,8 @@ export const UpgradeResultSchema = z.object({
   ),
   sync: SyncResultSchema.optional(),
   migrated: z.array(z.string()).optional(),
+  availablePlugins: z.array(z.string()).optional(),
+  selectedPlugins: z.array(z.string()).optional(),
   changelogUrl: z.string().optional(),
   error: z.string().optional(),
 });

package/src/fastkv.ts

@@ -139,78 +139,6 @@ export interface PluginManifest {
   additionalExports?: Array<{ path: string; exports: string[]; sha256: string }>;
 }
 
-export interface PluginMetadata {
-  title: string | null;
-  description: string | null;
-  repoUrl: string | null;
-  version: string;
-  publishedAt: string;
-  cdnUrl: string;
-  integrity: string | null;
-}
-
-export interface PluginRegistryEntry {
-  manifest: PluginManifest;
-  metadata: PluginMetadata;
-}
-
-export function parsePluginBosUrl(
-  source: string,
-): { accountId: string; pluginName: string } | null {
-  if (!source.startsWith("bos://")) return null;
-  const match = source.match(/^bos:\/\/([^/]+)\/plugins\/([^/]+)$/);
-  if (!match?.[1] || !match[2]) return null;
-  return { accountId: match[1], pluginName: match[2] };
-}
-
-async function fetchKvValue(accountId: string, key: string): Promise<unknown | null> {
-  const payload = await fetchJson<FastKvListResponse>(
-    `${getFastKvBaseUrlForAccount(accountId)}/v0/latest/${encodeURIComponent(getRegistryNamespaceForAccount(accountId))}/${encodeURIComponent(accountId)}`,
-    {
-      method: "POST",
-      body: JSON.stringify({ key, limit: 1 }),
-    },
-  );
-  const value = payload?.entries?.find(Boolean)?.value;
-  if (value == null) return null;
-  if (typeof value === "string") {
-    try {
-      return JSON.parse(value);
-    } catch {
-      return null;
-    }
-  }
-  return value;
-}
-
-export async function fetchPluginFromRegistry(
-  accountId: string,
-  pluginName: string,
-): Promise<PluginRegistryEntry | null> {
-  const manifestKey = `plugins/${accountId}/${pluginName}/manifest.json`;
-  const metadataKey = `plugins/${accountId}/${pluginName}/metadata`;
-
-  const [rawManifest, rawMetadata] = await Promise.all([
-    fetchKvValue(accountId, manifestKey),
-    fetchKvValue(accountId, metadataKey),
-  ]);
-
-  if (!rawManifest || typeof rawManifest !== "object") return null;
-
-  return {
-    manifest: rawManifest as PluginManifest,
-    metadata: (rawMetadata ?? {
-      title: null,
-      description: null,
-      repoUrl: null,
-      version: "",
-      publishedAt: "",
-      cdnUrl: "",
-      integrity: null,
-    }) as PluginMetadata,
-  };
-}
-
 export async function fetchRemotePluginManifest(cdnUrl: string): Promise<PluginManifest | null> {
   try {
     const baseUrl = cdnUrl.replace(/\/$/, "");

package/src/merge.ts

@@ -95,28 +95,15 @@ export function mergeBosConfigWithExtends(
   parent: BosConfigInput,
   child: BosConfigInput,
 ): BosConfigInput {
-  const merged = bosConfigMerger(child, parent) as BosConfigInput;
-
-  if (isPlainObject(parent.plugins) && isPlainObject(child.plugins)) {
-    const plugins: Record<string, unknown> = { ...parent.plugins };
-    for (const [key, rawValue] of Object.entries(child.plugins)) {
-      const value = rawValue as unknown;
-      if (value === null || value === false) {
-        delete plugins[key];
-      } else if (isPlainObject(plugins[key]) && isPlainObject(value)) {
-        plugins[key] = bosConfigMerger(
-          value as Record<string, unknown>,
-          plugins[key] as Record<string, unknown>,
-        );
-      } else {
-        plugins[key] = value;
-      }
-    }
-    (merged as Record<string, unknown>).plugins = plugins;
-  } else if (child.plugins !== undefined) {
+  const { plugins: _ignoredParentPlugins, ...parentWithoutPlugins } = parent;
+  const merged = bosConfigMerger(child, parentWithoutPlugins) as BosConfigInput;
+
+  if (child.plugins !== undefined && isPlainObject(child.plugins)) {
     (merged as Record<string, unknown>).plugins = cleanNullSentinels(
       child.plugins as Record<string, unknown>,
     );
+  } else {
+    delete (merged as Record<string, unknown>).plugins;
   }
 
   const mergedRecord = merged as Record<string, unknown>;