everything-dev 1.21.0 → 1.23.0

package/dist/types.d.mts

@@ -397,9 +397,9 @@ declare const BosConfigSchema: z.ZodObject<{
 type BosConfig = z.infer<typeof BosConfigSchema>;
 declare const RuntimeConfigSchema: z.ZodObject<{
   env: z.ZodEnum<{
+    development: "development";
     production: "production";
     staging: "staging";
-    development: "development";
   }>;
   account: z.ZodString;
   domain: z.ZodOptional<z.ZodString>;
@@ -539,9 +539,9 @@ type RuntimeConfig = z.infer<typeof RuntimeConfigSchema>;
 declare const ClientRuntimeConfigSchema: z.ZodObject<{
   cspNonce: z.ZodOptional<z.ZodString>;
   env: z.ZodEnum<{
+    development: "development";
     production: "production";
     staging: "staging";
-    development: "development";
   }>;
   account: z.ZodString;
   networkId: z.ZodEnum<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "everything-dev",
-  "version": "1.21.0",
+  "version": "1.23.0",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/src/cli/init.ts

@@ -28,6 +28,8 @@ import { writeSnapshot } from "./snapshot";
 
 const require = createRequire(import.meta.url);
 
+const FRAMEWORK_PACKAGES = ["every-plugin", "everything-dev"] as const;
+
 const _DEFAULT_OVERRIDES: OverrideSection[] = ["ui", "api"];
 
 const OVERRIDE_WORKSPACE_MAP: Record<OverrideSection, string[]> = {
@@ -628,16 +630,94 @@ export interface AuthServices {
 `;
 }
 
-export async function runBunInstall(destination: string): Promise<void> {
-  await execCommand("bun", ["install", "--ignore-scripts"], destination);
+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);
+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);
+  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> = {
@@ -645,6 +725,63 @@ const WORKSPACE_LOCAL_PATHS: Record<string, string> = {
   "every-plugin": "packages/every-plugin",
 };
 
+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`);
+      const pkg = JSON.parse(readFileSync(resolved, "utf-8")) as { version?: string };
+      if (pkg.version) {
+        catalog[packageName] = `^${pkg.version}`;
+      }
+    } catch {}
+  }
+  return catalog;
+}
+
 export async function scaffoldMinimalProject(
   destination: string,
   parentConfig: BosConfigInput,
@@ -727,6 +864,8 @@ export async function scaffoldMinimalProject(
     }
   }
 
+  const catalog = resolveFrameworkCatalog();
+
   const pkg: Record<string, unknown> = {
     name: opts.domain || opts.extendsGateway,
     private: true,
@@ -750,7 +889,7 @@ export async function scaffoldMinimalProject(
     devDependencies: {},
     workspaces: {
       packages: workspacePackages,
-      catalog: {},
+      catalog,
     },
   };
   writeFileSync(join(destination, "package.json"), `${JSON.stringify(pkg, null, 2)}\n`);
@@ -920,8 +1059,21 @@ export async function generateDatabaseMigrations(destination: string): Promise<v
   }
 }
 
-export async function execCommand(command: string, args: string[], cwd?: string): Promise<void> {
-  await execa(command, args, { cwd, stdio: "pipe" });
+const COMMAND_TIMEOUTS: Record<string, number> = {
+  bun: 5 * 60_000,
+  docker: 5 * 60_000,
+  node_modules: 2 * 60_000,
+  tar: 60_000,
+};
+
+export async function execCommand(
+  command: string,
+  args: string[],
+  cwd?: string,
+  options?: { stdio?: "pipe" | "inherit" },
+): Promise<void> {
+  const timeout = COMMAND_TIMEOUTS[command] ?? 2 * 60_000;
+  await execa(command, args, { cwd, stdio: options?.stdio ?? "pipe", timeout });
 }
 
 function generateEnvExample(config: BosConfigInput, overrides: OverrideSection[]): string {

package/src/fastkv.ts

@@ -141,8 +141,13 @@ export interface PluginManifest {
 
 export async function fetchRemotePluginManifest(cdnUrl: string): Promise<PluginManifest | null> {
   try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FASTKV_TIMEOUT_MS);
     const baseUrl = cdnUrl.replace(/\/$/, "");
-    const response = await fetch(`${baseUrl}/plugin.manifest.json`);
+    const response = await fetch(`${baseUrl}/plugin.manifest.json`, {
+      signal: controller.signal,
+    });
+    clearTimeout(timeout);
     if (!response.ok) return null;
     return (await response.json()) as PluginManifest;
   } catch {

package/src/plugin.ts

@@ -17,6 +17,7 @@ import {
   runDockerComposeUp,
   runTypesGen,
   scaffoldMinimalProject,
+  stripOrphanedWorkspacesFromLockfile,
   writeInitSnapshot,
 } from "./cli/init";
 import { promptInitOptions } from "./cli/prompts";
@@ -1336,6 +1337,23 @@ export default createPlugin({
                 }),
               s,
             );
+
+            await timePhase(
+              timings,
+              "personalize config",
+              () =>
+                personalizeConfig(targetDir, {
+                  extendsAccount,
+                  extendsGateway,
+                  account: account || extendsAccount,
+                  domain: domain || extendsGateway,
+                  plugins,
+                  overrides,
+                  mode: "init",
+                  repository,
+                }),
+              s,
+            );
           } else {
             const patterns = await readTemplatekeep(sourceDir);
             if (patterns.length === 0) {
@@ -1411,6 +1429,10 @@ export default createPlugin({
             );
           }
 
+          const lockfilePath = join(targetDir, "bun.lock");
+          const allowedWorkspaces = computeAllowedWorkspaces(overrides, plugins);
+          stripOrphanedWorkspacesFromLockfile(lockfilePath, allowedWorkspaces);
+
           const initConfig = await timePhase(
             timings,
             "resolve config",
@@ -1437,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",
@@ -1721,3 +1747,23 @@ function extractTransactionHash(error: unknown) {
   const match = message.match(/Transaction ID:\s*([A-Za-z0-9]+)/i);
   return match?.[1];
 }
+
+const OVERRIDE_WORKSPACE_MAP: Record<string, string[]> = {
+  ui: ["ui"],
+  api: ["api"],
+  host: ["host"],
+  plugins: [],
+};
+
+function computeAllowedWorkspaces(overrides: string[], plugins?: string[]): string[] {
+  const workspaces: string[] = [];
+  for (const section of overrides) {
+    workspaces.push(...(OVERRIDE_WORKSPACE_MAP[section] ?? []));
+  }
+  if (plugins) {
+    for (const plugin of plugins) {
+      workspaces.push(`plugins/${plugin}`);
+    }
+  }
+  return workspaces;
+}