define-alpine-the-sequel/alpine.ts

import {
  chmod,
  copyFile,
  mkdir,
  opendir,
  symlink,
  writeFile,
} from "node:fs/promises";
import path from "node:path";
import { cwd } from "node:process";
import { Fstab } from "./fstab.js";
import { execFile } from "./helpers/better-api.js";
import { PasswdEntry, sudoReadPasswd } from "./helpers/passwd.js";
import { sudoWriteExecutable } from "./helpers/sudo.js";
import { logDebug } from "./helpers/logger.js";

export class Alpine {
  dir: string;
  private constructor({ dir }: { dir: string }) {
    this.dir = dir;
  }
  fstab: Fstab = new Fstab(this);

  async mkdir(dir: string, opts?: { recursive: boolean }): Promise<void> {
    await mkdir(path.join(this.dir, dir), opts);
  }
  async writeFile(filePath: string, content: string): Promise<void> {
    await this.mkdir(path.dirname(filePath), { recursive: true });
    await writeFile(path.join(this.dir, filePath), content);
  }
  async writeExecutable(filePath: string, content: string): Promise<void> {
    await this.writeFile(filePath, content);
    await chmod(path.join(this.dir, filePath), 700);
  }
  path(p: string): string {
    return path.join(this.dir, p);
  }
  sudoWriteExecutable(filePath: string, content: string): Promise<void> {
    return sudoWriteExecutable(this.path(filePath), content);
  }
  private getRelativeSymlink(
    target: string,
    filePath: string
  ): { target: string; filePath: string } {
    const realFilePath = path.join(this.dir, filePath);
    return {
      target: path.relative(
        path.dirname(realFilePath),
        path.join(this.dir, target)
      ),
      filePath: realFilePath,
    };
  }
  async symlink(_target: string, _filePath: string): Promise<void> {
    const { target, filePath } = this.getRelativeSymlink(_target, _filePath);
    await symlink(target, filePath);
  }
  async sudoSymlink(_target: string, _filePath: string): Promise<void> {
    const { target, filePath } = this.getRelativeSymlink(_target, _filePath);
    await execFile("sudo", ["ln", "-s", target, filePath]);
  }

  async userAdd(user: string): Promise<PasswdEntry> {
    await execFile("sudo", [
      "useradd",
      "--user-group",
      "--root",
      this.dir,
      user,
    ]);
    const passwd = await sudoReadPasswd(this.path("/etc/passwd"));
    const entry = passwd.find((e) => e.name === user);
    if (!entry) {
      throw new Error("fatal(userAdd): no encontré el usuario " + user);
    }
    return entry;
  }

  async addPackages(packages: string[]): Promise<void> {
    logDebug(
      "addPackages",
      await execFile("sudo", [
        "apk",
        "add",
        "--clean-protected",
        "--root",
        this.dir,
        ...packages,
      ])
    );
  }

  static async makeWorld({
    dir,
    packages,
  }: {
    dir: string;
    packages?: string[];
  }): Promise<Alpine> {
    const apkDir = path.join(dir, "/etc/apk");
    await mkdir(apkDir, { recursive: true });

    // hack
    {
      const cacheDir = path.join(cwd(), "cache");
      await mkdir("cache", { recursive: true });
      await symlink(cacheDir, path.join(apkDir, "cache"));
    }

    {
      const apkKeysDir = path.join(apkDir, "keys");
      const keysSrcDir = "alpine/keys";
      await mkdir(apkKeysDir);
      for await (const { name } of await opendir(keysSrcDir))
        await copyFile(
          path.join(keysSrcDir, name),
          path.join(apkKeysDir, name)
        );
    }

    await writeFile(
      path.join(apkDir, "repositories"),
      [
        "https://dl-cdn.alpinelinux.org/alpine/v3.17/main",
        "https://dl-cdn.alpinelinux.org/alpine/v3.17/community",
      ].join("\n")
    );
    logDebug(
      "makeWorld",
      await execFile("sudo", [
        "apk",
        "add",
        "--initdb",
        "--clean-protected",
        "--root",
        dir,
        ...["alpine-baselayout", "busybox", "libc-utils", "alpine-keys"],
        ...(packages || []),
      ])
    );

    const alpine = new Alpine({ dir });
    await alpine.fstab.write();
    return alpine;
  }
}