@arcote.tech/arc-cli 0.8.0 → 0.8.2

package/dist/index.js

@@ -10204,11 +10204,18 @@ function notifyTokenChange(scope) {
 
 class AuthAdapter {
   scopes = new Map;
+  namespace;
+  constructor(options) {
+    this.namespace = options?.storageNamespace || undefined;
+  }
+  storageKey(scope) {
+    return this.namespace ? `${TOKEN_PREFIX}${this.namespace}:${scope}` : TOKEN_PREFIX + scope;
+  }
   setToken(token, scope = "default") {
     if (!token) {
       this.scopes.delete(scope);
       if (hasLocalStorage()) {
-        localStorage.removeItem(TOKEN_PREFIX + scope);
+        localStorage.removeItem(this.storageKey(scope));
         notifyTokenChange(scope);
       }
       return;
@@ -10218,7 +10225,7 @@ class AuthAdapter {
       if (parts.length !== 3) {
         this.scopes.delete(scope);
         if (hasLocalStorage())
-          localStorage.removeItem(TOKEN_PREFIX + scope);
+          localStorage.removeItem(this.storageKey(scope));
         return;
       }
       const payload = JSON.parse(atob(parts[1]));
@@ -10232,13 +10239,13 @@ class AuthAdapter {
         }
       });
       if (hasLocalStorage()) {
-        localStorage.setItem(TOKEN_PREFIX + scope, token);
+        localStorage.setItem(this.storageKey(scope), token);
         notifyTokenChange(scope);
       }
     } catch {
       this.scopes.delete(scope);
       if (hasLocalStorage())
-        localStorage.removeItem(TOKEN_PREFIX + scope);
+        localStorage.removeItem(this.storageKey(scope));
     }
   }
   setDecoded(decoded, scope = "default") {
@@ -10247,10 +10254,13 @@ class AuthAdapter {
   loadPersisted() {
     if (!hasLocalStorage())
       return;
+    const prefix = this.namespace ? `${TOKEN_PREFIX}${this.namespace}:` : TOKEN_PREFIX;
     for (let i = 0;i < localStorage.length; i++) {
       const key = localStorage.key(i);
-      if (key?.startsWith(TOKEN_PREFIX)) {
-        const scope = key.slice(TOKEN_PREFIX.length);
+      if (key?.startsWith(prefix)) {
+        const scope = key.slice(prefix.length);
+        if (!this.namespace && scope.includes(":"))
+          continue;
         const raw = localStorage.getItem(key);
         if (raw) {
           try {
@@ -10304,7 +10314,7 @@ class AuthAdapter {
   clear() {
     if (hasLocalStorage()) {
       for (const scope of this.scopes.keys()) {
-        localStorage.removeItem(TOKEN_PREFIX + scope);
+        localStorage.removeItem(this.storageKey(scope));
       }
     }
     this.scopes.clear();
@@ -11393,6 +11403,8 @@ class ArcFunction {
       if (!tokenInstance) {
         return false;
       }
+      if (!protection.check)
+        continue;
       const result = await protection.check(tokenInstance);
       if (result === false) {
         return false;
@@ -17839,11 +17851,18 @@ function notifyTokenChange2(scope) {
 
 class AuthAdapter2 {
   scopes = new Map;
+  namespace;
+  constructor(options) {
+    this.namespace = options?.storageNamespace || undefined;
+  }
+  storageKey(scope) {
+    return this.namespace ? `${TOKEN_PREFIX2}${this.namespace}:${scope}` : TOKEN_PREFIX2 + scope;
+  }
   setToken(token, scope = "default") {
     if (!token) {
       this.scopes.delete(scope);
       if (hasLocalStorage2()) {
-        localStorage.removeItem(TOKEN_PREFIX2 + scope);
+        localStorage.removeItem(this.storageKey(scope));
         notifyTokenChange2(scope);
       }
       return;
@@ -17853,7 +17872,7 @@ class AuthAdapter2 {
       if (parts.length !== 3) {
         this.scopes.delete(scope);
         if (hasLocalStorage2())
-          localStorage.removeItem(TOKEN_PREFIX2 + scope);
+          localStorage.removeItem(this.storageKey(scope));
         return;
       }
       const payload = JSON.parse(atob(parts[1]));
@@ -17867,13 +17886,13 @@ class AuthAdapter2 {
         }
       });
       if (hasLocalStorage2()) {
-        localStorage.setItem(TOKEN_PREFIX2 + scope, token);
+        localStorage.setItem(this.storageKey(scope), token);
         notifyTokenChange2(scope);
       }
     } catch {
       this.scopes.delete(scope);
       if (hasLocalStorage2())
-        localStorage.removeItem(TOKEN_PREFIX2 + scope);
+        localStorage.removeItem(this.storageKey(scope));
     }
   }
   setDecoded(decoded, scope = "default") {
@@ -17882,10 +17901,13 @@ class AuthAdapter2 {
   loadPersisted() {
     if (!hasLocalStorage2())
       return;
+    const prefix = this.namespace ? `${TOKEN_PREFIX2}${this.namespace}:` : TOKEN_PREFIX2;
     for (let i = 0;i < localStorage.length; i++) {
       const key = localStorage.key(i);
-      if (key?.startsWith(TOKEN_PREFIX2)) {
-        const scope = key.slice(TOKEN_PREFIX2.length);
+      if (key?.startsWith(prefix)) {
+        const scope = key.slice(prefix.length);
+        if (!this.namespace && scope.includes(":"))
+          continue;
         const raw = localStorage.getItem(key);
         if (raw) {
           try {
@@ -17939,7 +17961,7 @@ class AuthAdapter2 {
   clear() {
     if (hasLocalStorage2()) {
       for (const scope of this.scopes.keys()) {
-        localStorage.removeItem(TOKEN_PREFIX2 + scope);
+        localStorage.removeItem(this.storageKey(scope));
       }
     }
     this.scopes.clear();
@@ -19028,6 +19050,8 @@ class ArcFunction2 {
       if (!tokenInstance) {
         return false;
       }
+      if (!protection.check)
+        continue;
       const result = await protection.check(tokenInstance);
       if (result === false) {
         return false;
@@ -36633,6 +36657,7 @@ async function platformDeploy(envArg, options = {}) {
       ensurePersistedSecret(ws.rootDir, name, "ARC_APP_SECRET", () => randomBytes(32).toString("base64url"));
       ensurePersistedSecret(ws.rootDir, name, "ARC_PAIRING_TOKEN", () => randomBytes(16).toString("base64url"));
     }
+    cfg = loadDeployConfig(ws.rootDir);
   }
   if (cfg.observability?.enabled) {
     const key = cfg.observability.adminPasswordEnv ?? "ARC_OBSERVABILITY_PASSWORD";
@@ -38241,6 +38266,14 @@ async function createArcServer(config) {
         if (contentLength > maxRequestBodySize) {
           return Response.json({ error: "Payload too large" }, { status: 413, headers: corsHeaders2 });
         }
+        if (url.pathname === "/ws" && req.headers.get("Upgrade") === "websocket") {
+          if (server2.upgrade(req, { data: { clientId: "" } }))
+            return;
+          return new Response("WebSocket upgrade failed", {
+            status: 500,
+            headers: corsHeaders2
+          });
+        }
         const authHeader = req.headers.get("Authorization");
         let rawToken = authHeader?.replace("Bearer ", "") || null;
         if (!rawToken && config.allowTokenInQuery) {
@@ -38258,14 +38291,6 @@ async function createArcServer(config) {
         if (rawToken && !tokenPayload) {
           return Response.json({ error: "Unauthorized" }, { status: 401, headers: corsHeaders2 });
         }
-        if (url.pathname === "/ws" && req.headers.get("Upgrade") === "websocket") {
-          if (server2.upgrade(req, { data: { clientId: "" } }))
-            return;
-          return new Response("WebSocket upgrade failed", {
-            status: 500,
-            headers: corsHeaders2
-          });
-        }
         const reqCtx = { rawToken, tokenPayload, corsHeaders: corsHeaders2 };
         for (const handler of httpHandlers) {
           const response = await handler(req, url, reqCtx);
@@ -38379,7 +38404,13 @@ init_i18n();
 import { timingSafeEqual } from "crypto";
 import { existsSync as existsSync19, mkdirSync as mkdirSync15 } from "fs";
 import { join as join22 } from "path";
-import { MAP_SCHEMA_VERSION } from "@arcote.tech/arc-map/types";
+async function initContextHandler(context2, dbPath) {
+  const factory = await resolveDbAdapterFactory(dbPath);
+  const dbAdapter = factory(context2);
+  const handler = new ContextHandler(context2, dbAdapter);
+  await handler.init();
+  return handler;
+}
 async function resolveDbAdapterFactory(dbPath) {
   const databaseUrl = process.env.DATABASE_URL;
   if (databaseUrl && databaseUrl.length > 0) {
@@ -38648,6 +38679,7 @@ function parseCorsOrigins(raw) {
   const list = raw.split(",").map((s) => s.trim()).filter(Boolean);
   return list.length > 0 ? list : undefined;
 }
+var DISCOVERY_SCHEMA_VERSION = 1;
 function safeEqual(a2, b4) {
   const ab = Buffer.from(a2);
   const bb = Buffer.from(b4);
@@ -38659,18 +38691,11 @@ function handleDiscovery(req, ctx, ws, manifest, federation, mapUrl) {
   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
-    });
-  }
   const fed = manifest.federation;
   const platformUrl = process.env.ARC_PUBLIC_URL || new URL(req.url).origin;
   return Response.json({
     meta: {
-      schemaVersion: MAP_SCHEMA_VERSION,
+      schemaVersion: DISCOVERY_SCHEMA_VERSION,
       name: ws.appName,
       version: ws.rootPkg?.version ?? undefined
     },
@@ -39085,11 +39110,11 @@ async function startPlatform(opts) {
 }
 async function startMapTool(ws, port, authToken, platformServer, platform3) {
   try {
-    const { startMapServer, MAP_SCHEMA_VERSION: MAP_SCHEMA_VERSION2 } = await import("@arcote.tech/arc-map");
+    const { startMapServer, MAP_SCHEMA_VERSION } = await import("@arcote.tech/arc-map");
     const { getContext } = await import("@arcote.tech/platform");
     const globs = ws.packages.map((p3) => join23(p3.path, "src", "**", "*.{ts,tsx}"));
     const packageOf = (absFile) => ws.packages.find((p3) => absFile.startsWith(join23(p3.path, "src")))?.name;
-    const meta = readAppMeta(ws.rootDir, MAP_SCHEMA_VERSION2);
+    const meta = readAppMeta(ws.rootDir, MAP_SCHEMA_VERSION);
     const map = await startMapServer({
       getContext: () => getContext(),
       scan: { globs, workspaceRoot: ws.rootDir, packageOf },
@@ -39111,18 +39136,12 @@ async function startMapTool(ws, port, authToken, platformServer, platform3) {
 function assertProdFederationSecrets(devMode, hasFederation) {
   if (devMode || !hasFederation)
     return;
-  const missing = [];
-  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)
+  if (process.env.ARC_PAIRING_TOKEN || process.env.ARC_MAP_TOKEN)
     return;
-  err(`Federacja w produkcji wymaga zmiennych \u015Brodowiskowych: ${missing.join(", ")}.
-` + `  Bez nich sekret i token s\u0105 generowane w kontenerze i GIN\u0104 przy pierwszym
-` + `  recreate \u2014 hosty musia\u0142yby przeinstalowa\u0107 aplikacj\u0119, bez \u017Cadnego b\u0142\u0119du.
-` + `  Ustaw je w deployu (deploy.arc.json \u2192 envVars + deploy.arc.<env>.env).`);
+  err(`Federacja w produkcji wymaga zmiennej \u015Brodowiskowej ARC_PAIRING_TOKEN.
+` + `  Bez niej token parowania jest generowany w kontenerze i GINIE przy
+` + `  pierwszym recreate \u2014 parowania host\xF3w staj\u0105 si\u0119 martwe, bez b\u0142\u0119du.
+` + `  Ustaw j\u0105 w deployu (deploy.arc.json \u2192 envVars + deploy.arc.<env>.env).`);
   process.exit(1);
 }
 function resolveAppSecret(rootDir) {
@@ -39233,6 +39252,36 @@ async function platformDev(opts = {}) {
   });
 }
 
+// src/commands/platform-pairing-token.ts
+import { randomBytes as randomBytes3 } from "crypto";
+import { join as join24 } from "path";
+async function platformPairingToken() {
+  const ws = resolveWorkspace();
+  const { context: context2 } = await loadServerContext(ws);
+  if (!context2) {
+    err("Brak zbudowanego kontekstu. Uruchom najpierw `arc platform build`.");
+    process.exit(1);
+  }
+  const isProd = false;
+  const dbPath = join24(ws.rootDir, ".arc", "data", isProd ? "prod.db" : "dev.db");
+  const handler = await initContextHandler(context2, dbPath);
+  const code = randomBytes3(24).toString("base64url");
+  const res = await handler.executeCommand("pairingCode.issue", { code }, null, { internal: true });
+  if (!res?.ok) {
+    err(`Nie uda\u0142o si\u0119 zapisa\u0107 kodu parowania${res?.error ? `: ${res.error}` : ""}. ` + "Czy aplikacja wystawia agregat `pairingCode` (federacja)?");
+    process.exit(1);
+  }
+  process.stdout.write(`
+  Kod parowania (jednorazowy):
+
+    ${code}
+
+` + `  Podaj go w ho\u015Bcie przy instalacji aplikacji. Wygasa po pierwszym u\u017Cyciu.
+
+`);
+  process.exit(0);
+}
+
 // src/commands/platform-start.ts
 async function platformStart() {
   const ws = resolveWorkspace();
@@ -39252,6 +39301,7 @@ platform3.command("dev").description("Start platform in dev mode (Bun server + V
 }));
 platform3.command("build").description("Build platform for production").option("--no-cache", "Force full rebuild").action((opts) => platformBuild({ noCache: opts.cache === false }));
 platform3.command("start").description("Start platform in production mode (requires prior build)").action(platformStart);
+platform3.command("pairing-token").description("Generate a one-time federation pairing code (writes to DB, prints it)").action(platformPairingToken);
 platform3.command("deploy [env]").description("Deploy platform to a remote server (reads deploy.arc.json, surveys if missing)").option("--skip-build", "Skip local build step").option("--rebuild", "Force rebuild before deploy").option("--build-only", "Build the Docker image locally, then exit (no remote push)").option("--image-tag <hash>", "Roll back / pin to an existing image tag instead of building a new one").option("--force-bootstrap", "Re-run Ansible host bootstrap even if the server is already configured").action((env2, opts) => platformDeploy(env2, opts));
 program2.parse(process.argv);
 if (process.argv.length === 2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-cli",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "CLI tool for Arc framework",
   "module": "index.ts",
   "main": "dist/index.js",
@@ -12,13 +12,13 @@
     "build": "bun build --target=bun ./src/index.ts --outdir=dist --external @arcote.tech/arc --external @arcote.tech/arc-ds --external @arcote.tech/arc-react --external @arcote.tech/platform --external @arcote.tech/arc-map --external '@opentelemetry/*' && chmod +x dist/index.js"
   },
   "dependencies": {
-    "@arcote.tech/arc": "^0.8.0",
-    "@arcote.tech/arc-ds": "^0.8.0",
-    "@arcote.tech/arc-react": "^0.8.0",
-    "@arcote.tech/arc-host": "^0.8.0",
-    "@arcote.tech/arc-adapter-db-sqlite": "^0.8.0",
-    "@arcote.tech/arc-adapter-db-postgres": "^0.8.0",
-    "@arcote.tech/arc-otel": "^0.8.0",
+    "@arcote.tech/arc": "^0.8.2",
+    "@arcote.tech/arc-ds": "^0.8.2",
+    "@arcote.tech/arc-react": "^0.8.2",
+    "@arcote.tech/arc-host": "^0.8.2",
+    "@arcote.tech/arc-adapter-db-sqlite": "^0.8.2",
+    "@arcote.tech/arc-adapter-db-postgres": "^0.8.2",
+    "@arcote.tech/arc-otel": "^0.8.2",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/api-logs": "^0.57.0",
     "@opentelemetry/core": "^1.30.0",
@@ -31,8 +31,8 @@
     "@opentelemetry/sdk-trace-base": "^1.30.0",
     "@opentelemetry/sdk-trace-node": "^1.30.0",
     "@opentelemetry/semantic-conventions": "^1.27.0",
-    "@arcote.tech/platform": "^0.8.0",
-    "@arcote.tech/arc-map": "^0.8.0",
+    "@arcote.tech/platform": "^0.8.2",
+    "@arcote.tech/arc-map": "^0.8.2",
     "@clack/prompts": "^0.9.0",
     "commander": "^11.1.0",
     "chokidar": "^3.5.3",

package/src/commands/platform-deploy.ts

@@ -119,6 +119,14 @@ export async function platformDeploy(
         randomBytes(16).toString("base64url"),
       );
     }
+    // Przeładowanie jest KONIECZNE: `loadDeployConfig` wczytał sidecar i scalił
+    // go do `cfg.envs[].envVars` ZANIM powyższe dopisało do pliku, a compose
+    // renderuje `environment` właśnie z `envVars`. Bez tego kontener startuje
+    // bez sekretów i pada na fail-fascie — przy czym DRUGI deploy by przeszedł
+    // (sidecar ma już klucze), co daje błąd zależny od historii, najgorszy do
+    // zdiagnozowania. Inaczej niż hasło Postgresa, które trafia do compose
+    // przez `${ARC_PG_PASSWORD_*}` z `/opt/arc/.env`, nie przez `envVars`.
+    cfg = loadDeployConfig(ws.rootDir);
   }
 
   // Observability stack — one Grafana password per deployment (stack-wide,

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/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
@@ -60,6 +61,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

@@ -10,9 +10,6 @@ import {
 import { timingSafeEqual } from "crypto";
 import { existsSync, mkdirSync } from "fs";
 import { join } from "path";
-// Subpath `/types` jest bezzależnościowy — import z korzenia arc-map wciągnąłby
-// ts-morph do każdego startu platformy (startup.ts importuje mapę leniwie).
-import { MAP_SCHEMA_VERSION } from "@arcote.tech/arc-map/types";
 import { readTranslationsConfig } from "../i18n";
 import { err, ok, type BuildManifest, type WorkspaceInfo } from "./shared";
 import type { BuildManifestGroup, ModuleAccess } from "@arcote.tech/platform";
@@ -532,6 +529,19 @@ function parseCorsOrigins(raw: string | undefined): string[] | undefined {
   return list.length > 0 ? list : undefined;
 }
 
+/**
+ * Wersja kontraktu discovery — MUSI odpowiadać `MAP_SCHEMA_VERSION`
+ * z `@arcote.tech/arc-map/src/types.ts`.
+ *
+ * Świadomie ZDUPLIKOWANA, nie zaimportowana: `arc-map` to narzędzie DEV, którego
+ * w obrazie produkcyjnym NIE MA (`bun install --production` pomija devDeps, a
+ * CLI trzyma go jako `--external`). Import — nawet z bezzależnościowego subpatha
+ * — zostawał w `host.js` i wywalał kontener w pętli restartów:
+ * `Cannot find module '@arcote.tech/arc-map/types'`. Bezzależnościowość PLIKU
+ * nie pomaga, gdy brakuje całego PAKIETU.
+ */
+const DISCOVERY_SCHEMA_VERSION = 1;
+
 /** Porównanie sekretów w czasie stałym (bez wycieku długości prefiksu). */
 function safeEqual(a: string, b: string): boolean {
   const ab = Buffer.from(a);
@@ -563,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
@@ -581,7 +589,7 @@ function handleDiscovery(
   return Response.json(
     {
       meta: {
-        schemaVersion: MAP_SCHEMA_VERSION,
+        schemaVersion: DISCOVERY_SCHEMA_VERSION,
         name: ws.appName,
         version: (ws.rootPkg?.version as string | undefined) ?? undefined,
       },

package/src/platform/startup.ts

@@ -232,37 +232,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);
 }