Home /Modules/operating-system/SLDownloadSet.sleela

SLDownloadSet.sleela

lib/operating-system/SLDownloadSet.sleela · 252 line(s) · sleela

<< lib/operating-system/SLDownloadSet.sleela
   SLeeLa Standard Library Definition.
   Definition: Defines SLDownloadSet — the set of URLs for the related downloads
     an OS build needs, resolved and recorded BEFORE the OS is compiled or the
     ISO is authored. A build does not pull everything from one place: it needs
     package repositories, the kernel and firmware sources, backend runtimes for
     foreign execution (Wine, QEMU, binfmt tooling), the upstream distro parts,
     and any developer-added sources. Each download is a kind + URL + an optional
     pinned version/checksum, and a PHASE that says whether it must be present
     before compile (sources/toolchain) or before the final ISO conversion
     (runtime payloads seeded into the rootfs).
   
   This makes the build's external dependencies explicit and auditable: a tool
   can list every URL, verify each is reachable, and refuse to compile or author
   the ISO until the required ones for that phase are present. SLOSModel composes
   one; the OS Creator writes it as a downloads manifest and a fetch script.
   
   The slots are fixed (array-free, like the rest of the model); up to a bounded
   number of extra developer URLs are held in parallel string fields.
   
   Family: operating-system. Design model; the reachability probe crosses the osRun bridge
     (requires #sleela 1.5). >>
#sleela 2.5
material;
class SLDownloadSet {
  < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
  << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader,
     or catalog can read and (where appropriate) override this record.
     Values are faithful to the subject's real origin where publicly known. >>
  String metaVersion = "1.0.0";
  int metaId = 11006;
  String metaAuthor = "Kiro Agent";
  String metaDate = "2026-10-16";
  String metaCopyright = "SLeeLa project";
  String metaTrademark = "none";
  String metaCorporation = "none";
  < metaOrigin: National | <nation> | International | Galactic >
  String metaOrigin = "International";
  String metaBirthDate = "2026-10-11";
  < metaScienceRating: maturity/robustness on a 1..10 scale >
  int metaScienceRating = 9;
  < metaNationalSchedule: a real, citable instrument or "none" >
  String metaNationalSchedule = "none";

  String getMetaVersion() { return metaVersion; }
  void setMetaVersion(String v) { metaVersion = v; }
  int getMetaId() { return metaId; }
  void setMetaId(int v) { metaId = v; }
  String getAuthor() { return metaAuthor; }
  void setAuthor(String v) { metaAuthor = v; }
  String getDate() { return metaDate; }
  void setDate(String v) { metaDate = v; }
  String getCopyright() { return metaCopyright; }
  void setCopyright(String v) { metaCopyright = v; }
  String getTrademark() { return metaTrademark; }
  void setTrademark(String v) { metaTrademark = v; }
  String getCorporation() { return metaCorporation; }
  void setCorporation(String v) { metaCorporation = v; }
  String getOrigin() { return metaOrigin; }
  void setOrigin(String v) { metaOrigin = v; }
  String getBirthDate() { return metaBirthDate; }
  void setBirthDate(String v) { metaBirthDate = v; }
  int getScienceRating() { return metaScienceRating; }
  void setScienceRating(int v) { metaScienceRating = v; }
  String getNationalSchedule() { return metaNationalSchedule; }
  void setNationalSchedule(String v) { metaNationalSchedule = v; }
  < Phase tags: when a download must be present. >
  < before compiling the OS (sources/toolchain) >
  static final int PHASE_COMPILE = 0;
  < before authoring the ISO (rootfs payloads) >
  static final int PHASE_ISO     = 1;

  < Well-known download slots. "" when unset. >
  String packageRepo;    String kernelSrc;    String firmwareSrc;
  String runtimeWine;    String runtimeQemu;  String upstreamDistro;
  < Up to four developer-added extra URLs, each "kind|url|phase". >
  String extra0; String extra1; String extra2; String extra3;
  int extraCount;
  < The resilient fallback downloader: when a primary URL 404s, it supplies >
  < prioritized support/mirror URLs (authoritative -> official -> college -> >
  < archive). This is the OS-document hook for the support downloader module. >
  SLSupportDownloader support;
  int configured;

  void configure() {
    packageRepo = ""; kernelSrc = ""; firmwareSrc = "";
    runtimeWine = ""; runtimeQemu = ""; upstreamDistro = "";
    extra0 = ""; extra1 = ""; extra2 = ""; extra3 = ""; extraCount = 0;
    support = new SLSupportDownloader(); support.configure();
    configured = 1;
  }

  < The composed support downloader (for the OS document to reach). >
  SLSupportDownloader supportDownloader() { return support; }

  < Seed the per-shape default download URLs. These are the canonical upstreams >
  < a build of that family pulls from; a developer overrides any of them. >
  void forShape(SLOSShape shape) {
    configure();
    upstreamDistro = "https://github.com/mearvk/Ubuntu.Determinant.Beta.Restricted.git";
    if (shape.isWindows()) {
      packageRepo = "https://pkgs.local/windows";
      kernelSrc   = "https://pkgs.local/windows/nt-src";
      firmwareSrc = "https://uefi.org/firmware";
      return;
    }
    if (shape.isMac()) {
      packageRepo = "https://pkgs.local/macos";
      kernelSrc   = "https://opensource.apple.com/source/xnu";
      firmwareSrc = "https://uefi.org/firmware";
      runtimeQemu = "https://www.qemu.org/download";
      return;
    }
    < Linux defaults. >
    packageRepo    = "http://archive.ubuntu.com/ubuntu";
    kernelSrc      = "https://cdn.kernel.org/pub/linux/kernel";
    firmwareSrc    = "https://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git";
    runtimeWine    = "https://dl.winehq.org/wine-builds";
    runtimeQemu    = "https://www.qemu.org/download";
  }

  < ---- Setters -------------------------------------------------------- >
  void setPackageRepo(String url) { packageRepo = url; }
  void setKernelSrc(String url)   { kernelSrc = url; }
  void setFirmwareSrc(String url) { firmwareSrc = url; }
  void setRuntimeWine(String url) { runtimeWine = url; }
  void setRuntimeQemu(String url) { runtimeQemu = url; }
  void setUpstreamDistro(String url) { upstreamDistro = url; }

  < Add a developer download: kind label, URL, and phase (0 compile / 1 iso). >
  < Up to four extras are held. >
  int addExtra(String kind, String url, int phase) {
    String ph = "compile";
    if (phase == PHASE_ISO) { ph = "iso"; }
    String rec = kind + "|" + url + "|" + ph;
    if (extraCount == 0) { extra0 = rec; }
    else if (extraCount == 1) { extra1 = rec; }
    else if (extraCount == 2) { extra2 = rec; }
    else if (extraCount == 3) { extra3 = rec; }
    < full >
    else { return -1; }
    extraCount = extraCount + 1;
    return 0;
  }

  < ---- Validity ------------------------------------------------------- >
  < Before COMPILE: a package repo + kernel source must be known (you cannot >
  < build an OS without where its base and kernel come from). >
  boolean readyForCompile() {
    if (configured != 1) { return false; }
    return packageRepo != "" && kernelSrc != "";
  }
  < Before ISO: additionally the firmware source must be known (the ESP/loader >
  < needs firmware), and every required slot resolved. >
  boolean readyForIso() {
    if (!readyForCompile()) { return false; }
    return firmwareSrc != "";
  }

  < ---- Manifest + fetch ----------------------------------------------- >
  < A newline manifest "<kind> <phase> <url>" of every known download. >
  String downloadManifest() {
    String m = "";
    m = row(m, "package-repo", "compile", packageRepo);
    m = row(m, "kernel-src",   "compile", kernelSrc);
    m = row(m, "firmware-src", "iso",     firmwareSrc);
    m = row(m, "runtime-wine", "iso",     runtimeWine);
    m = row(m, "runtime-qemu", "iso",     runtimeQemu);
    m = row(m, "upstream",     "compile", upstreamDistro);
    m = rowExtra(m, extra0);
    m = rowExtra(m, extra1);
    m = rowExtra(m, extra2);
    m = rowExtra(m, extra3);
    return m;
  }
  String row(String acc, String kind, String phase, String url) {
    if (url == "") { return acc; }
    String l = kind + " " + phase + " " + url;
    if (acc == "") { return l; }
    return acc + "\n" + l;
  }
  < An extra record "kind|url|phase" -> "kind phase url". >
  String rowExtra(String acc, String rec) {
    if (rec == "") { return acc; }
    < kept raw; the emitter reformats pipes for display >
    return acc + "\n" + rec;
  }

  < A POSIX fetch script that retrieves the phase's downloads. Honest: it uses >
  < the right tool per URL scheme (git clone for .git, curl otherwise) and is a >
  < separate, explicit step — never run during compile automatically. >
  String fetchScript(int phase) {
    String s = "#!/bin/sh\n# fetch downloads (phase=" + phaseName(phase)
             + ") generated by SLeeLa lib/os\nset -eu\nmkdir -p downloads\n";
    s = s + fetchLine(phase, PHASE_COMPILE, "package-repo", packageRepo);
    s = s + fetchLine(phase, PHASE_COMPILE, "kernel-src", kernelSrc);
    s = s + fetchLine(phase, PHASE_COMPILE, "upstream", upstreamDistro);
    s = s + fetchLine(phase, PHASE_ISO, "firmware-src", firmwareSrc);
    s = s + fetchLine(phase, PHASE_ISO, "runtime-wine", runtimeWine);
    s = s + fetchLine(phase, PHASE_ISO, "runtime-qemu", runtimeQemu);
    s = s + "echo \"downloads for phase " + phaseName(phase) + " complete\"\n";
    return s;
  }
  String fetchLine(int wantPhase, int rowPhase, String kind, String url) {
    if (url == "") { return ""; }
    if (wantPhase != rowPhase) { return ""; }
    < Choose the fetch tool by the download's kind rather than by string >
    < inspection: the distro upstream and kernel/firmware source are git repos; >
    < package repos and runtime payloads are retrieved with curl. (The surface >
    < has no string-length/substring, so kind drives the choice, not a suffix.) >
    if (kind == "upstream" || kind == "kernel-src" || kind == "firmware-src") {
      return "git clone --depth 1 " + url + " downloads/" + kind + " || true\n";
    }
    return "curl -fsSL -o downloads/" + kind + ".payload \"" + url + "\" || true\n";
  }

  String phaseName(int phase) { if (phase == PHASE_ISO) { return "iso"; } return "compile"; }

  < ---- Resilient fetch via the support downloader --------------------- >
  < supportFetchScript(phase): like fetchScript, but each component is fetched >
  < through the support downloader's 404-tolerant fallback loop (primary -> >
  < official mirror -> college/edu mirror -> archive). This is what a build >
  < should run so a single 404 does not break it. >
  String supportFetchScript(int phase) {
    String s = "#!/bin/sh\n# resilient fetch (phase=" + phaseName(phase)
             + ") with 404 fallback, generated by SLeeLa lib/os\nset -eu\nmkdir -p downloads\n";
    if (phase == PHASE_COMPILE) {
      s = s + support.fetchWithFallback("package", "downloads/package.payload");
      s = s + support.fetchWithFallback("kernel", "downloads/kernel-src");
      s = s + support.fetchWithFallback("upstream", "downloads/upstream");
    } else {
      s = s + support.fetchWithFallback("firmware", "downloads/firmware");
      s = s + support.fetchWithFallback("wine", "downloads/wine.payload");
      s = s + support.fetchWithFallback("qemu", "downloads/qemu.payload");
    }
    s = s + "echo \"resilient downloads for phase " + phaseName(phase) + " complete\"\n";
    return s;
  }

  < The support URL table for the manifest/report (every kind, every tier). >
  String supportManifest() {
    String s = "";
    s = s + "# package:\n" + support.rankedList("package") + "\n";
    s = s + "# kernel:\n" + support.rankedList("kernel") + "\n";
    s = s + "# firmware:\n" + support.rankedList("firmware") + "\n";
    s = s + "# upstream:\n" + support.rankedList("upstream") + "\n";
    s = s + "# wine:\n" + support.rankedList("wine") + "\n";
    s = s + "# qemu:\n" + support.rankedList("qemu");
    return s;
  }
}