everything-dev 1.16.1 → 1.16.3

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/timing.ts

@@ -0,0 +1,36 @@
+export interface PhaseTiming {
+  name: string;
+  durationMs: number;
+}
+
+export async function timePhase<T>(
+  timings: PhaseTiming[],
+  name: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  const startedAt = Date.now();
+  try {
+    return await fn();
+  } finally {
+    timings.push({ name, durationMs: Date.now() - startedAt });
+  }
+}
+
+export function sumPhaseDurations(timings: PhaseTiming[]): number {
+  return timings.reduce((total, timing) => total + timing.durationMs, 0);
+}
+
+export function formatDuration(durationMs: number): string {
+  if (durationMs < 1000) {
+    return `${durationMs}ms`;
+  }
+
+  if (durationMs < 60_000) {
+    const seconds = durationMs / 1000;
+    return `${seconds.toFixed(seconds >= 10 ? 0 : 1)}s`;
+  }
+
+  const minutes = Math.floor(durationMs / 60_000);
+  const seconds = Math.round((durationMs % 60_000) / 1000);
+  return `${minutes}m ${seconds}s`;
+}

package/src/cli/upgrade.ts

@@ -3,12 +3,13 @@ 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 type { PhaseTiming, UpgradeOptions, UpgradeResult } from "../contract";
 import { resolveExtendsRef } from "../merge";
 import { saveBosConfig } from "../utils/save-config";
 import { readInstalledFrameworkVersion } from "./framework-version";
 import { fetchParentConfig, runBunInstall, runTypesGen } from "./init";
 import { syncTemplate } from "./sync";
+import { timePhase } from "./timing";
 
 const FRAMEWORK_PACKAGES = ["everything-dev", "every-plugin"];
 
