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

package/_project.config/sync.js

@@ -1,88 +1,50 @@
 const { execSync } = require("child_process");
 const path = require("path");
 const fs = require("fs");
-const os = require("os");
 
-// Function to read IdaJS installation directory from .idajs.json
-function getIdaJsPath() {
-  // Try local config first, then user home config
-  const configPaths = [path.join(__dirname, ".idajs.json"), path.join(os.homedir(), ".idajs.json")];
+const { getArgValue, getIdaJsPath, getPackageName, isTypeScriptProject } = require("./project");
 
-  for (const configPath of configPaths) {
-    if (fs.existsSync(configPath)) {
-      try {
-        const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-        if (config.installDir) {
-          return config.installDir;
-        }
-      } catch (err) {
-        // Ignore parse errors and try next config
-      }
-    }
-  }
-
-  return null;
-}
-
-// Get package name from command line argument
-const packageName = process.argv[2];
-
-if (!packageName) {
-  console.error("Error: Package name is required as an argument");
-  console.error("Usage: node sync.js <package-name>");
-  process.exit(1);
-}
+const args = process.argv.slice(2);
+const packageName = getPackageName();
+const targetRoot = getArgValue("--target-root", args);
 
-// Get IdaJS installation path
-const idaJsPath = getIdaJsPath();
-if (!idaJsPath) {
-  console.error("Error: .idajs.json not found in current directory or user home directory.");
-  console.error("Please build IdaJS first or create .idajs.json with 'installDir' property.");
-  process.exit(1);
-}
+let resolvedTargetRoot = targetRoot;
+const typeScriptProject = isTypeScriptProject();
+if (!resolvedTargetRoot) {
+  const idaJsPath = getIdaJsPath();
 
-if (!fs.existsSync(idaJsPath)) {
-  console.error(`Error: IdaJS installation directory does not exist: ${idaJsPath}`);
-  console.error("Please build IdaJS first.");
-  process.exit(1);
-}
-
-const isTypeScriptProject = (() => {
-  // Check if tsconfig.json exists
-  if (!fs.existsSync("tsconfig.json")) {
-    return false;
+  if (!idaJsPath) {
+    console.error("Error: .idajs.json not found in current directory or user home directory.");
+    console.error("Please build IdaJS first or create .idajs.json with 'installDir' property.");
+    process.exit(1);
   }
 
-  // Check if there are any .ts files in src/
-  if (!fs.existsSync("src")) {
-    return false;
+  if (!fs.existsSync(idaJsPath)) {
+    console.error(`Error: IdaJS installation directory does not exist: ${idaJsPath}`);
+    console.error("Please build IdaJS first.");
+    process.exit(1);
   }
 
-  const files = fs.readdirSync("src");
-  return files.some((file) => file.endsWith(".ts"));
-})();
+  resolvedTargetRoot = path.join(idaJsPath, "GameRun", "mods");
+}
 
-const targetBase = path.join(idaJsPath, "GameRun", "mods", packageName);
+const targetBase = path.join(resolvedTargetRoot, packageName);
 const deleteExcludeArgs = '--delete-exclude "*.ida" --delete-exclude "*.md5"';
 
 console.log(`Syncing ${packageName}...`);
 
-// If TypeScript project, compile first
-if (isTypeScriptProject) {
+if (typeScriptProject) {
   console.log("TypeScript project detected, compiling...");
 
-  // Clean dist folder
   if (fs.existsSync("dist")) {
     console.log("Cleaning dist folder...");
     fs.rmSync("dist", { recursive: true, force: true });
   }
 
-  // Compile TypeScript
   execSync("tsc", { stdio: "inherit" });
   console.log("Compilation complete!");
 }
 
-// Sync media folder if it exists
 if (fs.existsSync("media")) {
   const mediaSyncCmd = `idasync media "${path.join(targetBase, "media")}" ${deleteExcludeArgs}`;
   console.log(`Running: ${mediaSyncCmd}`);
@@ -91,8 +53,7 @@ if (fs.existsSync("media")) {
   console.log("No media folder found, skipping media sync");
 }
 
-// Sync src folder
-const sourceFolder = isTypeScriptProject ? "dist" : "src";
+const sourceFolder = typeScriptProject ? "dist" : "src";
 const srcSyncCmd = `idasync "${sourceFolder}" "${targetBase}" ${deleteExcludeArgs} --delete-exclude "media/*"`;
 console.log(`Running: ${srcSyncCmd}`);
 execSync(srcSyncCmd, { stdio: "inherit" });

package/_project.config/watch.js

@@ -1,54 +1,121 @@
 /**
- * Watches for file changes in the src/ and media/ directories
- * and runs the sync script to copy changed files to the game mod directory.
- * Exits when the LBA2.exe process is no longer running.
+ * Watches for file changes in the src/ and media/ directories.
+ * Local mode syncs directly into the game mod directory.
+ * Remote mode stages the mod into a session temp folder and uploads a full zip.
  */
 
 const chokidar = require("chokidar");
-const { spawn, exec } = require("child_process");
+const { exec } = require("child_process");
 const { promisify } = require("util");
 
+const { getArgValue, parseServerAddress } = require("./project");
+const { getRemoteGameStatus, killRemoteGame, stageAndZip, stageMod, uploadMod } = require("./remote");
+
 const execAsync = promisify(exec);
 const PROC_NAME = "LBA2.exe";
+const args = process.argv.slice(2);
+const serverArg = getArgValue("--server", args);
+const sessionRoot = getArgValue("--session-root", args);
+const server = serverArg ? parseServerAddress(serverArg) : null;
+
+if (server && !sessionRoot) {
+  console.error("Remote watch mode requires --session-root <path>.");
+  process.exit(1);
+}
+
+let syncing = false;
+let syncQueued = false;
 
-let syncing = null;
-function runSync() {
-  if (syncing) return; // prevent overlapping syncs
-  syncing = spawn("npm", ["run", "sync"], { stdio: "inherit", shell: true });
-  syncing.on("exit", () => (syncing = null));
+async function runLocalSync() {
+  if (syncing) {
+    syncQueued = true;
+    return;
+  }
+
+  syncing = true;
+  do {
+    syncQueued = false;
+    try {
+      await stageMod();
+    } catch (error) {
+      console.error(error.message);
+    }
+  } while (syncQueued);
+  syncing = false;
 }
 
-const watcher = chokidar.watch(["src/**/*.js", "media/**/*.png"], {
+async function runRemoteSync() {
+  if (syncing) {
+    syncQueued = true;
+    return;
+  }
+
+  syncing = true;
+  do {
+    syncQueued = false;
+    try {
+      const { modName, zipPath } = await stageAndZip(sessionRoot);
+      await uploadMod(server, modName, zipPath);
+    } catch (error) {
+      console.error(error.message);
+    }
+  } while (syncQueued);
+  syncing = false;
+}
+
+const watcher = chokidar.watch(["src/**/*.js", "src/**/*.ts", "media/**/*.png"], {
   ignoreInitial: true,
 });
 
-watcher.on("all", () => runSync());
+watcher.on("all", async () => {
+  if (server) {
+    await runRemoteSync();
+    return;
+  }
 
-async function isProcRunning() {
+  await runLocalSync();
+});
+
+async function isLocalProcRunning() {
   try {
     const { stdout } = await execAsync(
-      `powershell -Command "Get-Process | Where-Object {$_.ProcessName -eq '${PROC_NAME.replace(".exe", "")}'} | Select-Object -First 1"`,
+      `tasklist /FI "IMAGENAME eq ${PROC_NAME}" /FO CSV /NH`,
       {
         timeout: 5000,
       }
     );
-    return stdout.trim().length > 0;
+    return stdout.toLowerCase().includes(`"${PROC_NAME.toLowerCase()}"`);
   } catch (error) {
-    // Process not found or command failed
     return false;
   }
 }
 
-async function killGameProc() {
+async function killLocalGameProc() {
   try {
-    await execAsync(
-      `powershell -Command "Stop-Process -Name '${PROC_NAME.replace(".exe", "")}' -Force -ErrorAction SilentlyContinue"`
-    );
-  } catch (e) {
-    // Process may already be stopped
+    await execAsync(`taskkill /IM "${PROC_NAME}" /F /T`);
+  } catch (error) {
+    // Process may already be stopped.
   }
 }
 
+async function isProcRunning() {
+  if (server) {
+    const status = await getRemoteGameStatus(server);
+    return Boolean(status && status.running);
+  }
+
+  return isLocalProcRunning();
+}
+
+async function killGameProc() {
+  if (server) {
+    await killRemoteGame(server);
+    return;
+  }
+
+  await killLocalGameProc();
+}
+
 const interval = setInterval(async () => {
   try {
     const alive = await isProcRunning();
@@ -59,12 +126,11 @@ const interval = setInterval(async () => {
       await watcher.close();
       process.exit(0);
     }
-  } catch (e) {
-    // if process listing fails, you can decide to ignore or stop
+  } catch (error) {
+    console.error(error.message);
   }
 }, 1000);
 
-// Ctrl+C cleanup
 process.on("SIGINT", async () => {
   console.log("Caught interrupt signal. Exiting watcher.");
 

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);
 }
@@ -70,9 +75,124 @@ function getIdaJsDirFromConfig() {
   return null;
 }
 
+function normalizeServerAddress(value) {
+  const trimmed = String(value || "").trim();
+  const input = trimmed.includes("://") ? trimmed : `http://${trimmed}`;
+  const url = new URL(input);
+  return `${url.hostname}:${url.port || 7770}`;
+}
+
+function parseIdaConnection(value) {
+  const trimmed = String(value || "").trim();
+
+  if (!trimmed) {
+    throw new Error("IdaJS installation directory or host[:port] is required");
+  }
+
+  if (fs.existsSync(trimmed)) {
+    return {
+      installDir: trimmed,
+      server: null,
+    };
+  }
+
+  if (trimmed.includes("/") || trimmed.includes("\\") || /^[A-Za-z]:/.test(trimmed)) {
+    throw new Error(`Directory does not exist: ${trimmed}`);
+  }
+
+  return {
+    installDir: null,
+    server: normalizeServerAddress(trimmed),
+  };
+}
+
+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());
@@ -124,16 +244,15 @@ async function main() {
     if (!config.idajsDir) {
       questions.push({
         type: "text",
-        name: "idajsDir",
-        message: "IdaJS installation directory:",
+        name: "idajsConnection",
+        message: "IdaJS installation directory or host[:port]:",
         validate: (value) => {
-          if (!value || value.length === 0) {
-            return "IdaJS installation directory is required";
+          try {
+            parseIdaConnection(value);
+            return true;
+          } catch (error) {
+            return error.message;
           }
-          if (!fs.existsSync(value)) {
-            return `Directory does not exist: ${value}`;
-          }
-          return true;
         },
       });
     }
@@ -159,6 +278,13 @@ async function main() {
     });
 
     config = { ...config, ...response };
+
+    if (response.idajsConnection) {
+      const parsedConnection = parseIdaConnection(response.idajsConnection);
+      config.idajsDir = parsedConnection.installDir;
+      config.server = parsedConnection.server;
+      delete config.idajsConnection;
+    }
   }
 
   // Set target directory to project name if not specified
@@ -171,7 +297,7 @@ async function main() {
     : path.join(process.cwd(), config.targetDirectory);
 
   // Validate IdaJS directory exists
-  if (!fs.existsSync(config.idajsDir)) {
+  if (config.idajsDir && !fs.existsSync(config.idajsDir)) {
     console.error(`\n❌ Error: IdaJS installation directory does not exist: ${config.idajsDir}`);
     process.exit(1);
   }
@@ -184,7 +310,7 @@ async function main() {
 
   console.log(`\nCreating IdaJS mod in ${targetDir}...`);
   console.log(`Language: ${config.language === "js" ? "JavaScript" : "TypeScript"}`);
-  console.log(`IdaJS: ${config.idajsDir}\n`);
+  console.log(`IdaJS: ${config.idajsDir || config.server}\n`);
 
   try {
     // Create project directory
@@ -218,14 +344,14 @@ async function main() {
     fs.writeFileSync(packageTemplatePath, JSON.stringify(packageTemplate, null, 2) + "\n");
     console.log("✓ Updated package.template.json");
 
-    // Create .idajs.json config file
-    const idajsConfig = {
-      installDir: config.idajsDir,
-    };
-    fs.writeFileSync(
-      path.join(targetDir, ".idajs.json"),
-      JSON.stringify(idajsConfig, null, 2) + "\n"
-    );
+    const idajsConfig = {};
+    if (config.idajsDir) {
+      idajsConfig.installDir = config.idajsDir;
+    }
+    if (config.server) {
+      idajsConfig.server = config.server;
+    }
+    fs.writeFileSync(path.join(targetDir, ".idajs.json"), JSON.stringify(idajsConfig, null, 2) + "\n");
     console.log("✓ Created .idajs.json");
 
     // Call Samples/install.js to set up the project