@arcote.tech/arc-cli 0.8.1 → 0.8.3

package/src/commands/platform-pairing-token.ts

@@ -0,0 +1,53 @@
+import { randomBytes } from "crypto";
+import { join } from "path";
+import { initContextHandler } from "../platform/server";
+import { err, loadServerContext, resolveWorkspace } from "../platform/shared";
+
+/**
+ * `arc platform pairing-token` — generuje JEDNORAZOWY kod parowania federacji
+ * i zapisuje go do bazy (agregat `pairingCode`), po czym wypisuje go operatorowi.
+ *
+ * Kod podaje się w HOŚCIE przy instalacji aplikacji; host rejestruje nim swój
+ * klucz publiczny (komenda `federationHost.register`), a kod zostaje zużyty.
+ * Uruchamiane po SSH na serwerze aplikacji — czyta ten sam kontekst i DB co
+ * serwer (postgres przez `DATABASE_URL`, inaczej sqlite w `.arc/data`).
+ */
+export async function platformPairingToken(): Promise<void> {
+  const ws = resolveWorkspace();
+  const { context } = await loadServerContext(ws);
+  if (!context) {
+    err("Brak zbudowanego kontekstu. Uruchom najpierw `arc platform build`.");
+    process.exit(1);
+  }
+
+  // TEN SAM plik/baza co serwer platformy (startup.ts): sqlite
+  // `.arc/data/<mode>.db` w dev/prod-sqlite, albo postgres przez DATABASE_URL
+  // (wtedy dbPath jest ignorowany). Bez tego kod trafiłby do innej bazy niż
+  // serwer i rejestracja by go nie znalazła.
+  const isProd = process.env.NODE_ENV === "production";
+  const dbPath = join(ws.rootDir, ".arc", "data", isProd ? "prod.db" : "dev.db");
+  const handler = await initContextHandler(context, dbPath);
+
+  // Kod = sekret pokazywany raz operatorowi. `_id` agregatu generuje handler.
+  const code = randomBytes(24).toString("base64url");
+  const res = (await handler.executeCommand(
+    "pairingCode.issue",
+    { code },
+    null,
+    { internal: true },
+  )) as { ok?: boolean; error?: string } | undefined;
+
+  if (!res?.ok) {
+    err(
+      `Nie udało się zapisać kodu parowania${res?.error ? `: ${res.error}` : ""}. ` +
+        "Czy aplikacja wystawia agregat `pairingCode` (federacja)?",
+    );
+    process.exit(1);
+  }
+
+  process.stdout.write(
+    `\n  Kod parowania (jednorazowy):\n\n    ${code}\n\n` +
+      "  Podaj go w hoście przy instalacji aplikacji. Wygasa po pierwszym użyciu.\n\n",
+  );
+  process.exit(0);
+}

package/src/deploy/caddyfile.ts

