everything-dev 1.22.0 → 1.24.0

package/src/cli/init.ts

@@ -91,10 +91,16 @@ export async function readTemplatekeep(sourceDir: string): Promise<string[]> {
   }
 
   const content = readFileSync(keepFile, "utf-8");
-  return content
+  const patterns = content
     .split("\n")
     .map((line) => line.trim())
     .filter((line) => line.length > 0 && !line.startsWith("#"));
+
+  if (!patterns.includes(".templatekeep")) {
+    patterns.unshift(".templatekeep");
+  }
+
+  return patterns;
 }
 
 export async function fetchParentConfig(
@@ -366,6 +372,10 @@ export async function personalizeConfig(
     workspaceOpts?: { localOverrides?: boolean; sourceDir?: string };
     mode?: "init" | "sync";
     repository?: string;
+    title?: string;
+    description?: string;
+    testnet?: string;
+    staging?: unknown;
   },
 ): Promise<void> {
   const isInit = opts.mode !== "sync";
@@ -385,6 +395,17 @@ export async function personalizeConfig(
     }
     if (opts.repository) {
       config.repository = opts.repository;
+    } else if (isInit) {
+      delete config.repository;
+    }
+
+    if (isInit) {
+      const inheritableFields = ["title", "description", "testnet", "staging"] as const;
+      for (const field of inheritableFields) {
+        if (!(field in opts)) {
+          delete config[field];
+        }
+      }
     }
 
     if (isInit && config.app && typeof config.app === "object") {
@@ -489,6 +510,10 @@ export async function personalizeConfig(
           scripts.typecheck = scripts.typecheck.replace(/bun run --cwd host tsc --noEmit & ?/, "");
         }
       }
+
+      if (!scripts.bos) {
+        scripts.bos = "node_modules/.bin/bos";
+      }
     }
 
     if (pkg.devDependencies && typeof pkg.devDependencies === "object") {
@@ -514,8 +539,12 @@ export async function personalizeConfig(
       workspaces.catalog["everything-dev"] = spec.rootCatalog["everything-dev"];
       workspaces.catalog["every-plugin"] = spec.rootCatalog["every-plugin"];
     }
-    if (!deps["everything-dev"] && spec) deps["everything-dev"] = "catalog:";
-    if (!deps["every-plugin"] && spec) deps["every-plugin"] = "catalog:";
+    const frameworkCatalog = resolveFrameworkCatalog();
+    for (const [name, version] of Object.entries(frameworkCatalog)) {
+      workspaces.catalog[name] = version;
+    }
+    if (!deps["everything-dev"]) deps["everything-dev"] = "catalog:";
+    if (!deps["every-plugin"]) deps["every-plugin"] = "catalog:";
 
     writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
   }
