@fased/fased 0.1.59 → 0.1.61

package/scripts/install-managed-runtime.mjs

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  assertManagedRuntime,
+  atomicSymlink,
+  atomicWriteJson,
+  buildManagedInstallManifest,
+  copyExecutable,
+  normalizeManagedProfile,
+  readHostedRuntimeMetadata,
+  readManagedInstallManifest,
+  readPackageVersion,
+  resolveLinkTarget,
+  resolveManagedRuntimePaths,
+} from "./managed-runtime-layout.mjs";
+
+function parseArgs(argv) {
+  const rollback = argv[0] === "--rollback";
+  const tokens = rollback ? argv.slice(1) : argv;
+  const values = new Map();
+  for (let index = 0; index < tokens.length; index += 1) {
+    const key = tokens[index];
+    const value = tokens[index + 1];
+    if (!key?.startsWith("--") || !value || value.startsWith("--")) {
+      throw new Error(`Invalid managed runtime installer argument: ${key || ""}`);
+    }
+    values.set(key, value);
+    index += 1;
+  }
+  const packageRoot = values.get("--package-root");
+  const stateDir = values.get("--state-dir");
+  const prefix = values.get("--prefix");
+  if (!stateDir || !prefix || (!rollback && !packageRoot)) {
+    throw new Error("--package-root, --state-dir, and --prefix are required");
+  }
+  return {
+    rollback,
+    packageRoot: packageRoot ? path.resolve(packageRoot) : null,
+    previousPackageRoot: values.get("--previous-package-root")
+      ? path.resolve(values.get("--previous-package-root"))
+      : null,
+    stateDir: path.resolve(stateDir),
+    prefix: path.resolve(prefix),
+    profile: normalizeManagedProfile(values.get("--profile")),
+  };
+}
+
+async function pathExists(target) {
+  try {
+    await fsp.lstat(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function moveDirectory(source, destination) {
+  try {
+    await fsp.rename(source, destination);
+    return;
+  } catch (error) {
+    if (error?.code !== "EXDEV") {
+      throw error;
+    }
+  }
+  await fsp.cp(source, destination, {
+    recursive: true,
+    dereference: false,
+    preserveTimestamps: true,
+  });
+  await fsp.rm(source, { recursive: true, force: true });
+}
+
+async function replaceWithSymlink(target, linkPath) {
+  let backupPath = null;
+  if (await pathExists(linkPath)) {
+    const stat = await fsp.lstat(linkPath);
+    if (stat.isSymbolicLink()) {
+      await fsp.rm(linkPath, { force: true });
+    } else {
+      backupPath = `${linkPath}.legacy-${Date.now()}-${process.pid}`;
+      await fsp.rename(linkPath, backupPath);
+    }
+  }
+  try {
+    await atomicSymlink(target, linkPath);
+  } catch (error) {
+    if (backupPath) {
+      await fsp.rename(backupPath, linkPath).catch(() => undefined);
+    }
+    throw error;
+  }
+  return backupPath;
+}
+
+async function installStableFiles(paths, releaseRoot) {
+  const scriptDir = path.join(releaseRoot, "scripts");
+  await copyExecutable(path.join(scriptDir, "fased-managed-launcher.sh"), paths.launcherPath);
+  await copyExecutable(path.join(scriptDir, "fased-managed-service.sh"), paths.serviceLauncherPath);
+  await copyExecutable(path.join(scriptDir, "fased-managed-updater.mjs"), paths.updaterPath);
+  await copyExecutable(
+    path.join(scriptDir, "managed-runtime-layout.mjs"),
+    path.join(paths.updaterDir, "managed-runtime-layout.mjs"),
+  );
+  await fsp.mkdir(path.dirname(paths.prefixLauncherPath), { recursive: true });
+  const launcherBackup = await replaceWithSymlink(paths.launcherPath, paths.prefixLauncherPath);
+  if (launcherBackup) {
+    await fsp.rm(launcherBackup, { recursive: true, force: true });
+  }
+}
+
+export async function installManagedRuntime(params) {
+  const paths = resolveManagedRuntimePaths(params);
+  const existingManifest = readManagedInstallManifest(paths.manifestPath);
+  const version = await assertManagedRuntime(params.packageRoot);
+  const metadata = await readHostedRuntimeMetadata(params.packageRoot);
+  let previousRoot = await resolveLinkTarget(paths.currentLink);
+  let previousVersion = previousRoot ? await readPackageVersion(previousRoot) : null;
+  let releaseRoot = path.join(paths.releasesDir, version);
+
+  await fsp.mkdir(paths.releasesDir, { recursive: true });
+  await fsp.mkdir(paths.stagingDir, { recursive: true });
+
+  const packageReal = await fsp.realpath(params.packageRoot).catch(() => params.packageRoot);
+  const releaseReal = await fsp.realpath(releaseRoot).catch(() => releaseRoot);
+  if (packageReal === releaseReal && existingManifest?.runtime?.activeVersion === version) {
+    previousVersion = existingManifest.runtime.previousVersion || null;
+  }
+  if (packageReal !== releaseReal) {
+    if (await pathExists(releaseRoot)) {
+      if (previousVersion === version) {
+        releaseRoot = path.join(
+          paths.releasesDir,
+          `${version}.repair-${Date.now()}-${process.pid}`,
+        );
+      } else {
+        await fsp.rm(releaseRoot, { recursive: true, force: true });
+      }
+    }
+    await moveDirectory(params.packageRoot, releaseRoot);
+  }
+  await assertManagedRuntime(releaseRoot, version);
+
+  if (
+    !previousRoot &&
+    params.previousPackageRoot &&
+    (await pathExists(params.previousPackageRoot))
+  ) {
+    const legacyVersion = await readPackageVersion(params.previousPackageRoot);
+    if (legacyVersion && legacyVersion !== version) {
+      const legacyReleaseRoot = path.join(paths.releasesDir, legacyVersion);
+      if (await pathExists(legacyReleaseRoot)) {
+        await fsp.rm(params.previousPackageRoot, { recursive: true, force: true });
+      } else {
+        await moveDirectory(params.previousPackageRoot, legacyReleaseRoot);
+      }
+      previousRoot = legacyReleaseRoot;
+      previousVersion = legacyVersion;
+    }
+  }
+
+  if (previousRoot && path.resolve(previousRoot) !== path.resolve(releaseRoot)) {
+    await atomicSymlink(previousRoot, paths.previousLink);
+  }
+  await atomicSymlink(releaseRoot, paths.currentLink);
+
+  const compatibilityBackup = await replaceWithSymlink(
+    paths.currentLink,
+    paths.compatibilityPackageRoot,
+  );
+  await installStableFiles(paths, releaseRoot);
+
+  const manifest = buildManagedInstallManifest({
+    paths,
+    profile: params.profile,
+    version,
+    dependencyHash: metadata?.dependencyHash,
+    previousVersion: previousVersion || null,
+  });
+  await atomicWriteJson(paths.manifestPath, manifest, 0o600);
+  await fsp.chmod(paths.stateDir, 0o700).catch(() => undefined);
+  if (compatibilityBackup) {
+    await fsp.rm(compatibilityBackup, { recursive: true, force: true });
+  }
+  return { manifest, paths, releaseRoot };
+}
+
+export async function rollbackManagedRuntime(params) {
+  const paths = resolveManagedRuntimePaths(params);
+  const manifest = readManagedInstallManifest(paths.manifestPath);
+  if (!manifest) {
+    throw new Error("Managed installation manifest is unavailable for rollback.");
+  }
+  const currentRoot = await resolveLinkTarget(paths.currentLink);
+  const previousRoot = await resolveLinkTarget(paths.previousLink);
+  if (!previousRoot || !currentRoot || path.resolve(previousRoot) === path.resolve(currentRoot)) {
+    throw new Error("No previous managed runtime is available for rollback.");
+  }
+  const previousVersion = await assertManagedRuntime(previousRoot);
+  const currentVersion = await readPackageVersion(currentRoot);
+  const metadata = await readHostedRuntimeMetadata(previousRoot);
+
+  await atomicSymlink(currentRoot, paths.previousLink);
+  await atomicSymlink(previousRoot, paths.currentLink);
+  await replaceWithSymlink(paths.currentLink, paths.compatibilityPackageRoot);
+  await installStableFiles(paths, previousRoot);
+  const previousManifest = buildManagedInstallManifest({
+    paths,
+    profile: manifest.profile,
+    version: previousVersion,
+    dependencyHash: metadata?.dependencyHash,
+    previousVersion: currentVersion,
+  });
+  await atomicWriteJson(paths.manifestPath, previousManifest, 0o600);
+  return { manifest: previousManifest, paths, releaseRoot: previousRoot };
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    const result = options.rollback
+      ? await rollbackManagedRuntime(options)
+      : await installManagedRuntime(options);
+    process.stdout.write(
+      `${options.rollback ? "Rolled back to" : "Installed stable Fased updater and activated"} managed runtime v${result.manifest.runtime.activeVersion}.\n`,
+    );
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
+}
+
+export const __testing = {
+  installStableFiles,
+  moveDirectory,
+  replaceWithSymlink,
+};

package/scripts/managed-runtime-layout.mjs

@@ -0,0 +1,188 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+export const MANAGED_INSTALL_SCHEMA_VERSION = 1;
+
+export function resolveManagedStateDir(env = process.env, homedir = os.homedir) {
+  return path.resolve(
+    env.FASED_STATE_DIR || env.FASED_CONFIG_DIR || path.join(homedir(), ".fased"),
+  );
+}
+
+export function resolveManagedRuntimePaths({ stateDir, prefix } = {}) {
+  const resolvedStateDir = path.resolve(stateDir || resolveManagedStateDir());
+  const resolvedPrefix = path.resolve(
+    prefix || path.join(resolvedStateDir, "install-cache", "npm-global"),
+  );
+  const runtimeDir = path.join(resolvedStateDir, "runtime");
+  const binDir = path.join(resolvedStateDir, "bin");
+  const updaterDir = path.join(resolvedStateDir, "updater");
+  return {
+    stateDir: resolvedStateDir,
+    manifestPath: path.join(resolvedStateDir, "install.json"),
+    runtimeDir,
+    releasesDir: path.join(runtimeDir, "releases"),
+    currentLink: path.join(runtimeDir, "current"),
+    previousLink: path.join(runtimeDir, "previous"),
+    stagingDir: path.join(runtimeDir, ".staging"),
+    binDir,
+    launcherPath: path.join(binDir, "fased"),
+    serviceLauncherPath: path.join(binDir, "fased-service"),
+    updaterDir,
+    updaterPath: path.join(updaterDir, "fased-managed-updater.mjs"),
+    prefix: resolvedPrefix,
+    compatibilityPackageRoot: path.join(resolvedPrefix, "lib", "node_modules", "@fased", "fased"),
+    prefixLauncherPath: path.join(resolvedPrefix, "bin", "fased"),
+  };
+}
+
+export function normalizeManagedProfile(value) {
+  const profile = String(value || "")
+    .trim()
+    .toLowerCase();
+  if (profile === "hosting" || profile === "local" || profile === "source") {
+    return profile;
+  }
+  return "local";
+}
+
+export function readManagedInstallManifest(manifestPath) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    if (parsed?.schemaVersion !== MANAGED_INSTALL_SCHEMA_VERSION) {
+      return null;
+    }
+    if (!parsed.runtime || typeof parsed.runtime.activeVersion !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export async function readPackageVersion(packageRoot) {
+  try {
+    const parsed = JSON.parse(await fsp.readFile(path.join(packageRoot, "package.json"), "utf8"));
+    return typeof parsed.version === "string" && parsed.version.trim()
+      ? parsed.version.trim()
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function readHostedRuntimeMetadata(packageRoot) {
+  try {
+    const parsed = JSON.parse(
+      await fsp.readFile(path.join(packageRoot, ".fased-hosted-runtime.json"), "utf8"),
+    );
+    if (parsed?.schemaVersion !== 1 || !/^[a-f0-9]{64}$/.test(parsed.dependencyHash || "")) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export async function assertManagedRuntime(packageRoot, expectedVersion) {
+  const version = await readPackageVersion(packageRoot);
+  if (!version || (expectedVersion && version !== expectedVersion)) {
+    throw new Error(
+      `Managed runtime version mismatch: expected ${expectedVersion || "a package version"}, found ${version || "unknown"}.`,
+    );
+  }
+  for (const required of [
+    "fased.mjs",
+    "node_modules",
+    "scripts/start-managed.sh",
+    "dist/control-ui/version.json",
+  ]) {
+    await fsp.access(path.join(packageRoot, required));
+  }
+  const ui = JSON.parse(
+    await fsp.readFile(path.join(packageRoot, "dist", "control-ui", "version.json"), "utf8"),
+  );
+  if (ui?.version !== version) {
+    throw new Error(
+      `Managed dashboard version ${ui?.version || "unknown"} does not match runtime ${version}.`,
+    );
+  }
+  return version;
+}
+
+export async function atomicWriteFile(targetPath, content, mode = 0o600) {
+  await fsp.mkdir(path.dirname(targetPath), { recursive: true });
+  const temporaryPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+  await fsp.writeFile(temporaryPath, content, { mode });
+  await fsp.chmod(temporaryPath, mode);
+  await fsp.rename(temporaryPath, targetPath);
+}
+
+export async function atomicWriteJson(targetPath, value, mode = 0o600) {
+  await atomicWriteFile(targetPath, `${JSON.stringify(value, null, 2)}\n`, mode);
+}
+
+export async function atomicSymlink(target, linkPath) {
+  await fsp.mkdir(path.dirname(linkPath), { recursive: true });
+  const temporaryPath = `${linkPath}.tmp-${process.pid}-${Date.now()}`;
+  await fsp.rm(temporaryPath, { force: true, recursive: true });
+  await fsp.symlink(target, temporaryPath, "dir");
+  await fsp.rename(temporaryPath, linkPath);
+}
+
+export async function copyExecutable(source, destination) {
+  const content = await fsp.readFile(source);
+  await atomicWriteFile(destination, content, 0o755);
+}
+
+export async function resolveLinkTarget(linkPath) {
+  try {
+    return await fsp.realpath(linkPath);
+  } catch {
+    return null;
+  }
+}
+
+export function buildManagedInstallManifest({
+  paths,
+  profile,
+  version,
+  dependencyHash,
+  previousVersion,
+  source = "managed-artifact",
+}) {
+  const normalizedProfile = normalizeManagedProfile(profile);
+  return {
+    schemaVersion: MANAGED_INSTALL_SCHEMA_VERSION,
+    profile: normalizedProfile,
+    source,
+    stateDir: paths.stateDir,
+    configPath: path.join(paths.stateDir, "fased.json"),
+    runtime: {
+      activeVersion: version,
+      previousVersion: previousVersion || null,
+      currentLink: paths.currentLink,
+      previousLink: paths.previousLink,
+      releasesDir: paths.releasesDir,
+      dependencyHash: dependencyHash || null,
+    },
+    package: {
+      prefix: paths.prefix,
+      compatibilityRoot: paths.compatibilityPackageRoot,
+    },
+    service: {
+      name: "fased-gateway.service",
+      scope: normalizedProfile === "hosting" ? "system" : "user",
+      launcher: paths.serviceLauncherPath,
+    },
+    updater: {
+      version,
+      path: paths.updaterPath,
+    },
+    updatedAt: new Date().toISOString(),
+  };
+}