everything-dev 1.27.0 → 1.28.0

package/src/dev-session.ts

@@ -1,283 +0,0 @@
-import * as NodeContext from "@effect/platform-node/NodeContext";
-import { Deferred, Effect, Exit } from "effect";
-import {
-  type DevViewHandle,
-  type LogEntry,
-  type ProcessState,
-  renderDevView,
-} from "./components/dev-view";
-import { renderStreamingView } from "./components/streaming-view";
-import { getProjectRoot } from "./config";
-import { createDevLogger } from "./dev-logs";
-import {
-  getProcessStates,
-  makeDevProcess,
-  type ProcessCallbacks,
-  type ProcessHandle,
-} from "./orchestrator";
-import {
-  type AppOrchestrator,
-  DevRuntimeConfigLive,
-  type ServiceDescriptor,
-  ServiceDescriptorMap,
-  ServiceDescriptorMapLive,
-} from "./service-descriptor";
-import type { RuntimeConfig } from "./types";
-
-const LOG_NOISE_PATTERNS = [
-  /\[ Federation Runtime \] Version .* from (host|ui) of shared singleton module/,
-  /Executing an Effect versioned \d+\.\d+\.\d+ with a Runtime of version/,
-  /you may want to dedupe the effect dependencies/,
-];
-
-const SSR_LOG_ALLOWLIST = [
-  /\bready\s+built in\b/i,
-  /\bcompiled\b.*successfully/i,
-  /\berror\b/i,
-  /\bfailed\b/i,
-  /\bexception\b/i,
-];
-
-const shouldDisplayLog = (source: string, line: string, isError?: boolean): boolean => {
-  if (process.env.DEBUG === "true" || process.env.DEBUG === "1") return true;
-  if (source === "ui-ssr") {
-    if (isError) return true;
-    return SSR_LOG_ALLOWLIST.some((pattern) => pattern.test(line));
-  }
-  return !LOG_NOISE_PATTERNS.some((pattern) => pattern.test(line));
-};
-
-const isInteractiveSupported = (): boolean => {
-  return process.stdin.isTTY === true && process.stdout.isTTY === true;
-};
-
-const STARTUP_ORDER = ["ui-ssr", "ui", "auth", "api", "plugin", "host-build", "host"];
-
-const sortByOrder = (packages: string[]): string[] => {
-  return [...packages].sort((a, b) => {
-    const aIdx = a.startsWith("plugin:")
-      ? STARTUP_ORDER.indexOf("plugin")
-      : STARTUP_ORDER.indexOf(a);
-    const bIdx = b.startsWith("plugin:")
-      ? STARTUP_ORDER.indexOf("plugin")
-      : STARTUP_ORDER.indexOf(b);
-    if (aIdx === -1 && bIdx === -1) return 0;
-    if (aIdx === -1) return 1;
-    if (bIdx === -1) return -1;
-    return aIdx - bIdx;
-  });
-};
-
-function formatLogLine(entry: LogEntry): string {
-  const ts = new Date(entry.timestamp).toISOString();
-  const prefix = entry.isError ? "ERR" : "OUT";
-  return `[${ts}] [${entry.source}] [${prefix}] ${entry.line}`;
-}
-
-export const runDevSession = (
-  orchestrator: AppOrchestrator,
-  onShutdownReady?: (requestShutdown: () => void) => void,
-) =>
-  Effect.gen(function* () {
-    const configDir = getProjectRoot();
-    const services = yield* ServiceDescriptorMap;
-    const orderedPackages = sortByOrder(orchestrator.packages);
-    const initialProcesses: ProcessState[] = getProcessStates(
-      orderedPackages,
-      services,
-      orchestrator.port,
-    );
-
-    const logger = yield* Effect.promise(() =>
-      createDevLogger(configDir, orchestrator.description),
-    );
-
-    const shutdown = yield* Deferred.make<void>();
-
-    onShutdownReady?.(() => {
-      void Effect.runPromise(Deferred.succeed(shutdown, undefined));
-    });
-
-    const allLogs: LogEntry[] = [];
-    let view: DevViewHandle | null = null;
-    let shouldExportLogs = false;
-
-    const requestShutdownAndExport = () => {
-      shouldExportLogs = true;
-      void Effect.runPromise(Deferred.succeed(shutdown, undefined));
-    };
-
-    const useInteractive = orchestrator.interactive ?? isInteractiveSupported();
-    view = useInteractive
-      ? renderDevView(
-          initialProcesses,
-          orchestrator.description,
-          orchestrator.env,
-          () => void Effect.runPromise(Deferred.succeed(shutdown, undefined)),
-          requestShutdownAndExport,
-        )
-      : renderStreamingView(
-          initialProcesses,
-          orchestrator.description,
-          orchestrator.env,
-          () => void Effect.runPromise(Deferred.succeed(shutdown, undefined)),
-        );
-
-    const callbacks: ProcessCallbacks = {
-      onStatus: (name, status, message) => {
-        view?.updateProcess(name, status, message);
-      },
-      onLog: (name, line, isError) => {
-        const entry: LogEntry = {
-          id: `${Date.now()}-${allLogs.length + 1}`,
-          source: name,
-          line,
-          timestamp: Date.now(),
-          isError,
-        };
-        allLogs.push(entry);
-        if (shouldDisplayLog(name, line, isError)) {
-          view?.addLog(name, line, isError);
-        }
-        if (!orchestrator.noLogs) {
-          void logger.write(entry);
-        }
-      },
-    };
-
-    const startProcess = (pkg: string) => {
-      const portOverride = pkg === "host" ? orchestrator.port : undefined;
-      return makeDevProcess(pkg, callbacks, portOverride).pipe(
-        Effect.tapError((err) =>
-          Effect.sync(() => {
-            callbacks.onLog(pkg, `Failed to start: ${err}`, true);
-            callbacks.onStatus(pkg, "error");
-          }),
-        ),
-        Effect.catchAll(() =>
-          Effect.succeed({
-            name: pkg,
-            pid: undefined,
-            kill: Effect.void,
-            waitForReady: Effect.void,
-            waitForExit: Effect.never,
-          } satisfies ProcessHandle),
-        ),
-      );
-    };
-
-    const startGroup = (packages: string[]) =>
-      Effect.forEach(packages, startProcess, { concurrency: "unbounded" });
-
-    const awaitReady = (_pkg: string, handle: ProcessHandle) =>
-      handle.waitForReady.pipe(Effect.catchAll(() => Effect.void));
-
-    const nonHostPackages = orderedPackages.filter((pkg) => pkg !== "host");
-    const hostPackages = orderedPackages.filter((pkg) => pkg === "host");
-
-    const nonHostHandles = yield* startGroup(nonHostPackages);
-
-    yield* Effect.forEach(
-      nonHostHandles.map((handle, index) => ({
-        handle,
-        pkg: nonHostPackages[index] ?? handle.name,
-      })),
-      ({ handle, pkg }) => awaitReady(pkg, handle),
-      { concurrency: "unbounded" },
-    );
-
-    const hostHandles = yield* startGroup(hostPackages);
-
-    yield* Effect.forEach(
-      hostHandles.map((handle, index) => ({ handle, pkg: hostPackages[index] ?? handle.name })),
-      ({ handle, pkg }) => awaitReady(pkg, handle),
-      { concurrency: "unbounded" },
-    );
-
-    const allHandles = [...nonHostHandles, ...hostHandles];
-
-    yield* Effect.addFinalizer(() =>
-      Effect.gen(function* () {
-        yield* Effect.forEach(allHandles, (h) => h.kill.pipe(Effect.ignore), {
-          concurrency: "unbounded",
-        });
-
-        yield* Effect.sleep("200 millis");
-
-        view?.unmount();
-
-        if (shouldExportLogs) {
-          console.log("\n");
-          console.log("═".repeat(70));
-          console.log(`  SESSION LOGS: ${orchestrator.description}`);
-          console.log(`  Started: ${new Date(allLogs[0]?.timestamp || Date.now()).toISOString()}`);
-          console.log(`  Total entries: ${allLogs.length}`);
-          console.log("═".repeat(70));
-          console.log("");
-          for (const entry of allLogs) {
-            console.log(formatLogLine(entry));
-          }
-          console.log("");
-          console.log("═".repeat(70));
-          console.log(`  Full logs saved to: ${logger.logFile}`);
-          console.log("═".repeat(70));
-          console.log("");
-        }
-      }),
-    );
-
-    yield* Deferred.await(shutdown);
-  });
-
-const runApp = (
-  orchestrator: AppOrchestrator,
-  services: Map<string, ServiceDescriptor>,
-  runtimeConfig: RuntimeConfig,
-) => {
-  let requestShutdown: (() => void) | null = null;
-  let signalCount = 0;
-  let forceExitTimer: ReturnType<typeof setTimeout> | null = null;
-
-  const forceExit = () => {
-    console.log("\n[Dev] Force exit");
-    process.exit(0);
-  };
-
-  const program = Effect.scoped(
-    runDevSession(orchestrator, (shutdown) => {
-      requestShutdown = shutdown;
-    }),
-  ).pipe(
-    Effect.provide(ServiceDescriptorMapLive(services)),
-    Effect.provide(DevRuntimeConfigLive(runtimeConfig)),
-    Effect.provide(NodeContext.layer),
-    Effect.catchAllDefect((defect) =>
-      Effect.sync(() => {
-        console.error("[Dev] Unhandled defect in orchestrator:", defect);
-      }),
-    ),
-  );
-
-  const handleSignal = () => {
-    signalCount++;
-    if (signalCount > 1) {
-      forceExit();
-      return;
-    }
-    console.log("\n[Dev] Shutting down...");
-    forceExitTimer = setTimeout(forceExit, 5000);
-    requestShutdown?.();
-  };
-
-  process.on("SIGINT", handleSignal);
-  process.on("SIGTERM", handleSignal);
-
-  Effect.runPromiseExit(program).then((exit) => {
-    if (forceExitTimer) clearTimeout(forceExitTimer);
-    process.exit(Exit.isSuccess(exit) ? 0 : 0);
-  });
-};
-
-export const devApp = runApp;
-
-export const startApp = runApp;

