everything-dev 1.15.0 → 1.16.1

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

@@ -5,6 +5,8 @@ export const BOS_CONFIG_ORDER = [
   "extends",
   "account",
   "domain",
+  "title",
+  "description",
   "testnet",
   "staging",
   "repository",
@@ -93,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>;

package/src/near-cli.ts

@@ -1,6 +1,6 @@
-import { spawn } from "node:child_process";
 import { generateKeyPairSync } from "node:crypto";
 import { Effect } from "effect";
+import { execa } from "execa";
 
 export interface NearTransactionConfig {
   account: string;
@@ -112,49 +112,34 @@ export function generateNearKeyPair(): NearKeyPair {
 
 const checkNearCliInstalled = Effect.tryPromise({
   try: async () => {
-    return await new Promise<boolean>((resolve) => {
-      const proc = spawn("near", ["--version"], { stdio: "pipe" });
-      proc.on("close", (code) => resolve(code === 0));
-      proc.on("error", () => resolve(false));
-    });
+    try {
+      await execa("near", ["--version"], { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
   },
   catch: () => new Error("Failed to check NEAR CLI"),
 });
 
 const installNearCli = Effect.tryPromise({
   try: async () => {
-    return await new Promise<void>((resolve, reject) => {
-      const proc = spawn(
-        "sh",
-        ["-c", `curl --proto '=https' --tlsv1.2 -LsSf ${INSTALLER_URL} | sh`],
-        {
-          stdio: "inherit",
-        },
-      );
-
-      proc.on("close", (code) => {
-        if (code === 0) resolve();
-        else reject(new NearCliInstallError(`Installer exited with code ${code}`));
-      });
-      proc.on("error", (err) => reject(new NearCliInstallError(err.message)));
+    await execa("sh", ["-c", `curl --proto '=https' --tlsv1.2 -LsSf ${INSTALLER_URL} | sh`], {
+      stdio: "inherit",
     });
   },
-  catch: (error) => error as Error,
+  catch: (error) => {
+    if (error instanceof Error && "exitCode" in error) {
+      return new NearCliInstallError(
+        `Installer exited with code ${(error as { exitCode: number }).exitCode}`,
+      );
+    }
+    return new NearCliInstallError(error instanceof Error ? error.message : String(error));
+  },
 });
 
 async function runNearCommand(args: string[]): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    const proc = spawn("near", args, {
-      stdio: "inherit",
-    });
-
-    proc.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`near ${args.join(" ")} failed with exit code ${code}`));
-    });
-
-    proc.on("error", (err) => reject(new Error(err.message)));
-  });
+  await execa("near", args, { stdio: "inherit" });
 }
 
 export const ensureNearCli = Effect.gen(function* () {
@@ -209,43 +194,31 @@ export const executeTransaction = (
 
     const output = yield* Effect.tryPromise({
       try: async () => {
-        return await new Promise<string>((resolve, reject) => {
-          const proc = spawn("near", args, { stdio: ["inherit", "pipe", "pipe"] });
-
-          let stdout = "";
-          let stderr = "";
-
-          proc.stdout?.on("data", (data) => {
-            const text = data.toString();
-            stdout += text;
-            process.stdout.write(text);
-          });
-
-          proc.stderr?.on("data", (data) => {
-            const text = data.toString();
-            stderr += text;
-          });
-
-          proc.on("close", (code) => {
-            const combined = `${stdout}\n${stderr}`;
-            const txHashMatch = combined.match(/Transaction ID:\s*([A-Za-z0-9]+)/i);
-            const hasCodeDoesNotExist = /CodeDoesNotExist/i.test(combined);
-            const hasTransactionFailed = /Transaction failed/i.test(combined);
-            const softSuccess =
-              Boolean(txHashMatch?.[1]) && hasCodeDoesNotExist && hasTransactionFailed;
-
-            if (code === 0 || softSuccess) {
-              if (softSuccess) {
-                console.log(`  ${txHashMatch?.[1]} — FastDATA CodeDoesNotExist (expected)`);
-              }
-              resolve(combined);
-            } else {
-              reject(new NearTransactionError(stderr || `Transaction failed with code ${code}`));
-            }
-          });
-
-          proc.on("error", (err) => reject(new NearTransactionError(err.message)));
+        const result = await execa("near", args, {
+          stdin: "inherit",
+          stdout: "pipe",
+          stderr: "pipe",
+          reject: false,
         });
+
+        process.stdout.write(result.stdout);
+        const combined = `${result.stdout}\n${result.stderr}`;
+        const txHashMatch = combined.match(/Transaction ID:\s*([A-Za-z0-9]+)/i);
+        const hasCodeDoesNotExist = /CodeDoesNotExist/i.test(combined);
+        const hasTransactionFailed = /Transaction failed/i.test(combined);
+        const softSuccess =
+          Boolean(txHashMatch?.[1]) && hasCodeDoesNotExist && hasTransactionFailed;
+
+        if (result.exitCode === 0 || softSuccess) {
+          if (softSuccess) {
+            console.log(`  ${txHashMatch?.[1]} — FastDATA CodeDoesNotExist (expected)`);
+          }
+          return combined;
+        }
+
+        throw new NearTransactionError(
+          result.stderr || `Transaction failed with code ${result.exitCode}`,
+        );
       },
       catch: (error) => error as Error,
     });