@arcote.tech/arc-cli 0.6.2 → 0.7.1

package/src/deploy/remote-sync.ts

@@ -1,321 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { basename, join } from "path";
-import type { BuildManifest, ModuleDescriptor } from "@arcote.tech/platform";
-import type { DeployConfig } from "./config";
-import { assertExec, openTunnel } from "./ssh";
-import { isContextPackage } from "../builder/module-builder";
-import type { WorkspaceInfo } from "../platform/shared";
-
-// ---------------------------------------------------------------------------
-// v0.6 sync driver — API-only, per-module. No rsync of user code.
-//
-// Flow per env:
-//  1. Open SSH tunnel to Caddy 127.0.0.1:2019 (admin listener)
-//  2. GET /api/deploy/framework → remote framework depsHash
-//  3. If local hash differs → POST /api/deploy/framework (multipart
-//     package.json + bun.lock). Response needsRestart=true → close tunnel,
-//     `docker restart arc-${env}`, reopen tunnel, wait for /health.
-//  4. GET /api/deploy/manifest → remote manifest
-//  5. diffManifests → per-module list of changes
-//  6. For each changed module: POST /api/deploy/modules/<name>
-//     (browser.js + server.js? + package.json + access.json?)
-//  7. If styles changed: POST /api/deploy/styles
-//  8. POST /api/deploy/manifest (commit). Response needsRestart=true when
-//     any module had server.js change → second restart.
-// ---------------------------------------------------------------------------
-
-export interface SyncInputs {
-  cfg: DeployConfig;
-  env: string;
-  ws: WorkspaceInfo;
-  /** Path to the project root. */
-  projectDir: string;
-}
-
-export interface SyncOutcome {
-  env: string;
-  frameworkChanged: boolean;
-  changedModules: readonly string[];
-  stylesChanged: boolean;
-  restarts: number;
-}
-
-// ---------------------------------------------------------------------------
-// Pure diff — exported for tests
-// ---------------------------------------------------------------------------
-
-export interface ManifestDiff {
-  changedModules: ModuleDescriptor[];
-  stylesChanged: boolean;
-}
-
-export function diffManifests(
-  local: BuildManifest,
-  remote: BuildManifest,
-): ManifestDiff {
-  const remoteByName = new Map(remote.modules.map((m) => [m.name, m]));
-  const changedModules = local.modules.filter(
-    (m) => remoteByName.get(m.name)?.hash !== m.hash,
-  );
-  return {
-    changedModules: [...changedModules],
-    stylesChanged: local.stylesHash !== remote.stylesHash,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Sync driver
-// ---------------------------------------------------------------------------
-
-export async function syncEnv(inputs: SyncInputs): Promise<SyncOutcome> {
-  const { cfg, env, ws } = inputs;
-  const envConfig = cfg.envs[env];
-  if (!envConfig) throw new Error(`Unknown env: ${env}`);
-
-  // Local artifacts must exist (arc platform build was run)
-  const localManifestPath = join(ws.modulesDir, "manifest.json");
-  if (!existsSync(localManifestPath)) {
-    throw new Error(
-      `Local build missing at ${localManifestPath}. Run arc platform build first.`,
-    );
-  }
-  const localManifest = JSON.parse(
-    readFileSync(localManifestPath, "utf-8"),
-  ) as BuildManifest;
-
-  // Map module name → workspace package (needed to decide if server.js exists)
-  const pkgByName = new Map(
-    ws.packages.map((p) => [p.name.includes("/") ? p.name.split("/").pop()! : p.name, p]),
-  );
-
-  let tunnel = await openTunnel(
-    cfg.target,
-    15500 + hashEnvToOffset(env),
-    "127.0.0.1",
-    2019,
-  );
-  let restarts = 0;
-  let frameworkChanged = false;
-
-  try {
-    const base = () =>
-      `http://127.0.0.1:${tunnel.localPort}/env/${env}`;
-
-    // 1. Framework deps — diff and push if changed
-    const localFrameworkHash = readDepsHash(join(ws.arcDir, ".deps-hash"));
-    const remoteFwRes = await fetch(`${base()}/api/deploy/framework`);
-    const remoteFw = remoteFwRes.ok
-      ? ((await remoteFwRes.json()) as { depsHash: string | null })
-      : { depsHash: null };
-
-    if (localFrameworkHash && localFrameworkHash !== remoteFw.depsHash) {
-      console.log("[arc] Pushing framework deps...");
-      const form = new FormData();
-      form.append(
-        "package.json",
-        new Blob([readFileSync(join(ws.arcDir, "package.json"))]),
-        "package.json",
-      );
-      // Ship a placeholder bun.lock (server validates its presence) but
-      // intentionally empty — workspace bun.lock has the full dep graph and
-      // would trip --frozen-lockfile against our slim framework package.json.
-      // The server side runs `bun install --production` without freeze, so an
-      // empty lock is harmless: bun re-resolves against package.json.
-      form.append("bun.lock", new Blob([""]), "bun.lock");
-      const res = await fetch(`${base()}/api/deploy/framework`, {
-        method: "POST",
-        body: form,
-      });
-      if (!res.ok) {
-        throw new Error(
-          `framework push failed: ${res.status} ${await res.text()}`,
-        );
-      }
-      frameworkChanged = true;
-      const result = (await res.json()) as { needsRestart?: boolean };
-      if (result.needsRestart) {
-        tunnel = await restartAndReopen(cfg, env, tunnel);
-        restarts += 1;
-      }
-    }
-
-    // 2. Remote manifest + diff
-    const remoteManifestRes = await fetch(`${base()}/api/deploy/manifest`);
-    const remoteManifest: BuildManifest = remoteManifestRes.ok
-      ? await remoteManifestRes.json()
-      : ({
-          modules: [],
-          shellHash: "",
-          stylesHash: "",
-          buildTime: "",
-        } satisfies BuildManifest);
-    const diff = diffManifests(localManifest, remoteManifest);
-
-    // 3. Per-module push
-    for (const mod of diff.changedModules) {
-      const safeName = sanitizeName(mod.name);
-      const moduleDir = join(ws.modulesDir, safeName);
-      const browserPath = join(moduleDir, "browser.js");
-      const serverPath = join(moduleDir, "server.js");
-      const pkgPath = join(moduleDir, "package.json");
-      const accessPath = join(moduleDir, "access.json");
-
-      // Fall back to legacy <name>.js path while module-builder still emits
-      // the flat layout. Same hash either way.
-      const browserActual = existsSync(browserPath)
-        ? browserPath
-        : join(ws.modulesDir, `${safeName}.js`);
-      if (!existsSync(browserActual)) {
-        throw new Error(`Missing browser bundle for module ${mod.name}`);
-      }
-
-      const form = new FormData();
-      form.append(
-        "browser.js",
-        new Blob([readFileSync(browserActual)]),
-        "browser.js",
-      );
-
-      const pkg = pkgByName.get(safeName);
-      if (pkg && isContextPackage(pkg.packageJson) && existsSync(serverPath)) {
-        form.append(
-          "server.js",
-          new Blob([readFileSync(serverPath)]),
-          "server.js",
-        );
-      }
-      if (existsSync(pkgPath)) {
-        form.append(
-          "package.json",
-          new Blob([readFileSync(pkgPath)]),
-          "package.json",
-        );
-      }
-      if (existsSync(accessPath)) {
-        form.append(
-          "access.json",
-          new Blob([readFileSync(accessPath)]),
-          "access.json",
-        );
-      }
-
-      console.log(`[arc] Pushing module ${safeName}...`);
-      const res = await fetch(`${base()}/api/deploy/modules/${safeName}`, {
-        method: "POST",
-        body: form,
-      });
-      if (!res.ok) {
-        throw new Error(
-          `module ${safeName} push failed: ${res.status} ${await res.text()}`,
-        );
-      }
-    }
-
-    // 4. Styles push
-    if (diff.stylesChanged) {
-      console.log("[arc] Pushing styles...");
-      const form = new FormData();
-      for (const name of ["styles.css", "theme.css"] as const) {
-        const p = join(ws.arcDir, name);
-        if (existsSync(p)) {
-          form.append(name, new Blob([readFileSync(p)]), name);
-        }
-      }
-      const res = await fetch(`${base()}/api/deploy/styles`, {
-        method: "POST",
-        body: form,
-      });
-      if (!res.ok) {
-        throw new Error(
-          `styles push failed: ${res.status} ${await res.text()}`,
-        );
-      }
-    }
-
-    // 5. Manifest commit
-    const commitRes = await fetch(`${base()}/api/deploy/manifest`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(localManifest),
-    });
-    if (!commitRes.ok) {
-      throw new Error(
-        `manifest commit failed: ${commitRes.status} ${await commitRes.text()}`,
-      );
-    }
-    const commit = (await commitRes.json()) as { needsRestart?: boolean };
-    if (commit.needsRestart) {
-      tunnel = await restartAndReopen(cfg, env, tunnel);
-      restarts += 1;
-    }
-
-    return {
-      env,
-      frameworkChanged,
-      changedModules: diff.changedModules.map((m) => m.name),
-      stylesChanged: diff.stylesChanged,
-      restarts,
-    };
-  } finally {
-    tunnel.close();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function readDepsHash(path: string): string | null {
-  if (!existsSync(path)) return null;
-  return readFileSync(path, "utf-8").trim() || null;
-}
-
-function sanitizeName(name: string): string {
-  // Strip package scope ("@ndt/auth" → "auth"); manifest already stores names
-  // this way, but be defensive.
-  return basename(name);
-}
-
-async function restartAndReopen(
-  cfg: DeployConfig,
-  env: string,
-  oldTunnel: { close: () => void; localPort: number },
-): Promise<{ close: () => void; localPort: number }> {
-  console.log(`[arc] Restarting arc-${env}...`);
-  oldTunnel.close();
-  await assertExec(cfg.target, `docker restart arc-${env}`);
-
-  const tunnel = await openTunnel(
-    cfg.target,
-    15500 + hashEnvToOffset(env),
-    "127.0.0.1",
-    2019,
-  );
-  await waitForHealthy(`http://127.0.0.1:${tunnel.localPort}/env/${env}`, 60_000);
-  return tunnel;
-}
-
-async function waitForHealthy(baseUrl: string, timeoutMs: number): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  let lastErr: unknown;
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`${baseUrl}/api/deploy/health`, {
-        signal: AbortSignal.timeout(2_000),
-      });
-      if (res.ok) return;
-      lastErr = `status ${res.status}`;
-    } catch (e) {
-      lastErr = e;
-    }
-    await new Promise((r) => setTimeout(r, 1_000));
-  }
-  throw new Error(`Health check timeout: ${String(lastErr)}`);
-}
-
-/** Deterministic per-env tunnel port offset so parallel syncs don't collide. */
-function hashEnvToOffset(env: string): number {
-  let h = 0;
-  for (const ch of env) h = (h * 31 + ch.charCodeAt(0)) >>> 0;
-  return h % 100;
-}