package/src/fastkv.ts

@@ -1,181 +0,0 @@
-export type NetworkId = "mainnet" | "testnet";
-
-interface FastKvEntry {
-  value: unknown;
-}
-
-interface FastKvListResponse {
-  entries?: Array<FastKvEntry | null>;
-}
-
-const FASTKV_TIMEOUT_MS = 10_000;
-
-function getNetworkIdForAccount(accountId: string): NetworkId {
-  return accountId.endsWith(".testnet") ? "testnet" : "mainnet";
-}
-
-export function getFastKvBaseUrlForNetwork(network: NetworkId): string {
-  return network === "testnet"
-    ? process.env.REGISTRY_FASTKV_TESTNET_URL || "https://kv.test.fastnear.com"
-    : process.env.REGISTRY_FASTKV_MAINNET_URL || "https://kv.main.fastnear.com";
-}
-
-function getFastKvBaseUrlForAccount(accountId: string): string {
-  return getNetworkIdForAccount(accountId) === "testnet"
-    ? getFastKvBaseUrlForNetwork("testnet")
-    : getFastKvBaseUrlForNetwork("mainnet");
-}
-
-export function buildRegistryConfigUrl(accountId: string, gatewayId: string): string {
-  const baseUrl = getFastKvBaseUrlForAccount(accountId);
-  const namespace = getRegistryNamespaceForAccount(accountId);
-  const key = encodeURIComponent(getRegistryConfigKey(accountId, gatewayId));
-  return `${baseUrl}/v0/latest/${encodeURIComponent(namespace)}/${encodeURIComponent(accountId)}/${key}`;
-}
-
-export function buildRegistryConfigUrlForNetwork(
-  network: NetworkId,
-  accountId: string,
-  gatewayId: string,
-): string {
-  const baseUrl = getFastKvBaseUrlForNetwork(network);
-  const namespace = getRegistryNamespaceForNetwork(network);
-  const key = encodeURIComponent(getRegistryConfigKey(accountId, gatewayId));
-  return `${baseUrl}/v0/latest/${encodeURIComponent(namespace)}/${encodeURIComponent(accountId)}/${key}`;
-}
-
-export function getRegistryNamespaceForAccount(accountId: string): string {
-  return accountId.endsWith(".testnet")
-    ? process.env.REGISTRY_FASTKV_TESTNET_NAMESPACE || "dev.everything.near"
-    : process.env.REGISTRY_FASTKV_MAINNET_NAMESPACE || "dev.everything.near";
-}
-
-export function getRegistryNamespaceForNetwork(network: NetworkId): string {
-  return network === "testnet"
-    ? process.env.REGISTRY_FASTKV_TESTNET_NAMESPACE || "dev.everything.near"
-    : process.env.REGISTRY_FASTKV_MAINNET_NAMESPACE || "dev.everything.near";
-}
-
-function getRegistryConfigKey(
-  accountId: string,
-  gatewayId: string,
-  pathSegments: string[] = [],
-): string {
-  const suffix =
-    pathSegments.length > 0
-      ? `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`
-      : "";
-  return `apps/${accountId}/${gatewayId}${suffix}/bos.config.json`;
-}
-
-function parseBosUrl(bosUrl: string): {
-  accountId: string;
-  gatewayId: string;
-  pathSegments: string[];
-} {
-  const match = bosUrl.match(/^bos:\/\/([^/]+)\/(.+)$/);
-  if (!match?.[1] || !match[2]) {
-    throw new Error(`Invalid BOS URL: ${bosUrl}`);
-  }
-
-  const pathSegments = match[2]
-    .split("/")
-    .filter(Boolean)
-    .map((segment) => decodeURIComponent(segment));
-  if (pathSegments.length === 0) {
-    throw new Error(`Invalid BOS URL: ${bosUrl}`);
-  }
-
-  const [gatewayId, ...pathSegmentsTail] = pathSegments;
-  if (!gatewayId) {
-    throw new Error(`Invalid BOS URL: ${bosUrl}`);
-  }
-
-  return {
-    accountId: match[1],
-    gatewayId,
-    pathSegments: pathSegmentsTail,
-  };
-}
-
-export async function fetchBosConfigFromFastKv<T>(bosUrl: string): Promise<T> {
-  const { accountId, gatewayId, pathSegments } = parseBosUrl(bosUrl);
-  const payload = await fetchJson<FastKvListResponse>(
-    `${getFastKvBaseUrlForAccount(accountId)}/v0/latest/${encodeURIComponent(getRegistryNamespaceForAccount(accountId))}/${encodeURIComponent(accountId)}`,
-    {
-      method: "POST",
-      body: JSON.stringify({
-        key: getRegistryConfigKey(accountId, gatewayId, pathSegments),
-        limit: 1,
-      }),
-    },
-  );
-  const value = payload?.entries?.find(Boolean)?.value;
-
-  if (!value) {
-    throw new Error(`No config found for ${bosUrl}`);
-  }
-
-  if (typeof value === "string") {
-    return JSON.parse(value) as T;
-  }
-
-  if (typeof value !== "object") {
-    throw new Error(`Invalid config value for ${bosUrl}`);
-  }
-
-  return value as T;
-}
-
-export interface PluginManifest {
-  schemaVersion: number;
-  kind: string;
-  plugin: { name: string; version: string };
-  runtime: { remoteEntry: string };
-  contract: {
-    kind: string;
-    types: { path: string; exportName: string; typeName: string; sha256: string };
-  };
-  additionalExports?: Array<{ path: string; exports: string[]; sha256: string }>;
-}
-
-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`, {
-      signal: controller.signal,
-    });
-    clearTimeout(timeout);
-    if (!response.ok) return null;
-    return (await response.json()) as PluginManifest;
-  } catch {
-    return null;
-  }
-}
-
-async function fetchJson<T>(url: string, init?: RequestInit): Promise<T | null> {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), FASTKV_TIMEOUT_MS);
-
-  try {
-    const response = await fetch(url, {
-      ...init,
-      headers: {
-        accept: "application/json",
-        "content-type": "application/json",
-        ...(init?.headers ?? {}),
-      },
-      signal: controller.signal,
-    });
-
-    if (!response.ok) {
-      return null;
-    }
-
-    return (await response.json()) as T;
-  } finally {
-    clearTimeout(timeout);
-  }
-}

package/src/index.ts

@@ -1,8 +0,0 @@
-export * from "./config";
-export * from "./contract";
-export * from "./contract.meta";
-export * from "./fastkv";
-export * from "./plugin";
-export * from "./sdk";
-export * from "./sidebar";
-export * from "./types";

package/src/integrity.ts

@@ -1,138 +0,0 @@
-import { createHash } from "node:crypto";
-import { fetchBosConfigFromFastKv } from "./fastkv";
-
-export function computeSriHash(content: string | Buffer): string {
-  return `sha384-${createHash("sha384").update(content).digest("base64")}`;
-}
-
-export async function computeSriHashForUrl(url: string): Promise<string | null> {
-  try {
-    const entryUrl = resolveEntryUrl(url);
-
-    const response = await fetch(entryUrl);
-    if (!response.ok) {
-      console.warn(`[SRI] Failed to fetch ${entryUrl}: ${response.status} ${response.statusText}`);
-      return null;
-    }
-    const buffer = Buffer.from(await response.arrayBuffer());
-    return computeSriHash(buffer);
-  } catch (error) {
-    console.warn(
-      `[SRI] Error computing integrity for ${url}:`,
-      error instanceof Error ? error.message : error,
-    );
-    return null;
-  }
-}
-
-export function resolveEntryUrl(url: string): string {
-  if (url.endsWith("/remoteEntry.js")) return url;
-  if (url.endsWith("/mf-manifest.json"))
-    return `${url.replace(/\/mf-manifest\.json$/, "")}/remoteEntry.js`;
-  return `${url.replace(/\/$/, "")}/remoteEntry.js`;
-}
-
-export async function verifySriForUrl(url: string, expectedIntegrity: string): Promise<void> {
-  const entryUrl = resolveEntryUrl(url);
-
-  const response = await fetch(entryUrl);
-  if (!response.ok) {
-    console.warn(`[SRI] Failed to fetch ${entryUrl} for verification: ${response.status}`);
-    return;
-  }
-
-  const buffer = Buffer.from(await response.arrayBuffer());
-  const computed = computeSriHash(buffer);
-
-  if (computed !== expectedIntegrity) {
-    throw new Error(
-      `[SRI] Integrity check failed for ${entryUrl}\n  Expected: ${expectedIntegrity}\n  Computed: ${computed}`,
-    );
-  }
-}
-
-export class IntegrityRegistry {
-  private hashes = new Map<string, string>();
-
-  register(url: string, integrity: string): void {
-    this.hashes.set(url, integrity);
-  }
-
-  registerEntry(baseUrl: string, integrity: string): void {
-    this.hashes.set(resolveEntryUrl(baseUrl), integrity);
-  }
-
-  get(url: string): string | undefined {
-    return this.hashes.get(url);
-  }
-
-  has(url: string): boolean {
-    return this.hashes.has(url);
-  }
-
-  entries(): IterableIterator<[string, string]> {
-    return this.hashes.entries();
-  }
-}
-
-function extractIntegrityHashes(config: Record<string, unknown>): Map<string, string> {
-  const hashes = new Map<string, string>();
-  const app = config.app as Record<string, Record<string, unknown>> | undefined;
-  const plugins = config.plugins as Record<string, Record<string, unknown>> | undefined;
-
-  if (app) {
-    for (const [, entry] of Object.entries(app)) {
-      if (entry?.integrity && entry?.production) {
-        hashes.set(resolveEntryUrl(entry.production as string), entry.integrity as string);
-      }
-    }
-  }
-
-  if (plugins) {
-    for (const [, entry] of Object.entries(plugins)) {
-      if (entry?.integrity && entry?.production) {
-        hashes.set(resolveEntryUrl(entry.production as string), entry.integrity as string);
-      }
-    }
-  }
-
-  return hashes;
-}
-
-export async function verifyConfigAgainstChain(
-  localConfig: Record<string, unknown>,
-  bosUrl: string,
-): Promise<{ verified: boolean; mismatches: string[] }> {
-  const mismatches: string[] = [];
-
-  let chainConfig: Record<string, unknown>;
-  try {
-    chainConfig = await fetchBosConfigFromFastKv<Record<string, unknown>>(bosUrl);
-  } catch (error) {
-    console.warn(
-      `[Attestation] Failed to fetch on-chain config: ${error instanceof Error ? error.message : String(error)}`,
-    );
-    return { verified: false, mismatches: ["chain-fetch-failed"] };
-  }
-
-  const localHashes = extractIntegrityHashes(localConfig);
-  const chainHashes = extractIntegrityHashes(chainConfig);
-
-  for (const [url, chainHash] of chainHashes) {
-    const localHash = localHashes.get(url);
-    if (localHash && localHash !== chainHash) {
-      mismatches.push(url);
-      console.error(
-        `[Attestation] Integrity mismatch for ${url}\n  Local: ${localHash}\n  Chain: ${chainHash}`,
-      );
-    }
-  }
-
-  if (mismatches.length === 0 && localHashes.size > 0) {
-    console.log(
-      `[Attestation] Local config verified against on-chain anchor (${localHashes.size} entries checked)`,
-    );
-  }
-
-  return { verified: mismatches.length === 0, mismatches };
-}