@idajs/create-mod 0.2.15-dev.19 → 0.2.15-dev.37

package/README.md

@@ -24,6 +24,12 @@ npx @idajs/create-mod
 
 The tool will guide you through the setup process with interactive prompts.
 
+Refresh scaffolder-managed files in an existing mod project:
+
+```pwsh
+npx @idajs/create-mod --update
+```
+
 ## Usage
 
 ```pwsh

package/_project.config/archive.js

@@ -0,0 +1,107 @@
+const fs = require("fs");
+const path = require("path");
+const yazl = require("yazl");
+
+function normalizeZipPath(value) {
+  return String(value || "")
+    .split(path.sep)
+    .join("/")
+    .replace(/\/+/g, "/")
+    .replace(/^\/+/, "")
+    .replace(/\/+$/, "");
+}
+
+async function collectDirectoryEntries(sourceDir, zipRoot) {
+  const dirents = await fs.promises.readdir(sourceDir, { withFileTypes: true });
+  const sortedDirents = dirents.slice().sort((a, b) => a.name.localeCompare(b.name));
+  const entries = [];
+
+  if (sortedDirents.length === 0 && zipRoot) {
+    entries.push({
+      type: "directory",
+      metadataPath: normalizeZipPath(zipRoot),
+    });
+  }
+
+  for (const dirent of sortedDirents) {
+    const sourcePath = path.join(sourceDir, dirent.name);
+    const metadataPath = normalizeZipPath(path.posix.join(zipRoot, dirent.name));
+
+    if (dirent.isDirectory()) {
+      entries.push(...(await collectDirectoryEntries(sourcePath, metadataPath)));
+      continue;
+    }
+
+    if (dirent.isFile()) {
+      entries.push({
+        type: "file",
+        sourcePath,
+        metadataPath,
+      });
+      continue;
+    }
+
+    throw new Error(`Unsupported entry type in archive source: ${sourcePath}`);
+  }
+
+  return entries;
+}
+
+async function createZipFromDirectories(zipPath, mappings, options = {}) {
+  const zipfile = new yazl.ZipFile();
+  const output = fs.createWriteStream(zipPath);
+  const zipOptions = {};
+
+  if (typeof options.compressionLevel === "number") {
+    zipOptions.compressionLevel = options.compressionLevel;
+  }
+
+  const collectedEntries = [];
+  for (const mapping of mappings) {
+    if (!fs.existsSync(mapping.sourceDir)) {
+      throw new Error(`Source directory not found: ${mapping.sourceDir}`);
+    }
+
+    collectedEntries.push(...(await collectDirectoryEntries(mapping.sourceDir, mapping.zipRoot)));
+  }
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+
+    function finish(error) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    }
+
+    output.on("close", () => finish());
+    output.on("error", finish);
+    zipfile.outputStream.on("error", finish);
+
+    zipfile.outputStream.pipe(output);
+
+    try {
+      for (const entry of collectedEntries) {
+        if (entry.type === "directory") {
+          zipfile.addEmptyDirectory(entry.metadataPath);
+        } else {
+          zipfile.addFile(entry.sourcePath, entry.metadataPath, zipOptions);
+        }
+      }
+
+      zipfile.end();
+    } catch (error) {
+      finish(error);
+    }
+  });
+}
+
+module.exports = {
+  createZipFromDirectories,
+};

package/_project.config/build.js

@@ -1,14 +1,15 @@
 const { execSync } = require("child_process");
 const path = require("path");
 const fs = require("fs");
-const archiver = require("archiver");
+const { createZipFromDirectories } = require("./archive");
+const { getPackageName } = require("./project");
 
 // Get mod name from command line argument
-const modName = process.argv[2];
+const modName = process.argv[2] || getPackageName();
 
 if (!modName) {
   console.error("Error: Mod name is required as an argument");
-  console.error("Usage: node build.js <mod-name>");
+  console.error("Usage: node build.js [mod-name]");
   process.exit(1);
 }
 
@@ -61,47 +62,31 @@ if (!fs.existsSync(buildFolder)) {
 
 // Create zip file
 const zipPath = path.join(buildFolder, `${modName}.zip`);
-const output = fs.createWriteStream(zipPath);
-const archive = archiver("zip", {
-  zlib: { level: 9 }, // Maximum compression
-});
 
-console.log(`Creating ${zipPath}...`);
+async function main() {
+  console.log(`Creating ${zipPath}...`);
 
-// Handle archive events
-output.on("close", () => {
-  const sizeInKB = (archive.pointer() / 1024).toFixed(2);
-  console.log(`✓ Build complete: ${zipPath} (${sizeInKB} KB)`);
-});
+  const mappings = [{ sourceDir: sourceFolder, zipRoot: modName }];
 
-archive.on("error", (err) => {
-  console.error("Error creating archive:", err);
-  process.exit(1);
-});
+  console.log(`Adding ${sourceFolder}/ → ${modName}/`);
 
-archive.on("warning", (err) => {
-  if (err.code === "ENOENT") {
-    console.warn("Warning:", err);
+  const mediaFolder = "media";
+  if (fs.existsSync(mediaFolder)) {
+    console.log(`Adding ${mediaFolder}/ → ${modName}/media/`);
+    mappings.push({ sourceDir: mediaFolder, zipRoot: `${modName}/media` });
   } else {
-    throw err;
+    console.log("No media folder found, skipping");
   }
-});
-
-// Pipe archive data to the file
-archive.pipe(output);
 
-// Add source folder contents to zip under modName directory
-console.log(`Adding ${sourceFolder}/ → ${modName}/`);
-archive.directory(sourceFolder, modName);
+  await createZipFromDirectories(zipPath, mappings, {
+    compressionLevel: 9,
+  });
 
-// Add media folder if it exists
-const mediaFolder = "media";
-if (fs.existsSync(mediaFolder)) {
-  console.log(`Adding ${mediaFolder}/ → ${modName}/media/`);
-  archive.directory(mediaFolder, `${modName}/media`);
-} else {
-  console.log("No media folder found, skipping");
+  const sizeInKB = (fs.statSync(zipPath).size / 1024).toFixed(2);
+  console.log(`✓ Build complete: ${zipPath} (${sizeInKB} KB)`);
 }
 
-// Finalize the archive
-archive.finalize();
+main().catch((error) => {
+  console.error("Error creating archive:", error);
+  process.exit(1);
+});

package/_project.config/package.template.json

@@ -6,14 +6,14 @@
     "watch": "node watch.js",
     "sync": "node sync.js",
     "start": "node start.js",
-    "build": "node build.js %npm_package_name%",
+    "build": "node build.js",
     "update:types": "npm update @idajs/types"
   },
-  "devDependencies": {
-    "archiver": "^7.0.1",
-    "chokidar-cli": "^3.0.0",
-    "@idajs/types": "^0.2.0",
-    "@idajs/sync": "^1.1.0",
+  "devDependencies": {
+    "yazl": "^3.3.1",
+    "chokidar-cli": "^3.0.0",
+    "@idajs/types": "^0.2.0",
+    "@idajs/sync": "^1.1.0",
     "typescript": "^5.9.3"
   }
 }

package/_project.config/remote.js

@@ -1,10 +1,10 @@
-const archiver = require("archiver");
 const fs = require("fs");
 const http = require("http");
 const https = require("https");
 const path = require("path");
 const { spawn } = require("child_process");
 
+const { createZipFromDirectories } = require("./archive");
 const { getPackageName } = require("./project");
 
 function runNodeScript(scriptName, args = []) {
@@ -27,25 +27,11 @@ function runNodeScript(scriptName, args = []) {
 }
 
 function createZip(zipPath, sourceDir, rootName) {
-  return new Promise((resolve, reject) => {
-    const output = fs.createWriteStream(zipPath);
-    const archive = archiver("zip", {
-      store: true,
-    });
-
-    output.on("close", resolve);
-    output.on("error", reject);
-    archive.on("error", reject);
-    archive.on("warning", (error) => {
-      if (error.code !== "ENOENT") {
-        reject(error);
-      }
-    });
-
-    archive.pipe(output);
-    archive.directory(sourceDir, rootName);
-    archive.finalize();
-  });
+  return createZipFromDirectories(
+    zipPath,
+    [{ sourceDir, zipRoot: rootName }],
+    { compressionLevel: 0 }
+  );
 }
 
 function request(server, method, requestPath, body, headers = {}) {

package/index.js

@@ -4,6 +4,7 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 const { execSync } = require("child_process");
+const readline = require("readline");
 const IdaSync = require("@idajs/sync");
 
 // Parse command line arguments
@@ -26,7 +27,9 @@ const idajsDir = getArgValue("--idajs-dir") || getArgValue("--idajs");
 const useTypeScript = args.includes("--typescript") || args.includes("--ts");
 const useJavaScript = args.includes("--javascript") || args.includes("--js");
 const skipInstall = args.includes("--skip-install");
+const updateMode = args.includes("--update");
 const helpRequested = args.includes("--help") || args.includes("-h");
+const requiredUpdatePackages = ["@idajs/types", "@idajs/sync"];
 
 // Show help if requested
 if (helpRequested) {
@@ -41,7 +44,8 @@ Options:
   --idajs-dir, --idajs <path>     IdaJS installation directory
   --typescript, --ts              Use TypeScript
   --javascript, --js              Use JavaScript
-  --skip-install                  Skip npm install
+  --update                        Refresh scaffolder-managed files in the current mod folder
+  --skip-install                  Skip npm install (and type update in --update mode)
   -h, --help                      Show this help message
 
 Examples:
@@ -50,6 +54,7 @@ Examples:
   npx @idajs/create-mod my-mod --typescript
   npx @idajs/create-mod my-mod --dir ./projects/my-mod --idajs C:/Projects/idajs --js
   npx @idajs/create-mod my-mod --skip-install
+  npx @idajs/create-mod --update
 `);
   process.exit(0);
 }
