everything-dev 1.17.0 → 1.20.0

package/src/cli/init.ts

@@ -20,7 +20,7 @@ import {
   loadManifestNormalizationSpec,
   normalizePackageManifestsInTree,
 } from "../internal/manifest-normalizer";
-import type { BosConfig } from "../types";
+import type { BosConfig, BosConfigInput } from "../types";
 import { isPathExcluded } from "../utils/path-match";
 import { saveBosConfig } from "../utils/save-config";
 import { writeSnapshot } from "./snapshot";
@@ -51,12 +51,25 @@ export async function resolveSourceDir(opts: {
 
   const parentConfig = await fetchParentConfig(opts.extendsAccount, opts.extendsGateway);
 
-  if (!parentConfig.repository) {
-    throw new Error("Parent config has no repository field — cannot locate template source");
+  if (parentConfig.repository) {
+    const { dir: sourceDir, cleanup } = await downloadTarball(parentConfig.repository);
+    return { sourceDir, parentConfig, cleanup };
   }
 
-  const { dir: sourceDir, cleanup } = await downloadTarball(parentConfig.repository);
-  return { sourceDir, parentConfig, cleanup };
+  const chainResult = await resolveRepositoryViaExtendsChain(
+    opts.extendsAccount,
+    opts.extendsGateway,
+  );
+  if (chainResult?.repository) {
+    const { dir: sourceDir, cleanup } = await downloadTarball(chainResult.repository);
+    return { sourceDir, parentConfig: chainResult.config, cleanup };
+  }
+
+  return {
+    sourceDir: "",
+    parentConfig,
+    cleanup: async () => {},
+  };
 }
 
 export async function readTemplatekeep(sourceDir: string): Promise<string[]> {
@@ -80,6 +93,37 @@ export async function fetchParentConfig(
   return fetchBosConfigFromFastKv<BosConfig>(bosUrl);
 }
 
+export async function resolveRepositoryViaExtendsChain(
+  extendsAccount: string,
+  extendsGateway: string,
+  visited = new Set<string>(),
+): Promise<{ repository: string; config: BosConfig } | null> {
+  const key = `bos://${extendsAccount}/${extendsGateway}`;
+  if (visited.has(key)) return null;
+  visited.add(key);
+
+  try {
+    const config = await fetchParentConfig(extendsAccount, extendsGateway);
+    if (config.repository) {
+      return { repository: config.repository, config };
+    }
+
+    const extendsRef = config.extends;
+    if (extendsRef && typeof extendsRef === "string") {
+      const normalized = extendsRef.startsWith("bos://") ? extendsRef : `bos://${extendsRef}`;
+      const match = normalized.match(/^bos:\/\/([^/]+)\/(.+)$/);
+      if (match) {
+        const result = await resolveRepositoryViaExtendsChain(match[1], match[2], visited);
+        if (result) return result;
+      }
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
 export async function downloadTarball(
   repoUrl: string,
 ): Promise<{ dir: string; cleanup: () => Promise<void> }> {
@@ -286,89 +330,21 @@ export async function personalizeConfig(
         }
       }
 
-      if (isInit) {
-        const parentDomain = opts.extendsGateway;
+      for (const pluginKey of Object.keys(plugins)) {
+        const plugin = plugins[pluginKey];
+        let pluginObj: Record<string, unknown>;
 
-        for (const pluginKey of Object.keys(plugins)) {
-          const plugin = plugins[pluginKey];
-          let pluginObj: Record<string, unknown>;
-
-          if (typeof plugin === "string") {
-            pluginObj = { extends: plugin };
-            plugins[pluginKey] = pluginObj;
-          } else if (plugin && typeof plugin === "object") {
-            pluginObj = { ...(plugin as Record<string, unknown>) };
-          } else {
-            continue;
-          }
-
-          if (
-            pluginObj.development &&
-            typeof pluginObj.development === "string" &&
-            pluginObj.development.startsWith("local:")
-          ) {
-            const pluginDir = join(destination, pluginObj.development.slice("local:".length));
-            const pluginConfigPath = join(pluginDir, "bos.config.json");
-
-            if (existsSync(pluginConfigPath)) {
-              try {
-                const pluginConfig = JSON.parse(readFileSync(pluginConfigPath, "utf-8")) as Record<
-                  string,
-                  unknown
-                >;
-                const normalizedConfig = ensureLocalPluginProviderConfig(
-                  pluginConfig,
-                  pluginKey,
-                  `${pluginKey}.${opts.domain ?? parentDomain}`,
-                  pluginObj,
-                  opts.pluginRoutes,
-                );
-                if (stripProviderProductionFields(normalizedConfig)) {
-                  writeFileSync(pluginConfigPath, `${JSON.stringify(normalizedConfig, null, 2)}\n`);
-                }
-              } catch {}
-            } else if (existsSync(pluginDir)) {
-              const pluginConfig = ensureLocalPluginProviderConfig(
-                {},
-                pluginKey,
-                `${pluginKey}.${opts.domain ?? parentDomain}`,
-                pluginObj,
-                opts.pluginRoutes,
-              );
-
-              mkdirSync(pluginDir, { recursive: true });
-              writeFileSync(pluginConfigPath, `${JSON.stringify(pluginConfig, null, 2)}\n`);
-            }
-
-            plugins[pluginKey] = buildCleanPluginEntry(pluginObj);
-          } else {
-            delete pluginObj.production;
-            delete pluginObj.integrity;
-            delete pluginObj.sidebar;
-            delete pluginObj.routes;
-          }
-        }
-      } else {
-        for (const pluginKey of Object.keys(plugins)) {
-          const pluginDir = resolve(
-            destination,
-            (plugins[pluginKey] as Record<string, unknown>)?.development
-              ?.toString()
-              ?.slice("local:".length) ?? "",
-          );
-          const pluginConfigPath = join(pluginDir, "bos.config.json");
-          if (!existsSync(pluginConfigPath)) continue;
-
-          try {
-            const pluginConfig = JSON.parse(readFileSync(pluginConfigPath, "utf-8")) as Record<
-              string,
-              unknown
-            >;
-            if (stripProviderProductionFields(pluginConfig)) {
-              writeFileSync(pluginConfigPath, `${JSON.stringify(pluginConfig, null, 2)}\n`);
-            }
-          } catch {}
+        if (typeof plugin === "string") {
+          pluginObj = { extends: plugin };
+          plugins[pluginKey] = pluginObj;
+        } else if (plugin && typeof plugin === "object") {
+          pluginObj = { ...(plugin as Record<string, unknown>) };
+        } else {
+          continue;
         }
+
+        delete pluginObj.production;
+        delete pluginObj.integrity;
       }
 
       if (Object.keys(plugins).length === 0) {
@@ -506,82 +482,6 @@ export async function personalizeConfig(
   }
 }
 
-function stripProviderProductionFields(config: Record<string, unknown>): boolean {
-  let changed = false;
-
-  if ("extends" in config) {
-    delete config.extends;
-    changed = true;
-  }
-
-  if (config.plugins && typeof config.plugins === "object") {
-    const pluginEntries = config.plugins as Record<string, unknown>;
-    for (const entryKey of Object.keys(pluginEntries)) {
-      const entry = pluginEntries[entryKey];
-      if (!entry || typeof entry !== "object") continue;
-      const normalizedEntry = entry as Record<string, unknown>;
-      if ("production" in normalizedEntry) {
-        delete normalizedEntry.production;
-        changed = true;
-      }
-      if ("integrity" in normalizedEntry) {
-        delete normalizedEntry.integrity;
-        changed = true;
-      }
-    }
-  }
-
-  return changed;
-}
-
-function ensureLocalPluginProviderConfig(
-  pluginConfig: Record<string, unknown>,
-  pluginKey: string,
-  domain: string,
-  pluginObj: Record<string, unknown>,
-  pluginRoutes?: Record<string, string[]>,
-): Record<string, unknown> {
-  pluginConfig.domain = domain;
-  if (!pluginConfig.plugins || typeof pluginConfig.plugins !== "object") {
-    pluginConfig.plugins = {};
-  }
-
-  const plugins = pluginConfig.plugins as Record<string, unknown>;
-  if (!plugins[pluginKey] || typeof plugins[pluginKey] !== "object") {
-    plugins[pluginKey] = {};
-  }
-
-  const pluginEntry = plugins[pluginKey] as Record<string, unknown>;
-  if (!pluginEntry.name) {
-    pluginEntry.name = pluginKey;
-  }
-  if (!pluginEntry.development) {
-    pluginEntry.development = "local:.";
-  }
-  if (pluginRoutes?.[pluginKey]) {
-    pluginEntry.routes = pluginRoutes[pluginKey];
-  }
-  if (pluginObj.sidebar) {
-    pluginEntry.sidebar = pluginObj.sidebar;
-  }
-
-  return pluginConfig;
-}
-
-function buildCleanPluginEntry(pluginObj: Record<string, unknown>): Record<string, unknown> {
-  const cleanEntry: Record<string, unknown> = { development: pluginObj.development };
-  if (pluginObj.extends) {
-    cleanEntry.extends = pluginObj.extends;
-  }
-  if (pluginObj.secrets) {
-    cleanEntry.secrets = pluginObj.secrets;
-  }
-  if (pluginObj.variables) {
-    cleanEntry.variables = pluginObj.variables;
-  }
-  return cleanEntry;
-}
-
 function generateAuthTypesTemplate(): string {
   return `import type { Auth } from "better-auth";
 export type { Auth } from "better-auth";
@@ -650,6 +550,121 @@ const WORKSPACE_LOCAL_PATHS: Record<string, string> = {
   "every-plugin": "packages/every-plugin",
 };
 
+export async function scaffoldMinimalProject(
+  destination: string,
+  parentConfig: BosConfigInput,
+  opts: {
+    extendsAccount: string;
+    extendsGateway: string;
+    account?: string;
+    domain?: string;
+    plugins?: string[];
+    withHost?: boolean;
+  },
+): Promise<number> {
+  mkdirSync(destination, { recursive: true });
+
+  const config: Record<string, unknown> = {
+    extends: `bos://${opts.extendsAccount}/${opts.extendsGateway}`,
+    account: opts.account || opts.extendsAccount,
+    ...(opts.domain ? { domain: opts.domain } : {}),
+  };
+
+  if (parentConfig.app && typeof parentConfig.app === "object") {
+    const app: Record<string, unknown> = {};
+    const parentApp = parentConfig.app as Record<string, Record<string, unknown>>;
+
+    if (parentApp.host) {
+      app.host = { ...parentApp.host };
+      const host = app.host as Record<string, unknown>;
+      delete host.production;
+      delete host.integrity;
+    }
+
+    if (parentApp.ui) {
+      app.ui = { ...parentApp.ui };
+      const ui = app.ui as Record<string, unknown>;
+      delete ui.production;
+      delete ui.integrity;
+      delete ui.ssr;
+      delete ui.ssrIntegrity;
+    }
+
+    if (parentApp.api) {
+      app.api = { ...parentApp.api };
+      const api = app.api as Record<string, unknown>;
+      delete api.production;
+      delete api.integrity;
+    }
+
+    if (parentApp.auth) {
+      app.auth = { ...parentApp.auth };
+      const auth = app.auth as Record<string, unknown>;
+      delete auth.production;
+      delete auth.integrity;
+    }
+
+    config.app = app;
+  }
+
+  if (opts.plugins && opts.plugins.length > 0 && parentConfig.plugins) {
+    const plugins: Record<string, unknown> = {};
+    for (const key of opts.plugins) {
+      const parentPlugin = (parentConfig.plugins as Record<string, unknown>)?.[key];
+      if (parentPlugin) {
+        if (typeof parentPlugin === "string") {
+          plugins[key] = { extends: parentPlugin };
+        } else {
+          const pluginCopy = { ...(parentPlugin as Record<string, unknown>) };
+          delete pluginCopy.production;
+          delete pluginCopy.integrity;
+          plugins[key] = pluginCopy;
+        }
+      }
+    }
+    config.plugins = plugins;
+  }
+
+  await saveBosConfig(destination, config);
+
+  const pkg: Record<string, unknown> = {
+    name: opts.domain || opts.extendsGateway,
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "node_modules/.bin/bos dev --host remote",
+      "dev:ui": "node_modules/.bin/bos dev --ui local --api remote",
+      "dev:api": "node_modules/.bin/bos dev --ui remote --api local",
+      build: "node_modules/.bin/bos build",
+      deploy: "node_modules/.bin/bos build --deploy",
+      publish: "node_modules/.bin/bos publish",
+      start: "node_modules/.bin/bos start",
+      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",
+    },
+    dependencies: {
+      "everything-dev": "catalog:",
+      "every-plugin": "catalog:",
+    },
+    devDependencies: {},
+    workspaces: {
+      packages: [],
+      catalog: {},
+    },
+  };
+  writeFileSync(join(destination, "package.json"), `${JSON.stringify(pkg, null, 2)}\n`);
+
+  const envExample = generateEnvExample(parentConfig);
+  if (envExample) {
+    writeFileSync(join(destination, ".env.example"), envExample);
+  }
+
+  writeFileSync(join(destination, ".gitignore"), generateGitignore());
+
+  return 4;
+}
+
 async function resolveWorkspaceRefs(
   destination: string,
   options?: { localOverrides?: boolean; sourceDir?: string },
@@ -801,3 +816,50 @@ 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" });
 }
+
+function generateEnvExample(config: BosConfigInput): string {
+  const lines: string[] = ["# Environment variables"];
+  const collectSecrets = (obj: Record<string, unknown>, prefix = ""): void => {
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "secrets" && Array.isArray(value)) {
+        for (const secret of value) {
+          if (typeof secret === "string") {
+            lines.push(`${secret}=`);
+          }
+        }
+      } else if (key === "variables" && isPlainObject(value)) {
+        for (const [varKey, varVal] of Object.entries(value as Record<string, unknown>)) {
+          if (typeof varVal === "string") {
+            lines.push(`${varKey}=${varVal}`);
+          }
+        }
+      } else if (isPlainObject(value) && key !== "extends") {
+        collectSecrets(value as Record<string, unknown>, `${prefix}${key}.`);
+      }
+    }
+  };
+
+  if (config.app && typeof config.app === "object") {
+    collectSecrets(config.app as Record<string, unknown>);
+  }
+  if (config.plugins && typeof config.plugins === "object") {
+    collectSecrets(config.plugins as Record<string, unknown>);
+  }
+
+  lines.push("BETTER_AUTH_SECRET=generate-a-secret-here");
+  return `${lines.join("\n")}\n`;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function generateGitignore(): string {
+  return `node_modules/
+dist/
+.env
+.bos/
+*.gen.ts
+*.gen.tsx
+`;
+}

package/src/cli/prompts.ts

@@ -2,12 +2,13 @@ import process from "node:process";
 import * as p from "@clack/prompts";
 
 function parseExtendsRef(ref: string): { account: string; gateway: string } | null {
-  const match = ref.match(/^(?:bos:\/\/)?([^/]+)\/(.+)$/);
+  const normalized = ref.startsWith("bos://") ? ref : `bos://${ref}`;
+  const match = normalized.match(/^bos:\/\/([^/]+)\/(.+)$/);
   if (!match) return null;
   return { account: match[1], gateway: match[2] };
 }
 
-function deriveAccountFromDomain(domain: string, extendsAccount: string): string {
+function deriveAccountFromExtends(domain: string, extendsAccount: string): string {
   const firstSegment = domain.split(".")[0];
   if (!firstSegment) return "";
   const suffix = extendsAccount.includes(".")
@@ -17,8 +18,6 @@ function deriveAccountFromDomain(domain: string, extendsAccount: string): string
 }
 
 export async function promptInitOptions(input: {
-  extendsAccount?: string;
-  extendsGateway?: string;
   extends?: string;
   directory?: string;
   account?: string;
@@ -37,40 +36,36 @@ export async function promptInitOptions(input: {
 }> {
   p.intro("Let's build an app...");
 
-  const domain =
-    input.domain ??
-    ((await p.text({
-      message: "Starting with a domain?",
-      placeholder: "no",
-    })) as string);
-
-  if (p.isCancel(domain)) process.exit(0);
-
-  const extendsPlaceholder = "bos://dev.everything.near/everything.dev";
   const extendsInput =
     input.extends ??
     ((await p.text({
       message: "Extending an existing app?",
-      placeholder: extendsPlaceholder,
+      placeholder: "bos://dev.everything.near/everything.dev",
     })) as string);
 
   if (p.isCancel(extendsInput)) process.exit(0);
 
-  let extendsAccount = input.extendsAccount || "";
-  let extendsGateway = input.extendsGateway || "";
+  let extendsAccount = "dev.everything.near";
+  let extendsGateway = "everything.dev";
 
   if (extendsInput) {
     const parsed = parseExtendsRef(extendsInput);
     if (parsed) {
-      extendsAccount = extendsAccount || parsed.account;
-      extendsGateway = extendsGateway || parsed.gateway;
+      extendsAccount = parsed.account;
+      extendsGateway = parsed.gateway;
     }
   }
 
-  extendsAccount = extendsAccount || "dev.everything.near";
-  extendsGateway = extendsGateway || "everything.dev";
+  const domain =
+    input.domain ??
+    ((await p.text({
+      message: "Starting with a domain?",
+      placeholder: "no",
+    })) as string);
+
+  if (p.isCancel(domain)) process.exit(0);
 
-  const accountDefault = domain ? deriveAccountFromDomain(domain, extendsAccount) : "";
+  const accountDefault = domain ? deriveAccountFromExtends(domain, extendsAccount) : "";
   const account =
     input.account ??
     ((await p.text({

package/src/cli/timing.ts

@@ -1,13 +1,40 @@
+import type { spinner as clackSpinner } from "@clack/prompts";
+
+type Spinner = ReturnType<typeof clackSpinner>;
+
 export interface PhaseTiming {
   name: string;
   durationMs: number;
 }
 
+const PHASE_LABELS: Record<string, string> = {
+  "parent config": "Fetching parent config...",
+  "template source": "Resolving template source...",
+  "scaffold project": "Creating project scaffold...",
+  "copy files": "Copying template files...",
+  "personalize config": "Personalizing config...",
+  "write snapshot": "Writing snapshot...",
+  "resolve config": "Resolving config...",
+  "generate env/docker": "Generating environment config...",
+  "create env file": "Creating .env file...",
+  "install dependencies": "Installing dependencies...",
+  "generate types": "Generating types...",
+  "generate migrations": "Generating database migrations...",
+  "generate code artifacts": "Generating code artifacts...",
+  "docker compose up": "Starting Docker services...",
+};
+
+function phaseLabel(name: string): string {
+  return PHASE_LABELS[name] ?? name;
+}
+
 export async function timePhase<T>(
   timings: PhaseTiming[],
   name: string,
   fn: () => Promise<T>,
+  spinner?: Spinner,
 ): Promise<T> {
+  spinner?.message(phaseLabel(name));
   const startedAt = Date.now();
   try {
     return await fn();