@@ -333,38 +334,52 @@ export async function upgradeTemplate(
   projectDir: string,
   options: UpgradeOptions,
 ): Promise<UpgradeResult> {
+  const timings: PhaseTiming[] = [];
   const pkgPath = join(projectDir, "package.json");
   if (!existsSync(pkgPath)) {
     return {
       status: "error",
       packages: [],
+      timings,
       error: "No package.json found in current directory",
     };
   }
 
-  const packages: UpgradeResult["packages"] = [];
+  const { packages, catalogVersionUpdates } = await timePhase(
+    timings,
+    "check package versions",
+    async () => {
+      const nextPackages: UpgradeResult["packages"] = [];
 
-  for (const name of FRAMEWORK_PACKAGES) {
-    const installed = readInstalledVersion(projectDir, name);
-    const latest = await fetchLatestNpmVersion(name);
+      for (const name of FRAMEWORK_PACKAGES) {
+        const installed = readInstalledVersion(projectDir, name);
+        const latest = await fetchLatestNpmVersion(name);
 
-    if (!latest) {
-      packages.push({ name, from: installed, to: installed ?? "unknown" });
-      continue;
-    }
+        if (!latest) {
+          nextPackages.push({ name, from: installed, to: installed ?? "unknown" });
+          continue;
+        }
 
-    packages.push({ name, from: installed, to: latest });
-  }
+        nextPackages.push({ name, from: installed, to: latest });
+      }
 
-  const catalogVersionUpdates: Array<{ name: string; from: string | undefined; to: string }> = [];
-  for (const name of CATALOG_TOOL_PACKAGES) {
-    const installed = readInstalledVersion(projectDir, name);
-    if (!installed) continue;
-    const latest = await fetchLatestNpmVersion(name);
-    if (!latest) continue;
-    if (installed === latest) continue;
-    catalogVersionUpdates.push({ name, from: installed, to: latest });
-  }
+      const nextCatalogVersionUpdates: Array<{
+        name: string;
+        from: string | undefined;
+        to: string;
+      }> = [];
+      for (const name of CATALOG_TOOL_PACKAGES) {
+        const installed = readInstalledVersion(projectDir, name);
+        if (!installed) continue;
+        const latest = await fetchLatestNpmVersion(name);
+        if (!latest) continue;
+        if (installed === latest) continue;
+        nextCatalogVersionUpdates.push({ name, from: installed, to: latest });
+      }
+
+      return { packages: nextPackages, catalogVersionUpdates: nextCatalogVersionUpdates };
+    },
+  );
 
   const hasFrameworkUpdates = packages.some((p) => p.from !== p.to && p.from !== undefined);
   const hasCatalogUpdates = catalogVersionUpdates.length > 0;
@@ -372,7 +387,11 @@ export async function upgradeTemplate(
 
   if (options.dryRun) {
     let changelogUrl: string | undefined;
-    const pluginOptions = options.noSync ? null : await loadParentPluginOptions(projectDir);
+    const pluginOptions = options.noSync
+      ? null
+      : await timePhase(timings, "discover parent plugins", () =>
+          loadParentPluginOptions(projectDir),
+        );
     if (hasUpdates) {
       const configPath = join(projectDir, "bos.config.json");
       let parentConfig: Record<string, unknown> | null = null;
@@ -394,59 +413,68 @@ export async function upgradeTemplate(
         ...catalogVersionUpdates.map((u) => ({ name: u.name, from: u.from, to: u.to })),
       ],
       availablePlugins: pluginOptions?.newPluginKeys,
+      timings,
       changelogUrl,
     };
   }
 
-  for (const pkg of packages) {
-    if (pkg.from !== undefined && pkg.from !== pkg.to) {
-      updateRootPackageVersion(projectDir, pkg.name, pkg.to);
-    }
-  }
-
-  for (const update of catalogVersionUpdates) {
-    updateRootCatalogVersion(projectDir, update.name, update.to);
-  }
-
-  const workspacePkgPaths = await findWorkspacePackageJsons(projectDir);
-  for (const pkgPath of workspacePkgPaths) {
+  await timePhase(timings, "apply package updates", async () => {
     for (const pkg of packages) {
       if (pkg.from !== undefined && pkg.from !== pkg.to) {
-        updateWorkspacePackageRefInFile(pkgPath, pkg.name);
+        updateRootPackageVersion(projectDir, pkg.name, pkg.to);
       }
     }
+
     for (const update of catalogVersionUpdates) {
-      updateWorkspacePackageRefInFile(pkgPath, update.name);
+      updateRootCatalogVersion(projectDir, update.name, update.to);
     }
-  }
+
+    const workspacePkgPaths = await findWorkspacePackageJsons(projectDir);
+    for (const pkgPath of workspacePkgPaths) {
+      for (const pkg of packages) {
+        if (pkg.from !== undefined && pkg.from !== pkg.to) {
+          updateWorkspacePackageRefInFile(pkgPath, pkg.name);
+        }
+      }
+      for (const update of catalogVersionUpdates) {
+        updateWorkspacePackageRefInFile(pkgPath, update.name);
+      }
+    }
+  });
 
   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,
-      noInstall: true,
+    addedPlugins = await timePhase(timings, "discover parent plugins", async () => {
+      if (options.dryRun) return [];
+      return addSelectedParentPlugins(projectDir);
     });
+
+    syncResult = await timePhase(timings, "sync template", () =>
+      syncTemplate(projectDir, {
+        dryRun: false,
+        force: options.force,
+        noInstall: true,
+      }),
+    );
   }
 
   if ((hasUpdates || addedPlugins.length > 0) && !options.noInstall) {
-    await runBunInstall(projectDir);
-    await runTypesGen(projectDir);
+    await timePhase(timings, "install dependencies", () => runBunInstall(projectDir));
+    await timePhase(timings, "generate types", () => runTypesGen(projectDir));
   }
 
-  const migratedFiles = await rewriteLegacyUiImports(projectDir);
-  for (const file of OBSOLETE_FILES) {
-    const filePath = join(projectDir, file);
-    if (existsSync(filePath)) {
-      rmSync(filePath);
-      migratedFiles.push(file);
+  const migratedFiles = await timePhase(timings, "clean obsolete files", async () => {
+    const nextMigratedFiles = await rewriteLegacyUiImports(projectDir);
+    for (const file of OBSOLETE_FILES) {
+      const filePath = join(projectDir, file);
+      if (existsSync(filePath)) {
+        rmSync(filePath);
+        nextMigratedFiles.push(file);
+      }
     }
-  }
+    return nextMigratedFiles;
+  });
 
   let changelogUrl: string | undefined;
   const mainPkg = packages.find((p) => p.name === "everything-dev");
@@ -470,6 +498,7 @@ export async function upgradeTemplate(
     sync: syncResult,
     migrated: migratedFiles.length > 0 ? migratedFiles : undefined,
     selectedPlugins: addedPlugins.length > 0 ? addedPlugins : undefined,
+    timings,
     changelogUrl,
   };
 }

package/src/cli.ts

@@ -2,6 +2,7 @@
 import { findCommandDescriptor } from "./cli/catalog";
 import { printHelp } from "./cli/help";
 import { parseCommandInput } from "./cli/parse";
+import { formatDuration, sumPhaseDurations } from "./cli/timing";
 import { findConfigPath } from "./config";
 import bosPlugin from "./plugin";
 import { createPluginRuntime } from "./sdk";
@@ -50,6 +51,18 @@ function normalizeVersion(v: string): string {
   return v.replace(/^[\^~>=v]+/, "").trim();
 }
 
+function printTimingSummary(timings: Array<{ name: string; durationMs: number }> | undefined) {
+  if (!timings || timings.length === 0) return;
+
+  console.log(`  ${colors.dim("Timings:")}`);
+  for (const timing of timings) {
+    console.log(`    ${colors.dim(timing.name.padEnd(22))} ${formatDuration(timing.durationMs)}`);
+  }
+  console.log(
+    `    ${colors.dim("total".padEnd(22))} ${formatDuration(sumPhaseDurations(timings))}`,
+  );
+}
+
 async function warnIfOutdated(client: any, command: string): Promise<void> {
   if (!["dev", "build", "start"].includes(command)) return;
 
@@ -152,6 +165,7 @@ async function main() {
       if (result.plugins && result.plugins.length > 0)
         console.log(`  ${colors.dim("Plugins:")} ${result.plugins.join(", ")}`);
       console.log(`  ${colors.dim("Files copied:")} ${result.filesCopied}`);
+      printTimingSummary(result.timings);
       console.log();
       console.log(colors.dim("  Next steps:"));
       console.log(colors.dim(`    cd ${result.directory}`));
@@ -246,6 +260,7 @@ async function main() {
       if (result.selectedPlugins && result.selectedPlugins.length > 0) {
         console.log(`  ${colors.dim("Added plugins:")} ${result.selectedPlugins.join(", ")}`);
       }
+      printTimingSummary(result.timings);
       if (result.sync) {
         const sync = result.sync;
         if (sync.updated.length > 0) {

package/src/contract.ts

@@ -156,6 +156,11 @@ export const InitOptionsSchema = z.object({
   noInstall: z.boolean().default(false),
 });
 
+export const PhaseTimingSchema = z.object({
+  name: z.string(),
+  durationMs: z.number(),
+});
+
 export const InitResultSchema = z.object({
   status: z.enum(["initialized", "error"]),
   directory: z.string(),
@@ -166,6 +171,7 @@ export const InitResultSchema = z.object({
   extends: z.string(),
   plugins: z.array(z.string()).optional(),
   filesCopied: z.number(),
+  timings: z.array(PhaseTimingSchema).optional(),
   error: z.string().optional(),
 });
 
@@ -203,6 +209,7 @@ export const UpgradeResultSchema = z.object({
   migrated: z.array(z.string()).optional(),
   availablePlugins: z.array(z.string()).optional(),
   selectedPlugins: z.array(z.string()).optional(),
+  timings: z.array(PhaseTimingSchema).optional(),
   changelogUrl: z.string().optional(),
   error: z.string().optional(),
 });
@@ -307,6 +314,7 @@ export type KeyPublishOptions = z.infer<typeof KeyPublishOptionsSchema>;
 export type KeyPublishResult = z.infer<typeof KeyPublishResultSchema>;
 export type InitOptions = z.infer<typeof InitOptionsSchema>;
 export type InitResult = z.infer<typeof InitResultSchema>;
+export type PhaseTiming = z.infer<typeof PhaseTimingSchema>;
 export type SyncOptions = z.infer<typeof SyncOptionsSchema>;
 export type SyncResult = z.infer<typeof SyncResultSchema>;
 export type UpgradeOptions = z.infer<typeof UpgradeOptionsSchema>;

package/src/dev-session.ts

@@ -1,4 +1,4 @@
-import { NodeContext } from "@effect/platform-node";
+import * as NodeContext from "@effect/platform-node/NodeContext";
 import { Deferred, Effect, Exit } from "effect";
 import {
   type DevViewHandle,