@@ -630,18 +659,108 @@ export interface AuthServices {
 `;
 }
 
-export async function runBunInstall(destination: string): Promise<void> {
-  await execCommand("bun", ["install", "--ignore-scripts"], destination, { stdio: "inherit" });
+export async function runBunInstall(
+  destination: string,
+  spinner?: { message: (msg: string) => void },
+): Promise<void> {
+  await runWithProgress(
+    "bun",
+    ["install", "--ignore-scripts"],
+    destination,
+    spinner,
+    "Installing dependencies",
+  );
 }
 
-export async function runTypesGen(destination: string): Promise<void> {
-  await execCommand("node_modules/.bin/bos", ["types", "gen"], destination, { stdio: "inherit" });
+export async function runBunInstallForUpgrade(
+  destination: string,
+  spinner?: { message: (msg: string) => void },
+): Promise<void> {
+  const lockfilePath = join(destination, "bun.lock");
+  if (existsSync(lockfilePath)) {
+    rmSync(lockfilePath, { force: true });
+  }
+
+  await runWithProgress("bun", ["install"], destination, spinner, "Installing dependencies");
+}
+
+export async function runTypesGen(
+  destination: string,
+  spinner?: { message: (msg: string) => void },
+): Promise<void> {
+  await runWithProgress(
+    "node_modules/.bin/bos",
+    ["types", "gen"],
+    destination,
+    spinner,
+    "Generating types",
+  );
 }
 
 export async function runDockerComposeUp(destination: string): Promise<void> {
   await execCommand("docker", ["compose", "up", "-d", "--wait"], destination, { stdio: "inherit" });
 }
 
+async function runWithProgress(
+  command: string,
+  args: string[],
+  cwd: string,
+  spinner: { message: (msg: string) => void } | undefined,
+  label: string,
+): Promise<void> {
+  const timeout = COMMAND_TIMEOUTS[command] ?? 2 * 60_000;
+  const child = execa(command, args, { cwd, stdio: "inherit", timeout });
+
+  if (spinner) {
+    const start = Date.now();
+    const interval = setInterval(() => {
+      const elapsed = Math.round((Date.now() - start) / 1000);
+      spinner.message(`${label}... (${elapsed}s)`);
+    }, 2000);
+    try {
+      await child;
+    } finally {
+      clearInterval(interval);
+    }
+  } else {
+    await child;
+  }
+}
+
+export function stripOrphanedWorkspacesFromLockfile(
+  lockfilePath: string,
+  allowedWorkspaces: string[],
+): void {
+  if (!existsSync(lockfilePath)) return;
+
+  const content = readFileSync(lockfilePath, "utf-8");
+  let lockfile: Record<string, unknown>;
+  try {
+    lockfile = JSON.parse(content) as Record<string, unknown>;
+  } catch {
+    return;
+  }
+
+  const workspaces = lockfile.workspaces;
+  if (!workspaces || typeof workspaces !== "object") return;
+
+  const workspaceMap = workspaces as Record<string, unknown>;
+  const allowed = new Set(["", ...allowedWorkspaces]);
+
+  const keys = Object.keys(workspaceMap);
+  let changed = false;
+  for (const key of keys) {
+    if (!allowed.has(key)) {
+      delete workspaceMap[key];
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    writeFileSync(lockfilePath, `${JSON.stringify(lockfile, null, 2)}\n`);
+  }
+}
+
 const WORKSPACE_LOCAL_PATHS: Record<string, string> = {
   "everything-dev": "packages/everything-dev",
   "every-plugin": "packages/every-plugin",
@@ -649,6 +768,49 @@ const WORKSPACE_LOCAL_PATHS: Record<string, string> = {
 
 function resolveFrameworkCatalog(): Record<string, string> {
   const catalog: Record<string, string> = {};
+
+  try {
+    const selfPkgPath = require.resolve("everything-dev/package.json");
+    const selfPkgDir = dirname(selfPkgPath);
+    const monorepoPkgPath = join(selfPkgDir, "..", "..", "package.json");
+    if (existsSync(monorepoPkgPath)) {
+      const monorepoPkg = JSON.parse(readFileSync(monorepoPkgPath, "utf-8")) as {
+        workspaces?: { catalog?: Record<string, string> };
+      };
+      const sourceCatalog = monorepoPkg.workspaces?.catalog;
+      if (sourceCatalog && typeof sourceCatalog === "object") {
+        for (const [name, version] of Object.entries(sourceCatalog)) {
+          if (typeof version === "string") {
+            catalog[name] = version;
+          }
+        }
+      }
+    }
+  } catch {}
+
+  try {
+    const selfPkgPath = require.resolve("everything-dev/package.json");
+    const selfPkg = JSON.parse(readFileSync(selfPkgPath, "utf-8")) as {
+      version?: string;
+      workspaces?: { catalog?: Record<string, string> };
+    };
+    if (selfPkg.version && !catalog["everything-dev"]) {
+      catalog["everything-dev"] = `^${selfPkg.version}`;
+    }
+    const sourceCatalog = selfPkg.workspaces?.catalog;
+    if (sourceCatalog && typeof sourceCatalog === "object") {
+      for (const [name, version] of Object.entries(sourceCatalog)) {
+        if (typeof version === "string" && !catalog[name]) {
+          catalog[name] = version;
+        }
+      }
+    }
+  } catch {}
+
+  if (Object.keys(catalog).length > 0) {
+    return catalog;
+  }
+
   for (const packageName of FRAMEWORK_PACKAGES) {
     try {
       const resolved = require.resolve(`${packageName}/package.json`);
@@ -672,6 +834,8 @@ export async function scaffoldMinimalProject(
     plugins?: string[];
     overrides: OverrideSection[];
     repository?: string;
+    title?: string;
+    description?: string;
   },
 ): Promise<number> {
   mkdirSync(destination, { recursive: true });
@@ -683,6 +847,8 @@ export async function scaffoldMinimalProject(
     account: opts.account || opts.extendsAccount,
     ...(opts.domain ? { domain: opts.domain } : {}),
     ...(opts.repository ? { repository: opts.repository } : {}),
+    ...(opts.title ? { title: opts.title } : {}),
+    ...(opts.description ? { description: opts.description } : {}),
   };
 
   if (parentConfig.app && typeof parentConfig.app === "object") {
@@ -760,6 +926,7 @@ export async function scaffoldMinimalProject(
       typecheck: "node_modules/.bin/bos types gen && tsc --noEmit",
       postinstall: "node_modules/.bin/bos types gen || true",
       "types:gen": "node_modules/.bin/bos types gen",
+      bos: "node_modules/.bin/bos",
     },
     dependencies: {
       "everything-dev": "catalog:",

package/src/cli/upgrade.ts

@@ -7,7 +7,7 @@ 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 { fetchParentConfig, runBunInstallForUpgrade, runTypesGen } from "./init";
 import { syncTemplate } from "./sync";
 import { timePhase } from "./timing";
 
@@ -781,7 +781,7 @@ export async function upgradeTemplate(
   }
 
   if ((hasUpdates || addedPlugins.length > 0) && !options.noInstall) {
-    await timePhase(timings, "install dependencies", () => runBunInstall(projectDir));
+    await timePhase(timings, "install dependencies", () => runBunInstallForUpgrade(projectDir));
     await timePhase(timings, "generate types", () => runTypesGen(projectDir));
   }
 

package/src/plugin.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import * as p from "@clack/prompts";
 import { Effect } from "effect";
@@ -1428,6 +1428,11 @@ export default createPlugin({
             );
           }
 
+          const lockfilePath = join(targetDir, "bun.lock");
+          if (existsSync(lockfilePath)) {
+            rmSync(lockfilePath, { force: true });
+          }
+
           const initConfig = await timePhase(
             timings,
             "resolve config",
@@ -1454,8 +1459,12 @@ export default createPlugin({
           );
 
           if (!input.noInstall) {
-            await timePhase(timings, "install dependencies", () => runBunInstall(targetDir), s);
-            await timePhase(timings, "generate types", () => runTypesGen(targetDir), s);
+            await timePhase(timings, "install dependencies", () =>
+              runBunInstall(targetDir, s ?? undefined),
+            );
+            await timePhase(timings, "generate types", () =>
+              runTypesGen(targetDir, s ?? undefined),
+            );
             await timePhase(
               timings,
               "generate migrations",