lino-react 26.7.2__tar.gz → 26.7.4__tar.gz

{lino_react-26.7.2 → lino_react-26.7.4}/.gitlab-ci.yml

@@ -62,7 +62,12 @@ detect_version_change:
   script:
     - git fetch origin master --depth=2
     - CURRENT_VERSION=$(node -p "require('./package.json').version")
-    - PREVIOUS_VERSION=$(git show HEAD~1:package.json 2>/dev/null | node -p "const data = fs.readFileSync(0, 'utf-8'); try { JSON.parse(data).version } catch { '0.0.0' }") || PREVIOUS_VERSION="0.0.0"
+    # - PREVIOUS_VERSION=$(git show HEAD~1:package.json 2>/dev/null | node -p "const data = fs.readFileSync(0, 'utf-8'); try { JSON.parse(data).version } catch { '0.0.0' }") || PREVIOUS_VERSION="0.0.0"
+    - |
+      PREVIOUS_VERSION=$(
+        git show HEAD~1:package.json 2>/dev/null |
+        node -p "const data = fs.readFileSync(0, 'utf-8'); try { JSON.parse(data).version } catch { '0.0.0' }"
+      ) || PREVIOUS_VERSION="0.0.0"
     - echo "Previous version was $PREVIOUS_VERSION. Current version is $CURRENT_VERSION."
     - |
       if [ "$CURRENT_VERSION" = "$PREVIOUS_VERSION" ]; then
@@ -77,37 +82,33 @@ detect_version_change:
       dotenv: build.env
 
 publish_apps:
-  image: node:22-bookworm
+  image: node:24-bookworm
   stage: build-and-publish
   dependencies:
     - detect_version_change
   needs:
     - job: detect_version_change
       artifacts: true
-  cache:
-    key: wine-packages-cache
-    paths:
-      - .apt-cache/
   variables:
     LANG: C.UTF-8
     LC_ALL: C.UTF-8
   before_script:
     - echo "Setting up architecture layers and underlying compiler support packages..."
-    - export APT_CACHE_DIR="${CI_PROJECT_DIR}/.apt-cache"
-    - mkdir -p "${APT_CACHE_DIR}/partial"
     - dpkg --add-architecture i386
     - apt-get update -y
-    - apt-get -o dir::cache::archives="${APT_CACHE_DIR}" install -y wine wine32 wine64 libwine texlive libxtst6
+    - apt-get install -y wine wine32 wine64 libwine texlive libxtst6
+    - apt-get install -y python3
+    - apt-get install -y python3-yaml
+    - apt-get install -y rpm
     - npm ci
   rules:
     - if: '$CI_COMMIT_BRANCH == "master"'
   script:
-    # - |
-    #   if [ "$VERSION_CHANGED" != "true" ]; then
-    #     echo "Bypassing compilation. No version bump recorded."
-    #     exit 0
-    #   fi
-    - export GITLAB_TOKEN="${GITLAB_TOKEN}"
+    - |
+      if [ "$VERSION_CHANGED" != "true" ]; then
+        echo "Bypassing compilation. No version bump recorded."
+        exit 0
+      fi
 
     # DYNAMICALLY EXTRACT AND EXPORT THE CURRENT VERSION FOR THE API URL
     - export CURRENT_VERSION=$(node -p "require('./package.json').version")
@@ -116,32 +117,33 @@ publish_apps:
     - export APP_FLAVOR="prontobd"
     - export OVERRIDE_PRODUCT_NAME="Pronto BD"
     - export BUILD_URL="https://pronto.bd"
+    - export PACKAGE="lino-electron"
+    - echo "Project ID - $CI_PROJECT_ID"
 
-    # === 1. BUILD LINUX VERSION SEQUELETIALLY ===
-    # - echo "Compiling Linux Assets..."
-    # - npm run pre
-    # - npx electron-builder --linux --config=electron-builder.js --publish always
-    # - npm run post
-    
-    # === 2. BUILD WINDOWS VERSION SEQUELETIALLY (Uses Wine on Linux Host) ===
-    - echo "Compiling Windows Assets..."
-    - npm run pre
-    - |
-      set +e
+    # === 0. SET DESKTOP NAME IN PACKAGE.JSON ===
+    - node ci/inject_desktopName.mjs
 