@@ -61,6 +61,9 @@ export function generateCaddyfile(cfg: DeployConfig): string {
   for (const [name, env] of Object.entries(cfg.envs)) {
     lines.push(`${env.domain} {${tlsDirective}`);
     lines.push(...logDirective);
+    // Kompresja odpowiedzi (JS/CSS/JSON z hosta idą plaintext — host nie
+    // kompresuje, więc bez tej dyrektywy przeglądarka pobiera pełne bajty).
+    lines.push("    encode zstd gzip");
     if (observability) {
       lines.push("    handle_path /otel/* {");
       lines.push("        reverse_proxy otel-collector:4318");

package/src/index.ts

@@ -6,6 +6,7 @@ import { dev } from "./commands/dev";
 import { platformBuild } from "./commands/platform-build";
 import { platformDeploy } from "./commands/platform-deploy";
 import { platformDev } from "./commands/platform-dev";
+import { platformPairingToken } from "./commands/platform-pairing-token";
 import { platformStart } from "./commands/platform-start";
 
 // Create the program
@@ -51,8 +52,12 @@ platform
   .command("build")
   .description("Build platform for production")
   .option("--no-cache", "Force full rebuild")
-  .action((opts: { cache?: boolean }) =>
-    platformBuild({ noCache: opts.cache === false }),
+  .option(
+    "--stats",
+    "Wypisz rozbicie chunków na biblioteki (per-wejście raw/gzip + najcięższe liby, ext/wewn). Wymusza pełny build.",
+  )
+  .action((opts: { cache?: boolean; stats?: boolean }) =>
+    platformBuild({ noCache: opts.cache === false, stats: opts.stats }),
   );
 
 platform
@@ -60,6 +65,13 @@ platform
   .description("Start platform in production mode (requires prior build)")
   .action(platformStart);
 
+platform
+  .command("pairing-token")
+  .description(
+    "Generate a one-time federation pairing code (writes to DB, prints it)",
+  )
+  .action(platformPairingToken);
+
 platform
   .command("deploy [env]")
   .description(

package/src/platform/server.ts

@@ -573,14 +573,12 @@ function handleDiscovery(
   if (!federation) {
     return new Response("Not Found", { status: 404, headers: ctx.corsHeaders });
   }
-  const presented = req.headers.get("X-Arc-Pairing-Token");
-  if (!presented || !safeEqual(presented, federation.registrationToken)) {
-    return new Response("Unauthorized", {
-      status: 401,
-      headers: ctx.corsHeaders,
-    });
-  }
-
+  // Discovery jest PUBLICZNE (bez bramy tokenem). Zwraca wyłącznie metadane
+  // federacji (slug, moduły, uprawnienia, peers) — a te i tak wskazują na
+  // publiczne chunki `/browser-fed/`. Bramą PAROWANIA jest osobny JEDNORAZOWY
+  // kod sprawdzany przy rejestracji klucza (`federationHost.register`), nie ten
+  // odczyt. Host dzięki temu może pokazać ekran zgody (co instaluje), zanim
+  // operator poda kod.
   const fed = manifest.federation;
   // Adres własny: za proxy `req.url` jest wewnętrzny, więc pozwalamy nadpisać
   // przez env. Konsument i tak zna nas z adresu, którego użył — to pole jest

package/src/platform/shared.ts

@@ -25,7 +25,11 @@ import {
 import { extractAccessMap } from "../builder/access-extractor";
 import { buildPeerShell, type PeerShellResult } from "../builder/peer-shell";
 import type { FederationConfig } from "@arcote.tech/platform";
-import { assertOneModulePerPackage, planChunks } from "../builder/chunk-planner";
+import {
+  assertOneModulePerPackage,
+  packageDeclaresModule,
+  planChunks,
+} from "../builder/chunk-planner";
 import { collectFrameworkDeps } from "../builder/dependency-collector";
 import {
   mtimeOf,
@@ -144,6 +148,11 @@ export function resolveWorkspace(): WorkspaceInfo {
 
 export interface BuildOptions {
   noCache?: boolean;
+  /**
+   * Minifikacja bundli przeglądarki (domyślnie true — build/deploy).
+   * Dev watcher podaje false: czytelny kod w devtools, szybszy rebuild.
+   */
+  minify?: boolean;
 }
 
 /**
@@ -157,6 +166,7 @@ export async function buildAll(
 ): Promise<BuildManifest> {
   const cache = loadBuildCache(ws.arcDir);
   const noCache = opts.noCache ?? false;
+  const minify = opts.minify ?? true;
   const themePath = ws.rootPkg.arc?.theme as string | undefined;
   const federation = getFederationConfig(ws);
 
@@ -201,13 +211,20 @@ export async function buildAll(
   const moduleNameOf = (name: string) => name.split("/").pop() ?? name;
   const exposureOf = (pkgName: string): "local" | "external" | "both" =>
     accessMap.exposure[moduleNameOf(pkgName)]?.exposure ?? "local";
+  // Tylko pakiety DEKLARUJĄCE moduł Arc są członami wchodzącymi do initial/grup.
+  // Czyste biblioteki (np. @ndt/email — szablony maili) NIE mogą być tu, bo
+  // initial robiłoby `import "@pkg"` i przy `sideEffects:true` (patch buildu)
+  // wciągałoby całe ich drzewo zależności do pierwszego wczytania. Taka libka
+  // trafia do bundla NORMALNIE — dopiero gdy realnie zaimportuje ją moduł
+  // (wtedy podlega tree-shakingowi / lazy-split).
+  const modulePackages = ws.packages.filter(packageDeclaresModule);
   // Normalna platforma: moduły local/both (external-only ukryte w macierzystej
   // platformie). Host bierze wszystko (nie ukrywa niczego przed sobą).
   const localPackages = isHost
-    ? ws.packages
-    : ws.packages.filter((p) => exposureOf(p.name) !== "external");
+    ? modulePackages
+    : modulePackages.filter((p) => exposureOf(p.name) !== "external");
   // Build federowany: moduły external/both → browser-fed/.
-  const fedPackages = ws.packages.filter((p) =>
+  const fedPackages = modulePackages.filter((p) =>
     ["external", "both"].includes(exposureOf(p.name)),
   );
   const hasFederatedModules = fedPackages.length > 0;
@@ -238,31 +255,47 @@ export async function buildAll(
   // zawsze external peers) + peer-shell.
   const i18nCollector = new Map<string, Set<string>>();
 
-  const [browserResult, , , , shellResult, fedResult] = await Promise.all([
+  // Dwa buildy przeglądarkowe (bundled + federated) biegną SZEREGOWO, nie w
+  // Promise.all: oba mutują TE SAME package.json (patch sideEffects na czas
+  // builda) — przy równoległym biegu `finally` szybszego builda przywraca
+  // oryginał, zanim wolniejszy skończy bundlować, i tree-shaking wolniejszego
+  // biegnie na złych metadanych. Koszt: +czas builda fed; zysk: deterministyka.
+  const browserSequence = (async () => {
     // HOST buduje się BUNDLED (React inline, eager — bez lazy-race), a initial
     // eksponuje runtime na globalThis; gościa obsłuży peer-shell (globalThis).
-    buildBrowserApp(ws.rootDir, ws.browserDir, plan, cache, noCache, i18nCollector, {
-      federated: false,
-      exposeRuntime: isHost,
-    }),
-    buildStyles(ws.rootDir, ws.arcDir, ws.packages, themePath, cache, noCache),
-    copyBrowserAssets(ws, cache, noCache),
-    buildTranslations(ws.rootDir, ws.arcDir, cache, noCache),
-    needsPeerShell
-      ? buildPeerShell(ws.rootDir, join(ws.arcDir, "shell"), cache, noCache)
-      : Promise.resolve(undefined),
-    fedPlan
-      ? buildBrowserApp(
+    const bundled = await buildBrowserApp(
+      ws.rootDir,
+      ws.browserDir,
+      plan,
+      cache,
+      noCache,
+      i18nCollector,
+      { federated: false, exposeRuntime: isHost, minify },
+    );
+    const fed = fedPlan
+      ? await buildBrowserApp(
           ws.rootDir,
           join(ws.arcDir, "browser-fed"),
           fedPlan,
           cache,
           noCache,
           i18nCollector,
-          { federated: true, unitId: "browser-app-fed" },
+          { federated: true, unitId: "browser-app-fed", minify },
         )
-      : Promise.resolve(undefined),
-  ]);
+      : undefined;
+    return { bundled, fed };
+  })();
+
+  const [{ bundled: browserResult, fed: fedResult }, , , , shellResult] =
+    await Promise.all([
+      browserSequence,
+      buildStyles(ws.rootDir, ws.arcDir, ws.packages, themePath, cache, noCache),
+      copyBrowserAssets(ws, cache, noCache),
+      buildTranslations(ws.rootDir, ws.arcDir, cache, noCache),
+      needsPeerShell
+        ? buildPeerShell(ws.rootDir, join(ws.arcDir, "shell"), cache, noCache)
+        : Promise.resolve(undefined),
+    ]);
 
   // Finalize i18n catalogs once after all chunks + initial bundle collected.
   const { finalizeTranslations } = await import("../i18n");
@@ -493,7 +526,18 @@ async function copyBrowserAssets(
 
 export async function loadServerContext(
   ws: WorkspaceInfo,
-): Promise<{ context: any | null; moduleAccess: Map<string, any> }> {
+): Promise<{
+  context: any | null;
+  moduleAccess: Map<string, any>;
+  /**
+   * Set gdy import bundla serwerowego RZUCIŁ (np. fail-fast na brakującym env).
+   * Kontekst jest wtedy CZĘŚCIOWY — część modułów się nie zarejestrowała, więc
+   * ich query rzucają `Element not found`. Caller uruchamiający serwer MUSI to
+   * potraktować jako twardy błąd startu (patrz startup.ts), inaczej aplikacja
+   * wstaje połowiczna i cicho. Build/access-extractor może to zignorować.
+   */
+  serverError?: unknown;
+}> {
   // Set globals for server context — framework packages (arc-auth etc.)
   // use these at runtime to tree-shake browser/server code paths.
   (globalThis as any).ONLY_SERVER = true;
@@ -519,15 +563,18 @@ export async function loadServerContext(
     // No build yet (or a static-only workspace) — nothing to register.
     return { context: null, moduleAccess: new Map() };
   }
+  let serverError: unknown;
   try {
     await import(serverEntry);
   } catch (e) {
     err(`Failed to load server bundle ${SERVER_ENTRY_FILE}: ${e}`);
+    serverError = e;
   }
 
   const { getContext, getAllModuleAccess } = await import(platformEntry);
   return {
     context: getContext() ?? null,
     moduleAccess: getAllModuleAccess(),
+    serverError,
   };
 }

package/src/platform/startup.ts

@@ -60,7 +60,7 @@ export async function startPlatform(
   // missing manifest is a hard error.
   let manifest: BuildManifest;
   if (devMode) {
-    manifest = await buildAll(ws);
+    manifest = await buildAll(ws, { minify: false });
   } else {
     const manifestPath = join(ws.arcDir, "manifest.json");
     if (!existsSync(manifestPath)) {
@@ -88,7 +88,21 @@ export async function startPlatform(
   // imports the combined server bundle at .arc/platform/server/_server.js
   // (produced by the buildServerApp step in buildAll).
   log("Loading server context...");
-  const { context, moduleAccess } = await loadServerContext(ws);
+  const { context, moduleAccess, serverError } = await loadServerContext(ws);
+  // TWARDY STOP: import bundla serwerowego rzucił (np. fail-fast na brakującym
+  // env). Kontekst jest wtedy CZĘŚCIOWY — część agregatów się nie
+  // zarejestrowała, więc ich query rzucałyby `Element not found`, a aplikacja
+  // wyglądałaby na działającą (login OK), tyle że połowiczną. Przerywamy start
+  // GŁOŚNO, zamiast wstawać po cichu — to była realna produkcyjna pułapka.
+  if (serverError) {
+    err(
+      "Serwer NIE wstanie: moduł serwerowy nie załadował się (błąd wyżej). " +
+        "Częściowy kontekst = połowiczna aplikacja (query rzucają " +
+        "'Element not found'). Napraw przyczynę (np. brakujące zmienne " +
+        "środowiskowe) i wystartuj ponownie.",
+    );
+    process.exit(1);
+  }
   if (context) {
     ok("Context loaded");
   } else {
@@ -232,37 +246,33 @@ async function startMapTool(
 }
 
 /**
- * PROD + federacja → sekrety MUSZĄ pochodzić z env. Twarda odmowa startu.
+ * PROD + federacja → token parowania MUSI pochodzić z env. Twarda odmowa startu.
  *
  * DLACZEGO tak ostro: `.arc/` nie trafia ani do obrazu (deploy kopiuje tylko
- * `.arc/platform/`), ani na wolumen (montowane jest tylko `.arc/data`). Plik
+ * `.arc/platform/`), ani na wolumen (montowane jest tylko `.arc/data`). Token
  * wygenerowany wewnątrz kontenera przeżywa `restart`, ale **ginie przy pierwszym
- * `recreate`** (nowy obraz = nowy kontener). Wtedy:
- *   - nowy `ARC_APP_SECRET` → hosty trzymają STARY sekret, więc żadna asercja
- *     tożsamości się nie zweryfikuje i aplikacja przestaje działać u wszystkich,
- *     bez jednego błędu przy starcie,
- *   - nowy token parowania → istniejące parowania martwe.
+ * `recreate`** — a wtedy nowy token parowania unieważnia istniejące parowania,
+ * bez żadnego błędu przy starcie. Cicha awaria dzień po deployu jest gorsza niż
+ * głośna odmowa startu.
  *
- * Cicha awaria dzień po deployu jest dużo gorsza niż głośna odmowa startu.
- * Wymieniamy WSZYSTKIE braki naraz — inaczej operator poprawia po jednej na deploy.
+ * `ARC_APP_SECRET` NIE jest już wymagany: tożsamość federacji jest asymetryczna
+ * (host podpisuje kluczem prywatnym, partner weryfikuje publicznym z rejestru w
+ * bazie — patrz app-identity.md), więc partner nie trzyma współdzielonego
+ * sekretu HMAC. Klucze publiczne żyją w projekcji (wolumen `.arc/data`), nie w
+ * ulotnym pliku.
  */
 function assertProdFederationSecrets(
   devMode: boolean,
   hasFederation: boolean,
 ): void {
   if (devMode || !hasFederation) return;
-  const missing: string[] = [];
-  if (!process.env.ARC_APP_SECRET) missing.push("ARC_APP_SECRET");
-  if (!process.env.ARC_PAIRING_TOKEN && !process.env.ARC_MAP_TOKEN) {
-    missing.push("ARC_PAIRING_TOKEN");
-  }
-  if (missing.length === 0) return;
+  if (process.env.ARC_PAIRING_TOKEN || process.env.ARC_MAP_TOKEN) return;
 
   err(
-    `Federacja w produkcji wymaga zmiennych środowiskowych: ${missing.join(", ")}.\n` +
-      `  Bez nich sekret i token są generowane w kontenerze i GINĄ przy pierwszym\n` +
-      `  recreate — hosty musiałyby przeinstalować aplikację, bez żadnego błędu.\n` +
-      `  Ustaw je w deployu (deploy.arc.json → envVars + deploy.arc.<env>.env).`,
+    `Federacja w produkcji wymaga zmiennej środowiskowej ARC_PAIRING_TOKEN.\n` +
+      `  Bez niej token parowania jest generowany w kontenerze i GINIE przy\n` +
+      `  pierwszym recreate — parowania hostów stają się martwe, bez błędu.\n` +
+      `  Ustaw ją w deployu (deploy.arc.json → envVars + deploy.arc.<env>.env).`,
   );
   process.exit(1);
 }
@@ -385,7 +395,7 @@ function attachDevWatcher(
       isRebuilding = true;
       log("Rebuilding...");
       try {
-        const next = await buildAll(ws);
+        const next = await buildAll(ws, { minify: false });
         platform.setManifest(next);
         platform.notifyReload(next);
         onReload?.();