everything-dev 0.3.3 → 1.3.3

package/src/internal/manifest-normalizer.ts

@@ -0,0 +1,251 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { glob } from "glob";
+
+const FRAMEWORK_PACKAGES = ["every-plugin", "everything-dev"] as const;
+
+type PackageJson = Record<string, unknown>;
+
+type NormalizationSpec = {
+  rootCatalog: Record<string, string>;
+  frameworkVersions: Record<string, string>;
+};
+
+type NormalizeManifestOptions = {
+  resolveCatalogRefs: boolean;
+  excludeFrameworkWorkspaces?: boolean;
+  removeWorkspaceDeps?: string[];
+  removeWorkspaces?: boolean;
+  removePublishScripts?: boolean;
+};
+
+export type NormalizeTreeOptions = NormalizeManifestOptions & {
+  sourceRootDir: string;
+  targetDir: string;
+};
+
+function readJson<T>(filePath: string): T {
+  return JSON.parse(readFileSync(filePath, "utf-8")) as T;
+}
+
+function extractExactVersion(input: string | undefined): string | null {
+  if (!input) return null;
+  const match = input.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+  return match ? match[0] : null;
+}
+
+function writeJson(filePath: string, value: PackageJson) {
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export function loadManifestNormalizationSpec(sourceRootDir: string): NormalizationSpec {
+  const rootPackage = readJson<PackageJson>(join(sourceRootDir, "package.json"));
+  const rootCatalog = {
+    ...(((rootPackage.workspaces as { catalog?: Record<string, string> } | undefined)?.catalog ??
+      {}) as Record<string, string>),
+  };
+  const frameworkVersions: Record<string, string> = {};
+
+  for (const packageName of FRAMEWORK_PACKAGES) {
+    const sourcePackagePath = join(sourceRootDir, "packages", packageName, "package.json");
+    const localPackagePath = join(import.meta.dirname, "..", "..", packageName, "package.json");
+    const packageVersion = existsSync(sourcePackagePath)
+      ? readJson<{ version: string }>(sourcePackagePath).version
+      : existsSync(localPackagePath)
+        ? readJson<{ version: string }>(localPackagePath).version
+        : extractExactVersion(rootCatalog[packageName]);
+
+    if (!packageVersion) {
+      throw new Error(`Could not resolve version for ${packageName}`);
+    }
+
+    frameworkVersions[packageName] = packageVersion;
+    rootCatalog[packageName] = `^${packageVersion}`;
+  }
+
+  return { rootCatalog, frameworkVersions };
+}
+
+function normalizeDependencyMap(
+  map: Record<string, string>,
+  spec: NormalizationSpec,
+  options: NormalizeManifestOptions,
+) {
+  let modified = false;
+
+  for (const [name, version] of Object.entries(map)) {
+    if (version === "workspace:*") {
+      const frameworkVersion = spec.frameworkVersions[name];
+      if (frameworkVersion) {
+        map[name] = `^${frameworkVersion}`;
+        modified = true;
+        continue;
+      }
+
+      if (options.removeWorkspaceDeps?.includes(name)) {
+        delete map[name];
+        modified = true;
+      }
+      continue;
+    }
+
+    if (options.resolveCatalogRefs && version.startsWith("catalog:")) {
+      const resolved = spec.rootCatalog[name];
+      if (resolved) {
+        map[name] = resolved;
+        modified = true;
+      }
+    }
+  }
+
+  return modified;
+}
+
+export function normalizePackageManifest(
+  pkg: PackageJson,
+  spec: NormalizationSpec,
+  options: NormalizeManifestOptions,
+) {
+  let modified = false;
+
+  for (const depField of ["dependencies", "devDependencies", "peerDependencies"]) {
+    const deps = pkg[depField];
+    if (!deps || typeof deps !== "object") continue;
+    if (normalizeDependencyMap(deps as Record<string, string>, spec, options)) {
+      modified = true;
+    }
+  }
+
+  if (pkg.workspaces && typeof pkg.workspaces === "object") {
+    const workspaces = pkg.workspaces as {
+      packages?: string[];
+      catalog?: Record<string, string>;
+    };
+
+    if (options.excludeFrameworkWorkspaces && Array.isArray(workspaces.packages)) {
+      const nextPackages = workspaces.packages.filter(
+        (entry) => !FRAMEWORK_PACKAGES.some((name) => entry === `packages/${name}`),
+      );
+      if (nextPackages.length !== workspaces.packages.length) {
+        workspaces.packages = nextPackages;
+        modified = true;
+      }
+    }
+
+    if (workspaces.catalog && typeof workspaces.catalog === "object") {
+      for (const [name, version] of Object.entries(workspaces.catalog)) {
+        const resolved = spec.rootCatalog[name];
+        if (resolved && resolved !== version) {
+          workspaces.catalog[name] = resolved;
+          modified = true;
+          continue;
+        }
+
+        if (version === "workspace:*" && spec.frameworkVersions[name]) {
+          workspaces.catalog[name] = `^${spec.frameworkVersions[name]}`;
+          modified = true;
+        }
+      }
+    }
+  }
+
+  if (options.removeWorkspaces && "workspaces" in pkg) {
+    delete pkg.workspaces;
+    modified = true;
+  }
+
+  if (options.removePublishScripts && pkg.scripts && typeof pkg.scripts === "object") {
+    const scripts = pkg.scripts as Record<string, string>;
+    let scriptsModified = false;
+    for (const key of ["prepublishOnly", "prepack", "prepare", "postpack"]) {
+      if (key in scripts) {
+        delete scripts[key];
+        scriptsModified = true;
+      }
+    }
+    if (scriptsModified) {
+      modified = true;
+      if (Object.keys(scripts).length === 0) {
+        delete pkg.scripts;
+      }
+    }
+  }
+
+  return modified;
+}
+
+export async function normalizePackageManifestsInTree(opts: NormalizeTreeOptions) {
+  const spec = loadManifestNormalizationSpec(opts.sourceRootDir);
+  const files = await glob("**/package.json", {
+    cwd: opts.targetDir,
+    nodir: true,
+    dot: false,
+    absolute: true,
+    ignore: ["**/node_modules/**"],
+  });
+
+  const updatedFiles: string[] = [];
+
+  for (const filePath of files) {
+    const pkg = readJson<PackageJson>(filePath);
+    if (normalizePackageManifest(pkg, spec, opts)) {
+      writeJson(filePath, pkg);
+      updatedFiles.push(filePath);
+    }
+  }
+
+  return updatedFiles;
+}
+
+function shouldCopyPackageFile(sourceDir: string, filePath: string) {
+  const relPath = relative(sourceDir, filePath);
+  if (!relPath) return true;
+  const segments = relPath.split(sep);
+  return !segments.includes("node_modules") && !segments.includes("tests");
+}
+
+export function stageReleasePackage(opts: {
+  repoRoot: string;
+  packageName: string;
+  outDir: string;
+}) {
+  const sourceDir = join(opts.repoRoot, "packages", opts.packageName);
+
+  rmSync(opts.outDir, { recursive: true, force: true });
+  mkdirSync(dirname(opts.outDir), { recursive: true });
+  cpSync(sourceDir, opts.outDir, {
+    recursive: true,
+    filter: (filePath) => shouldCopyPackageFile(sourceDir, filePath),
+  });
+  rmSync(join(opts.outDir, "tests"), { recursive: true, force: true });
+
+  const packageJsonPath = join(opts.outDir, "package.json");
+  const spec = loadManifestNormalizationSpec(opts.repoRoot);
+  const pkg = readJson<PackageJson>(packageJsonPath);
+
+  normalizePackageManifest(pkg, spec, {
+    resolveCatalogRefs: true,
+    removeWorkspaces: true,
+    removePublishScripts: true,
+  });
+
+  writeJson(packageJsonPath, pkg);
+}
+
+export function stageReleasePackages(opts: {
+  repoRoot: string;
+  outDir: string;
+  packageNames?: string[];
+}) {
+  const packageNames = opts.packageNames ?? [...FRAMEWORK_PACKAGES];
+  rmSync(opts.outDir, { recursive: true, force: true });
+  mkdirSync(opts.outDir, { recursive: true });
+
+  for (const packageName of packageNames) {
+    stageReleasePackage({
+      repoRoot: opts.repoRoot,
+      packageName,
+      outDir: join(opts.outDir, packageName),
+    });
+  }
+}

package/src/mf.ts

@@ -0,0 +1,105 @@
+import { createInstance, getInstance } from "@module-federation/enhanced/runtime";
+import { setGlobalFederationInstance } from "@module-federation/runtime-core";
+
+type FederationInstance = ReturnType<typeof createInstance>;
+
+let mfInstance: FederationInstance | null = null;
+
+export function patchManifestFetchForSsrPublicPath(mf: FederationInstance): void {
+  if (!mf || !(mf as any).loaderHook?.lifecycle?.fetch?.on) return;
+  if ((mf as any).__everythingDevPatchedManifestFetch === true) return;
+  (mf as any).__everythingDevPatchedManifestFetch = true;
+
+  (mf as any).loaderHook.lifecycle.fetch.on((url: unknown, init: unknown) => {
+    if (typeof url !== "string" || !url.endsWith("/mf-manifest.json")) {
+      return;
+    }
+    return fetch(url, init as any)
+      .then((res) => res.json())
+      .then((json: any) => {
+        json.metaData = json.metaData ?? {};
+        json.metaData.ssrPublicPath =
+          json.metaData.ssrPublicPath ?? url.replace(/\/mf-manifest\.json$/, "/");
+        return new Response(JSON.stringify(json), {
+          headers: { "content-type": "application/json" },
+        });
+      });
+  });
+}
+
+export function getFederationInstance(): FederationInstance {
+  if (mfInstance) return mfInstance;
+
+  const existing = getInstance();
+  if (existing) {
+    mfInstance = existing as FederationInstance;
+    setGlobalFederationInstance(mfInstance as any);
+    patchManifestFetchForSsrPublicPath(mfInstance);
+    return mfInstance;
+  }
+
+  mfInstance = createInstance({
+    name: "host",
+    remotes: [],
+  }) as FederationInstance;
+  setGlobalFederationInstance(mfInstance as any);
+  patchManifestFetchForSsrPublicPath(mfInstance);
+  return mfInstance;
+}
+
+export async function registerRemote(opts: {
+  name: string;
+  entry: string;
+  type?: "manifest" | "script";
+}): Promise<void> {
+  const instance = getFederationInstance();
+
+  const inferType = (): "manifest" | "script" => {
+    if (opts.type) return opts.type;
+    if (opts.entry.endsWith("/mf-manifest.json")) return "manifest";
+    if (opts.entry.endsWith("/remoteEntry.js")) return "script";
+    return typeof window === "undefined" ? "script" : "manifest";
+  };
+
+  const remoteType = inferType();
+
+  instance.registerRemotes([
+    {
+      name: opts.name,
+      entry: opts.entry,
+      type: remoteType,
+    },
+  ]);
+}
+
+export async function loadRemoteModule<T>(
+  specifier: string,
+  options?: { loadFactory?: boolean; from?: "build" | "runtime" },
+): Promise<T> {
+  const instance = getFederationInstance();
+
+  const isServer = typeof window === "undefined";
+  if (isServer) {
+    await (instance as any).initializeSharing?.("default");
+  }
+
+  const mod = await instance.loadRemote<T>(specifier, options as any);
+  if (!mod) {
+    throw new Error(`Failed to load remote module: ${specifier}`);
+  }
+  return mod;
+}
+
+export async function ensureNodeRuntimePlugin(): Promise<void> {
+  const instance = getFederationInstance();
+  if (typeof window !== "undefined") return;
+  if ((instance as any).__nodeRuntimePluginLoaded) return;
+
+  const mod: any = await import("@module-federation/node/runtimePlugin");
+  const factory = mod?.default ?? mod;
+  const plugin = typeof factory === "function" ? factory() : null;
+  if (plugin) {
+    instance.registerPlugins([plugin]);
+  }
+  (instance as any).__nodeRuntimePluginLoaded = true;
+}

package/src/near-cli.ts

@@ -0,0 +1,284 @@
+import { spawn } from "node:child_process";
+import { generateKeyPairSync } from "node:crypto";
+import { Effect } from "effect";
+
+export interface NearTransactionConfig {
+  account: string;
+  contract: string;
+  method: string;
+  argsBase64: string;
+  network?: "mainnet" | "testnet";
+  privateKey?: string;
+  gas?: string;
+  deposit?: string;
+}
+
+export interface NearTransactionResult {
+  success: boolean;
+  txHash?: string;
+  error?: string;
+}
+
+export interface NearKeyPair {
+  publicKey: string;
+  privateKey: string;
+}
+
+export interface FunctionCallAccessKeyConfig {
+  account: string;
+  contract: string;
+  allowance: string;
+  functionNames: string[];
+  network?: "mainnet" | "testnet";
+}
+
+const NEAR_CLI_VERSION = "0.23.5";
+const INSTALLER_URL = `https://github.com/near/near-cli-rs/releases/download/v${NEAR_CLI_VERSION}/near-cli-rs-installer.sh`;
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+export class NearCliNotFoundError extends Error {
+  readonly _tag = "NearCliNotFoundError";
+  constructor() {
+    super("NEAR CLI not found");
+  }
+}
+
+export class NearCliInstallError extends Error {
+  readonly _tag = "NearCliInstallError";
+  constructor(message: string) {
+    super(`Failed to install NEAR CLI: ${message}`);
+  }
+}
+
+export class NearTransactionError extends Error {
+  readonly _tag = "NearTransactionError";
+}
+
+function base64UrlToBytes(input: string): Uint8Array {
+  const normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+  return new Uint8Array(Buffer.from(normalized, "base64"));
+}
+
+function base58Encode(input: Uint8Array): string {
+  if (input.length === 0) return "";
+
+  const digits: number[] = [0];
+  for (const byte of input) {
+    let carry = byte;
+    for (let i = 0; i < digits.length; i++) {
+      carry += digits[i]! << 8;
+      digits[i] = carry % 58;
+      carry = Math.floor(carry / 58);
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = Math.floor(carry / 58);
+    }
+  }
+
+  let output = "";
+  for (const byte of input) {
+    if (byte === 0) output += BASE58_ALPHABET[0];
+    else break;
+  }
+
+  for (let i = digits.length - 1; i >= 0; i--) {
+    output += BASE58_ALPHABET[digits[i]!]!;
+  }
+
+  return output;
+}
+
+export function generateNearKeyPair(): NearKeyPair {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+  const publicJwk = publicKey.export({ format: "jwk" }) as JsonWebKey;
+  const privateJwk = privateKey.export({ format: "jwk" }) as JsonWebKey;
+
+  if (!publicJwk.x || !privateJwk.d) {
+    throw new Error("Failed to generate NEAR keypair");
+  }
+
+  const publicBytes = base64UrlToBytes(publicJwk.x);
+  const privateSeed = base64UrlToBytes(privateJwk.d);
+  const secretBytes = new Uint8Array(privateSeed.length + publicBytes.length);
+  secretBytes.set(privateSeed, 0);
+  secretBytes.set(publicBytes, privateSeed.length);
+
+  return {
+    publicKey: `ed25519:${base58Encode(publicBytes)}`,
+    privateKey: `ed25519:${base58Encode(secretBytes)}`,
+  };
+}
+
+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));
+    });
+  },
+  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)));
+    });
+  },
+  catch: (error) => error as 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)));
+  });
+}
+
+export const ensureNearCli = Effect.gen(function* () {
+  const isInstalled = yield* checkNearCliInstalled;
+  if (isInstalled) return;
+
+  if (process.env.BOS_INSTALL_NEAR_CLI === "true") {
+    yield* installNearCli;
+    return;
+  }
+
+  console.log();
+  console.log("  NEAR CLI not found");
+
+  console.log();
+  console.log(`  To install manually: curl --proto '=https' --tlsv1.2 -LsSf ${INSTALLER_URL} | sh`);
+  console.log();
+  yield* Effect.fail(new NearCliNotFoundError());
+});
+
+export const executeTransaction = (
+  config: NearTransactionConfig,
+): Effect.Effect<NearTransactionResult, Error> =>
+  Effect.gen(function* () {
+    const gas = (config.gas || "300Tgas").replace(/\s+/g, "");
+    const deposit = (config.deposit || "0NEAR").replace(/\s+/g, "");
+    const network = config.network || (config.account.endsWith(".testnet") ? "testnet" : "mainnet");
+
+    const args = [
+      "contract",
+      "call-function",
+      "as-transaction",
+      config.contract,
+      config.method,
+      "base64-args",
+      config.argsBase64,
+      "prepaid-gas",
+      gas,
+      "attached-deposit",
+      deposit,
+      "sign-as",
+      config.account,
+      "network-config",
+      network,
+    ];
+
+    if (config.privateKey) {
+      args.push("sign-with-plaintext-private-key", config.privateKey, "send");
+    } else {
+      args.push("sign-with-keychain", "send");
+    }
+
+    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) ||
+              combined.match(/([A-HJ-NP-Za-km-z1-9]{43,44})/);
+            const softSuccess =
+              Boolean(txHashMatch?.[1]) &&
+              /CodeDoesNotExist/i.test(combined) &&
+              /Transaction failed/i.test(combined);
+
+            if (code === 0 || softSuccess) resolve(combined);
+            else reject(new NearTransactionError(stderr || `Transaction failed with code ${code}`));
+          });
+
+          proc.on("error", (err) => reject(new NearTransactionError(err.message)));
+        });
+      },
+      catch: (error) => error as Error,
+    });
+
+    const txHashMatch =
+      output.match(/Transaction ID:\s*([A-Za-z0-9]+)/i) ||
+      output.match(/([A-HJ-NP-Za-km-z1-9]{43,44})/);
+
+    return {
+      success: true,
+      txHash: txHashMatch?.[1] || "unknown",
+    };
+  });
+
+export async function addFunctionCallAccessKey(
+  config: FunctionCallAccessKeyConfig,
+): Promise<NearKeyPair> {
+  const keyPair = generateNearKeyPair();
+  const args = [
+    "account",
+    "add-key",
+    config.account,
+    "grant-function-call-access",
+    "--allowance",
+    config.allowance,
+    "--contract-account-id",
+    config.contract,
+    "--function-names",
+    config.functionNames.join(", "),
+    "use-manually-provided-public-key",
+    keyPair.publicKey,
+    "network-config",
+    config.network || (config.account.endsWith(".testnet") ? "testnet" : "mainnet"),
+    "sign-with-keychain",
+    "send",
+  ];
+
+  await runNearCommand(args);
+  return keyPair;
+}

package/src/network.ts

@@ -0,0 +1,3 @@
+export function getNetworkIdForAccount(account: string): "mainnet" | "testnet" {
+  return account.endsWith(".testnet") ? "testnet" : "mainnet";
+}