-      wine cmd /c echo hello
-      dpkg -l | grep -E 'wine|nsis'
-      which wine
-      which makensis
-
-      npx electron-builder --win --config=electron-builder.js --publish always
-      RC=$?
-
-      echo "Exit code: $RC"
-      
-      npm run post
-
-      exit $RC
+    # === 1. BUILD LINUX & WINDOWS ASSETS ===
+    - echo "Compiling Linux & Windows Assets..."
+    - npm run pre
+    - npx electron-builder --linux --win --config=electron-builder.js --publish never
+    - npm run post
+
+    # === 2. SANITIZE & PUBLISH LINUX & WINDOW ASSETS ===
+    - mkdir -p latest
+    - cp edist/*.yml latest/
+    - node ci/sanitize_filenames.mjs
+    - node ci/upload_packages.mjs
+    
+    # === 3. BUILD & PUBLISH LATEST META ===
+    - python3 write_electron_latest_meta.py "$CURRENT_VERSION" "$PACKAGE" "$CI_PROJECT_ID" "$CI_API_V4_URL" latest/prontobd.yml latest/prontobd-linux.yml
+    - node ci/upload_latest.mjs
+    
+    # === 4. CREATE RELEASE TAG & ASSET LINKS ===
+    - node ci/create_release.mjs
+    
+    # === 5. CLEANUP ===
+    - KEEP=10 node ci/cleanup_releases.mjs
 
 test:
   stage: test

{lino_react-26.7.2 → lino_react-26.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lino_react
-Version: 26.7.2
+Version: 26.7.4
 Summary: The React front end for Lino
 Project-URL: Homepage, https://react.lino-framework.org
 Project-URL: Repository, https://gitlab.com/lino-framework/react

lino_react-26.7.4/ci/cleanup_releases.mjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+const KEEP = Number(process.env.KEEP ?? 10);
+
+const {
+    GITLAB_TOKEN,
+    CI_API_V4_URL,
+    CI_PROJECT_ID,
+    PACKAGE,
+    CURRENT_VERSION,
+} = process.env;
+
+for (const variable of [
+    "GITLAB_TOKEN",
+    "CI_API_V4_URL",
+    "CI_PROJECT_ID",
+    "PACKAGE",
+    "CURRENT_VERSION",
+]) {
+    if (!process.env[variable]) {
+        console.error(`Missing environment variable: ${variable}`);
+        process.exit(1);
+    }
+}
+
+const api = `${CI_API_V4_URL}/projects/${encodeURIComponent(CI_PROJECT_ID)}`;
+
+async function request(path, options = {}) {
+    const response = await fetch(`${api}${path}`, {
+        ...options,
+        headers: {
+            "PRIVATE-TOKEN": GITLAB_TOKEN,
+            ...(options.headers ?? {}),
+        },
+    });
+
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+            `${response.status} ${response.statusText}\n${path}\n${text}`
+        );
+    }
+
+    if (response.status === 204)
+        return null;
+
+    return response.json();
+}
+
+async function fetchAllPackages() {
+    const packages = [];
+    let page = 1;
+
+    while (true) {
+        console.log(`Fetching package page ${page}...`);
+
+        const result = await request(
+            `/packages?package_name=${encodeURIComponent(PACKAGE)}&package_type=generic&per_page=100&page=${page}`
+        );
+
+        if (result.length === 0)
+            break;
+
+        packages.push(...result);
+        page++;
+    }
+
+    return packages;
+}
+
+async function removeReleaseAssets(version) {
+    try {
+        const release = await request(`/releases/v${version}`);
+
+        if (!release.assets?.links?.length) {
+            console.log(`    No release asset links.`);
+            return;
+        }
+
+        for (const link of release.assets.links) {
+            console.log(`    Removing asset: ${link.name}`);
+
+            await request(
+                `/releases/v${version}/assets/links/${link.id}`,
+                {
+                    method: "DELETE",
+                }
+            );
+        }
+    }
+    catch (err) {
+        console.warn(`    Couldn't update release v${version}: ${err.message}`);
+    }
+}
+
+async function deletePackage(packageId) {
+    await request(`/packages/${packageId}`, {
+        method: "DELETE",
+    });
+}
+
+async function main() {
+
+    const packages = await fetchAllPackages();
+
+    packages.sort(
+        (a, b) =>
+            new Date(b.created_at) -
+            new Date(a.created_at)
+    );
+
+    console.log("");
+    console.log(`Found ${packages.length} package versions.`);
+    console.log(`Keeping newest ${KEEP}.`);
+    console.log("");
+
+    for (let index = 0; index < packages.length; index++) {
+
+        const pkg = packages[index];
+
+        if (index < KEEP) {
+            console.log(`Keeping ${pkg.version}`);
+            continue;
+        }
+
+        if (pkg.version === CURRENT_VERSION) {
+            console.log(`Skipping current version ${pkg.version}`);
+            continue;
+        }
+
+        console.log("");
+        console.log(`Cleaning ${pkg.version}`);
+
+        await removeReleaseAssets(pkg.version);
+
+        console.log(`    Deleting package...`);
+
+        await deletePackage(pkg.id);
+
+        console.log(`    Done.`);
+    }
+
+    console.log("");
+    console.log("Cleanup complete.");
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exit(1);
+});

lino_react-26.7.4/ci/create_release.mjs

@@ -0,0 +1,171 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const {
+    GITLAB_TOKEN,
+    CI_API_V4_URL,
+    CI_PROJECT_ID,
+    CI_COMMIT_SHA,
+    CI_COMMIT_MESSAGE,
+    CURRENT_VERSION,
+    PACKAGE,
+} = process.env;
+
+for (const variable of [
+    "GITLAB_TOKEN",
+    "CI_API_V4_URL",
+    "CI_PROJECT_ID",
+    "CI_COMMIT_SHA",
+    "CI_COMMIT_MESSAGE",
+    "PACKAGE",
+    "CURRENT_VERSION",
+]) {
+    if (!process.env[variable]) {
+        console.error(`Missing environment variable: ${variable}`);
+        process.exit(1);
+    }
+}
+
+
+const api = `${CI_API_V4_URL}/projects/${CI_PROJECT_ID}`;
+
+async function postForm(url, fields) {
+    const form = new FormData();
+
+    for (const [key, value] of Object.entries(fields)) {
+        form.append(key, value);
+    }
+
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "PRIVATE-TOKEN": GITLAB_TOKEN,
+        },
+        body: form,
+    });
+
+    if (!response.ok) {
+        throw new Error(
+            `${response.status} ${response.statusText}\n${await response.text()}`
+        );
+    }
+
+    return response.json().catch(() => ({}));
+}
+
+function extractReleaseNotes(message) {
+    const lines = message.split(/\r?\n/);
+
+    const output = [];
+    let capture = false;
+
+    for (const line of lines) {
+        if (!capture) {
+            if (line.trim() === "Electron Release Note:") {
+                capture = true;
+            }
+            continue;
+        }
+
+        // if (line.trim() === "") {
+        //     break;
+        // }
+
+        output.push(line);
+    }
+
+    return output.join("\n");
+}
+
+async function createTag() {
+    console.log(`Creating tag v${CURRENT_VERSION}`);
+
+    await postForm(`${api}/repository/tags`, {
+        tag_name: `v${CURRENT_VERSION}`,
+        ref: CI_COMMIT_SHA,
+    });
+}
+
+async function createRelease(notes) {
+    console.log(`Creating release v${CURRENT_VERSION}`);
+
+    await postForm(`${api}/releases`, {
+        name: `v${CURRENT_VERSION}`,
+        tag_name: `v${CURRENT_VERSION}`,
+        description: notes,
+    });
+}
+
+async function addAsset(name, filename) {
+    console.log(`Adding asset: ${filename}`);
+
+    const encoded = encodeURIComponent(filename);
+
+    const url =
+        `${CI_API_V4_URL}/projects/${CI_PROJECT_ID}` +
+        `/packages/generic/${PACKAGE}/${CURRENT_VERSION}/${encoded}`;
+
+    await postForm(
+        `${api}/releases/v${CURRENT_VERSION}/assets/links`,
+        {
+            name,
+            url,
+        },
+    );
+}
+
+async function collectFiles(dir) {
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+
+        return entries
+            .filter((e) => e.isFile())
+            .map((e) => path.join(dir, e.name));
+    }
+    catch {
+        return [];
+    }
+}
+
+const assetNames = {
+    ".exe": "Windows Installer",
+    ".deb": "Debian Package",
+    ".rpm": "RPM Package",
+    ".AppImage": "AppImage",
+};
+
+async function main() {
+    const notes = extractReleaseNotes(CI_COMMIT_MESSAGE ?? "");
+
+    await createTag();
+    await createRelease(notes);
+
+    const files = [
+        ...(await collectFiles("edist")),
+    ];
+
+    for (const file of files) {
+        const basename = path.basename(file);
+
+        let displayName = null;
+
+        if (basename.endsWith(".AppImage")) {
+            displayName = assetNames[".AppImage"];
+        } else {
+            displayName = assetNames[path.extname(basename)];
+        }
+
+        if (!displayName) {
+            continue;
+        }
+
+        await addAsset(displayName, basename);
+    }
+
+    console.log("Release completed.");
+}
+
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

lino_react-26.7.4/ci/inject_desktopName.mjs

@@ -0,0 +1,16 @@
+import fs from "node:fs/promises";
+
+const packageJson = JSON.parse(
+    await fs.readFile("package.json", "utf8")
+);
+
+if (process.env.APP_FLAVOR) {
+    packageJson.desktopName = `${packageJson.desktopName}.${process.env.APP_FLAVOR}`;
+
+    await fs.writeFile(
+        "package.json",
+        JSON.stringify(packageJson, null, 2) + "\n"
+    );
+    
+    console.log("desktopName =", packageJson.desktopName);
+}

lino_react-26.7.4/ci/sanitize_filenames.mjs

@@ -0,0 +1,112 @@
+// ci/sanitize_filenames.mjs
+
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const DIRECTORIES = ["edist", "latest"];
+
+/**
+ * Replace characters GitLab Generic Registry dislikes.
+ * Currently:
+ *   - whitespace -> -
+ *
+ * You can easily extend this later if necessary.
+ */
+function sanitize(name) {
+    return name.replace(/\s+/g, "-")
+    .replace(/[^a-zA-Z0-9._+~@-]/g, '');
+}
+
+async function renameDirectory(dir) {
+    const mapping = new Map();
+
+    let entries;
+
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return mapping;
+    }
+
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+
+        const oldName = entry.name;
+        const newName = sanitize(oldName);
+
+        if (oldName === newName)
+            continue;
+
+        await fs.rename(
+            path.join(dir, oldName),
+            path.join(dir, newName),
+        );
+
+        console.log(`${oldName} -> ${newName}`);
+
+        mapping.set(oldName, newName);
+    }
+
+    return mapping;
+}
+
+async function rewriteYaml(dir, mapping) {
+    let entries;
+
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+
+    for (const entry of entries) {
+
+        if (!entry.isFile() || !entry.name.endsWith(".yml"))
+            continue;
+
+        const file = path.join(dir, entry.name);
+
+        let text = await fs.readFile(file, "utf8");
+
+        for (const [oldName, newName] of mapping) {
+            text = text.split(oldName).join(newName);
+        }
+
+        await fs.writeFile(file, text);
+
+        console.log(`Updated ${file}`);
+    }
+}
+
+async function main() {
+
+    const mapping = new Map();
+
+    // Rename files
+    for (const dir of DIRECTORIES) {
+        const local = await renameDirectory(dir);
+
+        for (const [k, v] of local)
+            mapping.set(k, v);
+    }
+
+    if (mapping.size === 0) {
+        console.log("Nothing to sanitize.");
+        return;
+    }
+
+    // Rewrite metadata
+    for (const dir of DIRECTORIES) {
+        await rewriteYaml(dir, mapping);
+    }
+
+    console.log("Done.");
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});