@@ -101,9 +106,93 @@ function parseIdaConnection(value) {
   };
 }
 
+function loadJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new Error(`Failed to parse JSON file: ${filePath}`);
+  }
+}
+
+function isInteractiveTerminal() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function askYesNo(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.question(question, (answer) => {
+      rl.close();
+      const normalized = String(answer || "").trim().toLowerCase();
+      resolve(normalized === "y" || normalized === "yes");
+    });
+  });
+}
+
+async function runUpdateMode() {
+  const targetDir = process.cwd();
+  const packageJsonPath = path.join(targetDir, "package.json");
+
+  if (!fs.existsSync(packageJsonPath)) {
+    console.error(`\n❌ Error: No package.json found in ${targetDir}`);
+    console.error("Run this command from inside an existing IdaJS mod folder.");
+    process.exit(1);
+  }
+
+  const packageJson = loadJson(packageJsonPath);
+  const devDependencies = packageJson.devDependencies || {};
+  const missingPackages = requiredUpdatePackages.filter((name) => !devDependencies[name]);
+
+  if (missingPackages.length > 0) {
+    console.warn(
+      `\n⚠️  Warning: Missing IdaJS devDependencies: ${missingPackages.join(", ")}.`
+    );
+    console.warn("This may not be an IdaJS mod, or the project may differ significantly from the scaffold.");
+
+    if (!isInteractiveTerminal()) {
+      console.error("\n❌ Error: Confirmation required. Rerun this command in an interactive terminal to continue.");
+      process.exit(1);
+    }
+
+    const confirmed = await askYesNo("Continue with scaffolder update? [y/N] ");
+    if (!confirmed) {
+      console.log("\nUpdate cancelled.");
+      process.exit(1);
+    }
+  }
+
+  console.log(`\nUpdating IdaJS mod in ${targetDir}...`);
+
+  const installScript = path.join(__dirname, "install.js");
+  const installArgs = [installScript, targetDir, "--update"];
+
+  if (skipInstall) {
+    installArgs.push("--skip-install");
+  }
+
+  try {
+    execSync(`node ${installArgs.map((arg) => `"${arg}"`).join(" ")}`, {
+      stdio: "inherit",
+    });
+    console.log("\n✅ Scaffolder update completed successfully.");
+  } catch (error) {
+    console.error(`\n❌ Error updating project: ${error.message}`);
+    process.exit(1);
+  }
+}
+
 async function main() {
   console.log("Welcome to IdaJS Mod Creator!\n");
 
+  if (updateMode) {
+    await runUpdateMode();
+    return;
+  }
+
   // Determine if we need prompts
   const needsPrompts =
     !projectName || (!useTypeScript && !useJavaScript) || (!idajsDir && !getIdaJsDirFromConfig());

package/install.js

@@ -2,12 +2,13 @@
 
 const fs = require("fs");
 const path = require("path");
-const { exec } = require("child_process");
+const { exec, execSync } = require("child_process");
 
 // Get configuration from arguments or defaults
 const args = process.argv.slice(2);
 const targetDirArg = args.find((arg) => !arg.startsWith("--"));
 const skipInstall = args.includes("--skip-install");
+const updateMode = args.includes("--update");
 const idaRootArg = args.find((arg) => arg.startsWith("--ida-root="));
 
 // Get the directory where this script was called from or use provided argument
@@ -30,48 +31,34 @@ const isTypeScriptProject = (() => {
   const files = fs.readdirSync(srcDir);
   return files.some((file) => file.endsWith(".ts"));
 })();
-
-console.log(`Installing development environment in: ${targetDir}`);
+const protectedUpdateFields = new Set([
+  "name",
+  "description",
+  "version",
+  "author",
+  "private",
+  "license",
+]);
+const obsoleteScaffolderDevDependencies = ["archiver"];
+
+console.log(`${updateMode ? "Updating" : "Installing"} development environment in: ${targetDir}`);
 if (idaRoot) {
   console.log(`Ida root: ${idaRoot}`);
 } else {
   console.log(`Running in standalone mode`);
 }
 
-// Step 1: Merge package.template.json files to create package.json
-function mergePackageJson() {
-  const packagePath = path.join(targetDir, "package.json");
-  const globalTemplatePath = path.join(configDir, "package.template.json");
-  const sampleTemplatePath = path.join(targetDir, "package.template.json");
-
-  if (!fs.existsSync(globalTemplatePath)) {
-    console.error("Error: package.template.json not found in config directory");
-    process.exit(1);
-  }
-
-  if (!fs.existsSync(sampleTemplatePath)) {
-    console.error("Error: package.template.json not found in sample directory");
-    process.exit(1);
-  }
-
-  console.log("Merging package.template.json files to create package.json...");
-
-  // Start with global template
-  const packageJson = JSON.parse(fs.readFileSync(globalTemplatePath, "utf8"));
-  const sampleTemplate = JSON.parse(fs.readFileSync(sampleTemplatePath, "utf8"));
-
-  // Get version from version.js or package.json (standalone mode)
+function getPackageVersion() {
   let version = null;
+
   if (versionScriptPath && fs.existsSync(versionScriptPath)) {
     try {
-      const { execSync } = require("child_process");
       version = execSync(`node "${versionScriptPath}"`, { encoding: "utf8" }).trim();
       console.log(`Using version from version.js: ${version}`);
     } catch (error) {
       console.warn("Warning: Could not read version from version.js");
     }
   } else {
-    // Standalone mode: get version from package.json in the same directory as this script
     const localPackagePath = path.join(__dirname, "package.json");
     if (fs.existsSync(localPackagePath)) {
       try {
@@ -84,7 +71,51 @@ function mergePackageJson() {
     }
   }
 
-  // Set version if available
+  return version;
+}
+
+function orderPackageJson(packageJson) {
+  const orderedPackageJson = {};
+  const propertyOrder = ["name", "description", "version", "author", "license", "private", "scripts"];
+
+  propertyOrder.forEach((key) => {
+    if (packageJson[key] !== undefined) {
+      orderedPackageJson[key] = packageJson[key];
+    }
+  });
+
+  Object.keys(packageJson).forEach((key) => {
+    if (!propertyOrder.includes(key)) {
+      orderedPackageJson[key] = packageJson[key];
+    }
+  });
+
+  return orderedPackageJson;
+}
+
+// Step 1: Merge package.template.json files to create package.json
+function mergePackageJsonForCreate() {
+  const packagePath = path.join(targetDir, "package.json");
+  const globalTemplatePath = path.join(configDir, "package.template.json");
+  const sampleTemplatePath = path.join(targetDir, "package.template.json");
+
+  if (!fs.existsSync(globalTemplatePath)) {
+    console.error("Error: package.template.json not found in config directory");
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(sampleTemplatePath)) {
+    console.error("Error: package.template.json not found in sample directory");
+    process.exit(1);
+  }
+
+  console.log("Merging package.template.json files to create package.json...");
+
+  // Start with global template
+  const packageJson = JSON.parse(fs.readFileSync(globalTemplatePath, "utf8"));
+  const sampleTemplate = JSON.parse(fs.readFileSync(sampleTemplatePath, "utf8"));
+
+  const version = getPackageVersion();
   if (version) {
     packageJson.version = version;
   }
@@ -116,31 +147,71 @@ function mergePackageJson() {
     packageJson.dependencies = { ...packageJson.dependencies, ...sampleTemplate.dependencies };
   }
 
-  // Reorder properties to ensure consistent ordering
-  const orderedPackageJson = {};
-  const propertyOrder = ["name", "description", "version", "author", "private", "scripts"];
+  fs.writeFileSync(packagePath, JSON.stringify(orderPackageJson(packageJson), null, 2) + "\n");
+  console.log("✓ Package.json created successfully");
+}
 
-  // Add properties in the specified order
-  propertyOrder.forEach((key) => {
-    if (packageJson[key] !== undefined) {
-      orderedPackageJson[key] = packageJson[key];
+function mergePackageJsonForUpdate() {
+  const packagePath = path.join(targetDir, "package.json");
+  const globalTemplatePath = path.join(configDir, "package.template.json");
+
+  if (!fs.existsSync(globalTemplatePath)) {
+    console.error("Error: package.template.json not found in config directory");
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(packagePath)) {
+    console.error("Error: package.json not found in target directory");
+    process.exit(1);
+  }
+
+  console.log("Refreshing package.json from scaffolder template...");
+
+  const existingPackageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+  const configTemplate = JSON.parse(fs.readFileSync(globalTemplatePath, "utf8"));
+  const packageJson = { ...existingPackageJson };
+  const existingDevDependencies = existingPackageJson.devDependencies || {};
+
+  Object.entries(configTemplate).forEach(([key, value]) => {
+    if (protectedUpdateFields.has(key)) {
+      return;
     }
-  });
 
-  // Add all remaining properties
-  Object.keys(packageJson).forEach((key) => {
-    if (!propertyOrder.includes(key)) {
-      orderedPackageJson[key] = packageJson[key];
+    if (key === "scripts" || key === "devDependencies") {
+      const templateValue = { ...value };
+
+      if (
+        key === "devDependencies" &&
+        !isTypeScriptProject &&
+        !Object.prototype.hasOwnProperty.call(existingDevDependencies, "typescript")
+      ) {
+        delete templateValue.typescript;
+      }
+
+      packageJson[key] = {
+        ...(existingPackageJson[key] || {}),
+        ...templateValue,
+      };
+      return;
     }
+
+    packageJson[key] = value;
   });
 
-  fs.writeFileSync(packagePath, JSON.stringify(orderedPackageJson, null, 2) + "\n");
-  console.log("✓ Package.json created successfully");
+  if (packageJson.devDependencies) {
+    obsoleteScaffolderDevDependencies.forEach((dependency) => {
+      delete packageJson.devDependencies[dependency];
+    });
+  }
+
+  fs.writeFileSync(packagePath, JSON.stringify(orderPackageJson(packageJson), null, 2) + "\n");
+  console.log("✓ Package.json refreshed successfully");
 }
 
 // Step 2: Copy necessary files
 function copyFiles() {
   const filesToCopy = [
+    { source: "archive.js" },
     { source: "project.js" },
     { source: "remote.js" },
     { source: "run.ps1" },
@@ -204,11 +275,49 @@ function runNpmInstall() {
   npmProcess.stderr.pipe(process.stderr);
 }
 
+function runCommand(command, errorMessage) {
+  try {
+    execSync(command, {
+      cwd: targetDir,
+      stdio: "inherit",
+    });
+  } catch (error) {
+    console.error(errorMessage);
+    process.exit(1);
+  }
+}
+
+function runUpdatePostInstall() {
+  if (skipInstall) {
+    console.log("\nSkipped npm install and update:types");
+    console.log("\nInfrastructure update complete.");
+    return;
+  }
+
+  console.log("Running npm install...");
+  runCommand("npm install", "Error running npm install");
+  console.log("✓ npm install completed successfully");
+
+  console.log("Running npm run update:types...");
+  runCommand(
+    "npm run update:types",
+    "Error running npm run update:types. Infrastructure refresh and npm install already completed."
+  );
+  console.log("✓ npm run update:types completed successfully");
+  console.log("\nInfrastructure update complete! You can now use the refreshed development scripts.");
+}
+
 // Main execution
 try {
-  mergePackageJson();
+  if (updateMode) {
+    mergePackageJsonForUpdate();
+  } else {
+    mergePackageJsonForCreate();
+  }
   copyFiles();
-  if (!skipInstall) {
+  if (updateMode) {
+    runUpdatePostInstall();
+  } else if (!skipInstall) {
     runNpmInstall();
   } else {
     console.log("\nSkipped npm install");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idajs/create-mod",
-  "version": "0.2.15-dev.19",
+  "version": "0.2.15-dev.37",
   "description": "Scaffolding tool for creating IdaJS game mods for Little Big Adventure 2. Use with: npx @idajs/create-mod",
   "author": "Andriy Tevelyev",
   "license": "GPL-2.0",