@arcote.tech/arc-cli 0.8.1 → 0.8.2

package/dist/index.js

@@ -38266,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) {
@@ -38283,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);
@@ -38404,6 +38404,13 @@ init_i18n();
 import { timingSafeEqual } from "crypto";
 import { existsSync as existsSync19, mkdirSync as mkdirSync15 } from "fs";
 import { join as join22 } from "path";
+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) {
@@ -38684,13 +38691,6 @@ 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({
@@ -39136,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) {
@@ -39258,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();
@@ -39277,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.1",
+  "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.1",
-    "@arcote.tech/arc-ds": "^0.8.1",
-    "@arcote.tech/arc-react": "^0.8.1",
-    "@arcote.tech/arc-host": "^0.8.1",
-    "@arcote.tech/arc-adapter-db-sqlite": "^0.8.1",
-    "@arcote.tech/arc-adapter-db-postgres": "^0.8.1",
-    "@arcote.tech/arc-otel": "^0.8.1",
+    "@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.1",
-    "@arcote.tech/arc-map": "^0.8.1",
+    "@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-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

@@ -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/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);
 }