st-registry-cli 1.0.0 → 1.4.0

package/.github/workflows/release.yml

@@ -1,21 +1,34 @@
-name: Publish Package to npmjs
+name: Publish Package
+
 on:
-  release:
-    types: [published]
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  id-token: write  # This is the "key" for Trusted Publishing
+  contents: read
+
 jobs:
-  build:
+  publish:
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
     steps:
-      - uses: actions/checkout@v5
-      # Setup .npmrc file to publish to npm
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@v6 # Updated version as per your docs
+
+      - uses: actions/setup-node@v6
         with:
-          node-version: '20.x'
-          registry-url: 'https://registry.npmjs.org'
+          node-version: '24'
+          # CRITICAL: Do NOT include registry-url here. 
+          # It forces npm to look for a secret token you don't have.
+
       - run: npm ci
-      - run: npm publish --provenance --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      
+      - name: Update Version
+        run: |
+          # Strip 'v' from tag (e.g. v1.3.0 -> 1.3.0)
+          CLEAN_VERSION=$(echo "${{ github.ref_name }}" | sed 's/^v//')
+          npm version $CLEAN_VERSION --no-git-tag-version
+
+      # The --provenance flag tells npm: 
+      # "Don't look for a token. Use my GitHub OIDC identity instead."
+      - run: npm publish --provenance --access public

package/chore/updatePackage.js

@@ -0,0 +1,22 @@
+import p from "../package.json" assert { type: "json" };
+import fs from "fs";
+import { program } from "commander";
+
+let packageData = p;
+
+program.argument("<version>", "New version to set in package.json");
+
+program.parse();
+
+const version = program.args[0];
+
+if (!version) {
+    console.error("Please provide a version.");
+    process.exit(1);
+}
+
+packageData.version = version.replace(/^v/, ""); // Remove leading 'v' if present
+
+fs.writeFileSync("package.json", JSON.stringify(packageData, null, 2));
+
+console.log(`Updated package.json to version ${version}`);

package/index.js

@@ -2,63 +2,54 @@
 import { program } from "commander";
 import chalk from "chalk";
 import { download } from "./download.js";
+import fetch from "node-fetch";
+import fs from "fs";
+import path from "path";
 
