@arcote.tech/arc-cli 0.6.1 → 0.7.0

package/src/commands/build-shell.ts

@@ -1,152 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
-
-// ---------------------------------------------------------------------------
-// _build-shell — hidden subcommand used by the runtime container's
-// /api/deploy/framework handler after `bun install` of the framework peers.
-// Discovers every @arcote.tech/* package + react/react-dom under --from and
-// emits one ESM shell bundle per package under --out. The browser then loads
-// these as singletons (shared across all user modules).
-//
-// Decoupled from `arc platform build` (which runs in the user's workspace) —
-// this command operates purely on an installed node_modules tree, with no
-// concept of workspace packages or build cache.
-// ---------------------------------------------------------------------------
-
-export interface BuildShellOptions {
-  out: string;
-  from: string;
-}
-
-const REACT_ENTRIES: Array<[string, string]> = [
-  ["react", `export * from "react";\nimport * as React from "react";\nexport default React;`],
-  ["react-dom", `export * from "react-dom";\nimport * as ReactDOM from "react-dom";\nexport default ReactDOM;`],
-  ["jsx-runtime", `export * from "react/jsx-runtime";`],
-  ["jsx-dev-runtime", `export * from "react/jsx-dev-runtime";`],
-  ["react-dom-client", `export { createRoot, hydrateRoot } from "react-dom/client";`],
-];
-
-const SHELL_BASE_EXTERNAL = [
-  "react",
-  "react-dom",
-  "react/jsx-runtime",
-  "react/jsx-dev-runtime",
-  "react-dom/client",
-];
-
-export async function buildShell(opts: BuildShellOptions): Promise<void> {
-  const outDir = opts.out;
-  const fromDir = opts.from;
-
-  if (!existsSync(fromDir)) {
-    console.error(`[_build-shell] --from not found: ${fromDir}`);
-    process.exit(1);
-  }
-
-  mkdirSync(outDir, { recursive: true });
-  const tmpDir = join(outDir, "_tmp");
-  mkdirSync(tmpDir, { recursive: true });
-
-  try {
-    const arcPkgs = discoverArcPackages(fromDir);
-    if (arcPkgs.length === 0) {
-      console.warn("[_build-shell] no @arcote.tech/* packages discovered");
-    }
-
-    console.log(
-      `[_build-shell] building shell for react + ${arcPkgs.length} @arcote.tech/* package(s)`,
-    );
-
-    await buildReactShell(outDir, tmpDir, fromDir);
-    for (const pkg of arcPkgs) {
-      await buildArcEntry(pkg, arcPkgs, outDir, tmpDir, fromDir);
-    }
-
-    console.log(`[_build-shell] done → ${outDir}`);
-  } finally {
-    rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Discovery — list every @arcote.tech/* dir under node_modules
-// ---------------------------------------------------------------------------
-
-function discoverArcPackages(fromDir: string): string[] {
-  const arcDir = join(fromDir, "@arcote.tech");
-  if (!existsSync(arcDir)) return [];
-  return readdirSync(arcDir)
-    .filter((name) => existsSync(join(arcDir, name, "package.json")))
-    .map((name) => `@arcote.tech/${name}`);
-}
-
-// ---------------------------------------------------------------------------
-// React shell (separated because it's not under @arcote.tech)
-// ---------------------------------------------------------------------------
-
-async function buildReactShell(
-  outDir: string,
-  tmpDir: string,
-  fromDir: string,
-): Promise<void> {
-  const eps: string[] = [];
-  for (const [name, code] of REACT_ENTRIES) {
-    const f = join(tmpDir, `${name}.ts`);
-    await Bun.write(f, code);
-    eps.push(f);
-  }
-
-  const r = await Bun.build({
-    entrypoints: eps,
-    outdir: outDir,
-    splitting: true,
-    format: "esm",
-    target: "browser",
-    naming: "[name].[ext]",
-    root: fromDir,
-  });
-  if (!r.success) {
-    for (const l of r.logs) console.error(l);
-    throw new Error("React shell build failed");
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Per-@arcote.tech package shell
-// ---------------------------------------------------------------------------
-
-async function buildArcEntry(
-  pkg: string,
-  allArcPkgs: string[],
-  outDir: string,
-  tmpDir: string,
-  fromDir: string,
-): Promise<void> {
-  const shortName = pkg.replace("@arcote.tech/", "");
-  const otherExternals = allArcPkgs.filter((p) => p !== pkg);
-
-  const f = join(tmpDir, `${shortName}.ts`);
-  await Bun.write(f, `export * from "${pkg}";\n`);
-
-  // Bun needs to resolve `pkg` from fromDir. Setting `root: fromDir` and
-  // letting Bun walk up node_modules works because @arcote.tech/* lives at
-  // `fromDir/@arcote.tech/<name>`.
-  const r = await Bun.build({
-    entrypoints: [f],
-    outdir: outDir,
-    format: "esm",
-    target: "browser",
-    naming: "[name].[ext]",
-    root: fromDir,
-    external: [...SHELL_BASE_EXTERNAL, ...otherExternals],
-    define: {
-      ONLY_SERVER: "false",
-      ONLY_BROWSER: "true",
-      ONLY_CLIENT: "true",
-    },
-  });
-  if (!r.success) {
-    for (const l of r.logs) console.error(l);
-    throw new Error(`Shell build failed for ${pkg}`);
-  }
-}

package/src/deploy/remote-sync.ts

@@ -1,323 +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",
-      );
-      const lockPath = join(ws.arcDir, "bun.lock");
-      if (existsSync(lockPath)) {
-        form.append(
-          "bun.lock",
-          new Blob([readFileSync(lockPath)]),
-          "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;
-}