lino_react-26.7.4/ci/upload_latest.mjs

@@ -0,0 +1,113 @@
+// electron/uploadLatest.mjs
+
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+
+const {
+    CI_API_V4_URL,
+    CI_PROJECT_ID,
+    CI_JOB_TOKEN,
+    PACKAGE,
+} = process.env;
+
+for (const variable of [
+    "CI_API_V4_URL",
+    "CI_PROJECT_ID",
+    "CI_JOB_TOKEN",
+    "PACKAGE",
+]) {
+    if (!process.env[variable]) {
+        console.error(`Missing environment variable: ${variable}`);
+        process.exit(1);
+    }
+}
+
+const execFileAsync = promisify(execFile);
+
+async function curlUpload(filePath, url) {
+    try {
+        await execFileAsync("curl", [
+            "--fail",
+            "--show-error",
+            "--silent",
+            "--header", `JOB-TOKEN: ${CI_JOB_TOKEN}`,
+            "--upload-file", filePath,
+            url,
+        ]);
+    }
+    catch (err) {
+        console.error(`Upload failed: ${filePath}`);
+        console.error(`URL: ${url}`);
+
+        if (err.stderr) {
+            console.error(err.stderr);
+        }
+
+        throw err;
+    }
+}
+
+const latestDir = "latest";
+
+async function uploadFile(filePath) {
+    const fileName = path.basename(filePath);
+
+    const url =
+        `${CI_API_V4_URL}/projects/${CI_PROJECT_ID}` +
+        `/packages/generic/${PACKAGE}/latest/${fileName}`;
+
+    console.log(`Uploading ${fileName}...`);
+
+    await curlUpload(filePath, url);
+
+    console.log(`✓ Uploaded ${fileName}`);
+}
+
+// async function uploadFile(filePath) {
+//     const fileName = path.basename(filePath);
+
+//     const url =
+//         `${CI_API_V4_URL}/projects/${CI_PROJECT_ID}` +
+//         `/packages/generic/${PACKAGE}/latest/${encodeURIComponent(fileName)}`;
+
+//     console.log(`Uploading ${fileName}...`);
+
+//     const response = await fetch(url, {
+//         method: "PUT",
+//         headers: {
+//             "JOB-TOKEN": CI_JOB_TOKEN,
+//         },
+//         body: await fs.readFile(filePath),
+//     });
+
+//     if (!response.ok) {
+//         throw new Error(
+//             `${response.status} ${response.statusText}\n${await response.text()}`
+//         );
+//     }
+
+//     console.log(`✓ Uploaded ${fileName}`);
+// }
+
+async function main() {
+    const entries = await fs.readdir(latestDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        if (!entry.isFile()) {
+            continue;
+        }
+
+        await uploadFile(path.join(latestDir, entry.name));
+    }
+
+    console.log("All latest metadata uploaded.");
+}
+
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});