+// --- INSTALL COMMAND (For individual downloads) ---
 program
     .command("install <name> [destination] [version]")
     .description("Downloads package")
     .action(async function (name, destination, version) {
         try {
-            // 1. Fetch the registry
             const response = await fetch("https://stoppedwumm-studios.github.io/st-registry/index.json");
             const modulesData = await response.json();
             const modules = modulesData.modules;
 
-            // 2. Find the module (Case-insensitive)
-            const moduleKey = Object.keys(modules).find(key => 
-                modules[key].name.toLowerCase() === name.toLowerCase()
+            const module = modules.find(m => 
+                m.name.toLowerCase() === name.toLowerCase()
             );
 
-            if (!moduleKey) {
+            if (!module) {
                 console.error(chalk.red(`Module "${name}" not found in registry.`));
                 return;
             }
 
-            const module = modules[moduleKey];
             const mjson = await (await fetch(module["url"])).json();
             console.log("Found module under path:", chalk.bold(module["path"]));
 
-            // 3. Determine which version to use
             let selectedVersion;
-
             if (Array.isArray(mjson["url"])) {
                 if (version) {
-                    // Find specific version
                     selectedVersion = mjson["url"].find(v => 
                         v.versionRule.toLowerCase() === version.toLowerCase()
                     );
                 } else {
-                    // Default to the first one if no version specified
                     selectedVersion = mjson["url"][0];
                 }
             } else if (typeof mjson["url"] === "string") {
-                // Handle cases where "url" might just be a string instead of an array
                 selectedVersion = { url: mjson["url"] };
             }
 
-            // 4. Execute download
             if (selectedVersion) {
                 const downloadUrl = selectedVersion.url;
-                
-                // Determine extension logic
                 const extension = downloadUrl.includes("zipball")
                     ? ".zip"
-                    : "." + downloadUrl.split(".").at(-1);
+                    : "." + downloadUrl.split(".").at(-1).split('?')[0];
 
                 const finalDestination = destination || (module["name"] + extension);
 
                 console.log(chalk.blue(`Downloading to ${finalDestination}...`));
-                
-                // Note: If download is async, you should probably 'await' it
                 await download(downloadUrl, finalDestination);
                 console.log(chalk.green("Download complete!"));
             } else {
@@ -70,4 +61,84 @@ program
         }
     });
 
+// --- CLONE COMMAND (Downloads everything using registry paths) ---
+program
+    .command("clone")
+    .description("Clones the entire registry using defined paths and all versions")
+    .action(async function () {
+        try {
+            console.log(chalk.cyan("Fetching registry..."));
+            const response = await fetch("https://stoppedwumm-studios.github.io/st-registry/index.json");
+            const modulesData = await response.json();
+            const modules = modulesData.modules;
+
+            for (const module of modules) {
+                console.log(chalk.yellow(`\nProcessing module: ${module.name}`));
+                
+                const mjson = await (await fetch(module.url)).json();
+                
+                // Create the directory based on the "path" key (e.g., "m/minecraft")
+                const targetDir = module.path;
+                if (!fs.existsSync(targetDir)) {
+                    fs.mkdirSync(targetDir, { recursive: true });
+                }
+
+                // Handle modules that have multiple versions
+                const versions = Array.isArray(mjson.url) 
+                    ? mjson.url 
+                    : [{ versionRule: "latest", url: mjson.url }];
+
+                for (const v of versions) {
+                    const downloadUrl = v.url;
+                    const versionName = v.versionRule || "default";
+                    
+                    // --- SMART EXTENSION DETECTION ---
+                    const urlObj = new URL(downloadUrl);
+                    const lastSegment = urlObj.pathname.split('/').pop();
+                    
+                    let extension = "";
+                    const commonExts = ['zip', 'jar', 'exe', 'msi', 'dmg', 'json', 'apk', 'tar', 'gz', '7z'];
+
+                    if (downloadUrl.includes("zipball") || downloadUrl.includes("/zip/")) {
+                        extension = ".zip";
+                    } else if (lastSegment.includes(".")) {
+                        const parts = lastSegment.split('.');
+                        const potentialExt = parts.pop().toLowerCase();
+                        
+                        // Check if it's a real extension or just a version number (like .1)
+                        if (commonExts.includes(potentialExt) || isNaN(potentialExt)) {
+                            extension = "." + potentialExt;
+                        }
+                    }
+
+                    // --- FALLBACK GUESSING ---
+                    // If no extension found, check for keywords in the URL
+                    if (!extension) {
+                        if (downloadUrl.toLowerCase().includes("installer")) extension = ".exe";
+                        else if (downloadUrl.toLowerCase().includes("mac") || downloadUrl.toLowerCase().includes("osx")) extension = ".dmg";
+                        else if (downloadUrl.toLowerCase().includes("json")) extension = ".json";
+                    }
+
+                    // Sanitize version name (remove slashes) to keep files inside the module folder
+                    const safeVersionName = versionName.replace(/[/\\?%*:|"<>]/g, '-');
+                    const fileName = `${module.name}-${safeVersionName}${extension}`;
+                    
+                    const finalDestination = path.join(targetDir, fileName);
+
+                    console.log(chalk.blue(`  -> Downloading version [${versionName}] to ${finalDestination}...`));
+                    
+                    try {
+                        await download(downloadUrl, finalDestination);
+                    } catch (dlErr) {
+                        console.error(chalk.red(`  Failed to download ${versionName}:`), dlErr.message);
+                    }
+                }
+                console.log(chalk.green(`Successfully processed all versions for ${module.name}`));
+            }
+            console.log(chalk.bold.green("\nRegistry cloning complete!"));
+        } catch (error) {
+            console.error(chalk.red("An error occurred during cloning:"), error.message);
+        }
+    });
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "st-registry-cli",
-  "version": "1.0.0",
+  "version": "1.4.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -12,9 +12,13 @@
   "type": "module",
   "dependencies": {
     "chalk": "^5.6.2",
-    "commander": "^14.0.3"
+    "commander": "^14.0.3",
+    "node-fetch": "^3.3.2"
   },
-  "bin":{
+  "bin": {
     "spm": "index.js"
+  },
+  "repository": {
+    "url": "Stoppedwumm-Studios/spm"
   }
 }