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

package/_project.config/AGENTS.md

@@ -0,0 +1,25 @@
+# AGENTS.md
+
+## What is IdaJS
+
+IdaJS is a JavaScript-powered modding engine for Little Big Adventure 2 (LBA2). It lets you create mods for the classic LBA2 game using JavaScript or TypeScript — modifying scenes, characters, behaviors, dialogs, and more through a modern scripting API.
+
+## API Reference
+
+The full IdaJS TypeScript API with JSDoc documentation is available in `./node_modules/@idajs/types/`, structured by entities. The global objects (such as `scene`, `ida`, `text`, `object`, etc.) are defined in `global.d.ts`. Always consult these type definitions when implementing any feature.
+
+## Mod Execution Phases
+
+Different phases of mod execution allow different APIs. Be aware which phase you are in:
+
+- **Scene setup phase** (`scene.Events.afterLoadScene` handler): Configure the scene before gameplay starts. Use `scene`, `object`, `text`, zone and waypoint APIs to add/modify objects, zones, waypoints, register life script handlers, register coroutines, and set initial state. Do **not** call life or move script commands here.
+- **Life script handler** (`handleLifeScript`): Runs every frame per actor. Use `ida.life()` and `ida.lifef()` for life script commands/functions (conditions, dialogs, state changes). Can start/pause/stop coroutines from here.
+- **Coroutine (move script)** (generator function registered via `registerCoroutine`): Runs across multiple frames. Use `yield doMove()` for move commands (animations, movement, timing) and other `yield do...()` helpers (`doSceneStore`, `doGameStore`, etc.). Cannot check game conditions directly — that logic belongs in life scripts.
+
+## Mod Examples
+
+For examples of working mods, look at `Ida/Samples` in the IdaJS installation folder. The path to the installation folder is written in a JSON file either in the user's home directory: `~/.idajs.json` or in the root directory of this project.
+
+## Web Documentation
+
+Full readme, API reference, and guides are available at: https://ida.innerbytes.com

package/_project.config/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/_project.config/extensions.json

@@ -1,6 +1,4 @@
 {
-  "recommendations": [
-    "prettier.prettier-vscode"
-  ],
+  "recommendations": ["esbenp.prettier-vscode"],
   "unwantedRecommendations": []
 }

package/_project.config/package.template.json

@@ -1,14 +1,14 @@
 {
   "author": "Andriy Tevelyev",
-  "private": true,
-  "scripts": {
-    "setup": "node ../install.js",
-    "watch": "node watch.js",
-    "sync": "node sync.js %npm_package_name%",
-    "start": "powershell -ExecutionPolicy Bypass -File run.ps1 %npm_package_name%",
-    "build": "node build.js %npm_package_name%",
-    "update:types": "npm update @idajs/types"
-  },
+  "private": true,
+  "scripts": {
+    "setup": "node ../install.js",
+    "watch": "node watch.js",
+    "sync": "node sync.js",
+    "start": "node start.js",
+    "build": "node build.js %npm_package_name%",
+    "update:types": "npm update @idajs/types"
+  },
   "devDependencies": {
     "archiver": "^7.0.1",
     "chokidar-cli": "^3.0.0",

package/_project.config/project.js

@@ -0,0 +1,120 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const DEFAULT_PORT = 7770;
+
+function getArgs(argv = process.argv.slice(2)) {
+  return argv;
+}
+
+function getArgValue(name, argv = getArgs()) {
+  const index = argv.findIndex((arg) => arg === name || arg.startsWith(`${name}=`));
+  if (index === -1) {
+    return null;
+  }
+
+  const arg = argv[index];
+  if (arg.includes("=")) {
+    return arg.split("=").slice(1).join("=");
+  }
+
+  return argv[index + 1] || null;
+}
+
+function getPackageName(projectDir = process.cwd()) {
+  const packagePath = path.join(projectDir, "package.json");
+
+  if (!fs.existsSync(packagePath)) {
+    throw new Error(`package.json not found in ${projectDir}`);
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+  if (!packageJson.name) {
+    throw new Error("package.json is missing the 'name' field");
+  }
+
+  return packageJson.name;
+}
+
+function getIdaJsPath(projectDir = process.cwd()) {
+  const configPaths = [path.join(projectDir, ".idajs.json"), path.join(os.homedir(), ".idajs.json")];
+
+  for (const configPath of configPaths) {
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      if (config.installDir) {
+        return config.installDir;
+      }
+    } catch (error) {
+      // Ignore parse failures and keep looking.
+    }
+  }
+
+  return null;
+}
+
+function getIdaJsServer(projectDir = process.cwd()) {
+  const configPaths = [path.join(projectDir, ".idajs.json"), path.join(os.homedir(), ".idajs.json")];
+
+  for (const configPath of configPaths) {
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      if (config.server) {
+        return config.server;
+      }
+    } catch (error) {
+      // Ignore parse failures and keep looking.
+    }
+  }
+
+  return null;
+}
+
+function isTypeScriptProject(projectDir = process.cwd()) {
+  const tsConfigPath = path.join(projectDir, "tsconfig.json");
+  const srcDir = path.join(projectDir, "src");
+
+  if (!fs.existsSync(tsConfigPath) || !fs.existsSync(srcDir)) {
+    return false;
+  }
+
+  const files = fs.readdirSync(srcDir);
+  return files.some((file) => file.endsWith(".ts"));
+}
+
+function parseServerAddress(serverInput) {
+  if (!serverInput) {
+    throw new Error("Server address is required. Use --server <host[:port]>.");
+  }
+
+  const trimmedInput = String(serverInput).trim();
+  const withProtocol = trimmedInput.includes("://") ? trimmedInput : `http://${trimmedInput}`;
+  const url = new URL(withProtocol);
+
+  return {
+    host: url.hostname,
+    port: Number(url.port || DEFAULT_PORT),
+    origin: `${url.protocol}//${url.hostname}:${url.port || DEFAULT_PORT}`,
+    value: `${url.hostname}:${url.port || DEFAULT_PORT}`,
+  };
+}
+
+module.exports = {
+  DEFAULT_PORT,
+  getArgValue,
+  getArgs,
+  getIdaJsPath,
+  getIdaJsServer,
+  getPackageName,
+  isTypeScriptProject,
+  parseServerAddress,
+};

package/_project.config/remote.js

@@ -0,0 +1,171 @@
+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 { getPackageName } = require("./project");
+
+function runNodeScript(scriptName, args = []) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(__dirname, scriptName), ...args], {
+      cwd: process.cwd(),
+      stdio: "inherit",
+    });
+
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      reject(new Error(`${scriptName} exited with code ${code}`));
+    });
+  });
+}
+
+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();
+  });
+}
+
+function request(server, method, requestPath, body, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const client = server.origin.startsWith("https://") ? https : http;
+    const options = {
+      method,
+      hostname: server.host,
+      port: server.port,
+      path: requestPath,
+      headers,
+    };
+
+    const req = client.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const responseBody = Buffer.concat(chunks).toString("utf8");
+
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          if (!responseBody) {
+            resolve(null);
+            return;
+          }
+
+          try {
+            resolve(JSON.parse(responseBody));
+          } catch (error) {
+            resolve(responseBody);
+          }
+          return;
+        }
+
+        reject(
+          new Error(
+            `${method} ${requestPath} failed with ${res.statusCode}: ${responseBody || "no body"}`
+          )
+        );
+      });
+    });
+
+    req.on("error", (error) => {
+      if (error.code === "EHOSTUNREACH" || error.code === "ECONNREFUSED" || error.code === "ETIMEDOUT") {
+        reject(
+          new Error(
+            `Cannot reach remote Ida listener at ${server.host}:${server.port}. ` +
+              `Start it on the Windows machine with 'npm run listen' in the Ida folder and verify the host/port is reachable. ` +
+              `Original error: ${error.code}`
+          )
+        );
+        return;
+      }
+
+      reject(error);
+    });
+
+    if (body) {
+      req.write(body);
+    }
+
+    req.end();
+  });
+}
+
+async function stageMod(targetRoot) {
+  const args = [];
+  if (targetRoot) {
+    args.push("--target-root", targetRoot);
+  }
+
+  await runNodeScript("sync.js", args);
+}
+
+async function stageAndZip(targetRoot) {
+  const modName = getPackageName();
+  const stagedModDir = path.join(targetRoot, modName);
+  const zipPath = path.join(targetRoot, `${modName}.zip`);
+
+  await stageMod(targetRoot);
+  if (fs.existsSync(zipPath)) {
+    fs.rmSync(zipPath, { force: true });
+  }
+  await createZip(zipPath, stagedModDir, modName);
+
+  return { modName, stagedModDir, zipPath };
+}
+
+async function uploadMod(server, modName, zipPath) {
+  const body = fs.readFileSync(zipPath);
+  return request(server, "POST", `/sync?modName=${encodeURIComponent(modName)}`, body, {
+    "Content-Type": "application/zip",
+    "Content-Length": Buffer.byteLength(body),
+  });
+}
+
+async function startRemoteGame(server, modName) {
+  return request(
+    server,
+    "POST",
+    "/game/start",
+    Buffer.from(JSON.stringify({ modName }), "utf8"),
+    {
+      "Content-Type": "application/json",
+    }
+  );
+}
+
+async function killRemoteGame(server) {
+  return request(server, "POST", "/game/kill");
+}
+
+async function getRemoteGameStatus(server) {
+  return request(server, "GET", "/game/status");
+}
+
+module.exports = {
+  getRemoteGameStatus,
+  killRemoteGame,
+  stageMod,
+  stageAndZip,
+  startRemoteGame,
+  uploadMod,
+};

package/_project.config/run-remote.js

@@ -0,0 +1,75 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const { getArgValue, parseServerAddress } = require("./project");
+const { getRemoteGameStatus, stageAndZip, startRemoteGame, uploadMod } = require("./remote");
+
+async function main() {
+  const args = process.argv.slice(2);
+  const server = parseServerAddress(getArgValue("--server", args));
+  const sessionRoot = fs.mkdtempSync(path.join(os.tmpdir(), "idajs-remote-"));
+  let cleanedUp = false;
+
+  const cleanup = () => {
+    if (cleanedUp) {
+      return;
+    }
+
+    cleanedUp = true;
+    fs.rmSync(sessionRoot, { recursive: true, force: true });
+  };
+
+  try {
+    console.log(`Checking remote Ida listener at ${server.origin}...`);
+    await getRemoteGameStatus(server);
+
+    console.log(`Using remote staging directory: ${sessionRoot}`);
+    const { modName, zipPath } = await stageAndZip(sessionRoot);
+    await uploadMod(server, modName, zipPath);
+    await startRemoteGame(server, modName);
+
+    const child = spawn(
+      process.execPath,
+      [
+        path.join(__dirname, "watch.js"),
+        "--server",
+        server.value,
+        "--session-root",
+        sessionRoot,
+      ],
+      {
+        cwd: process.cwd(),
+        stdio: "inherit",
+      }
+    );
+
+    child.on("exit", (code) => {
+      cleanup();
+      process.exit(code ?? 0);
+    });
+
+    child.on("error", (error) => {
+      cleanup();
+      console.error(error.message);
+      process.exit(1);
+    });
+
+    process.on("SIGINT", () => {
+      child.kill("SIGINT");
+    });
+
+    process.on("SIGTERM", () => {
+      child.kill("SIGTERM");
+    });
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/_project.config/settings.json

@@ -7,14 +7,14 @@
     "*.ts": "typescript"
   },
   "[javascript]": {
-    "editor.defaultFormatter": "prettier.prettier-vscode",
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
     "editor.tabSize": 2,
     "editor.wordWrap": "wordWrapColumn",
     "editor.wordWrapColumn": 100,
     "editor.rulers": [100]
   },
   "[typescript]": {
-    "editor.defaultFormatter": "prettier.prettier-vscode",
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
     "editor.tabSize": 2,
     "editor.wordWrap": "wordWrapColumn",
     "editor.wordWrapColumn": 100,

package/_project.config/start.js

@@ -0,0 +1,60 @@
+const path = require("path");
+const { execFileSync, spawn } = require("child_process");
+
+const { getArgValue, getIdaJsPath, getIdaJsServer, getPackageName } = require("./project");
+
+function runRemote(args) {
+  const child = spawn(process.execPath, [path.join(__dirname, "run-remote.js"), ...args], {
+    cwd: process.cwd(),
+    stdio: "inherit",
+  });
+
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+
+  child.on("error", (error) => {
+    console.error(error.message);
+    process.exit(1);
+  });
+}
+
+function runLocal() {
+  try {
+    execFileSync(
+      "powershell",
+      [
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        path.join(__dirname, "run.ps1"),
+        getPackageName(),
+      ],
+      {
+        cwd: process.cwd(),
+        stdio: "inherit",
+      }
+    );
+    process.exit(0);
+  } catch (error) {
+    if (typeof error.status === "number") {
+      process.exit(error.status);
+    }
+
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+const args = process.argv.slice(2);
+const explicitServer = getArgValue("--server", args);
+const installDir = getIdaJsPath();
+const configuredServer = getIdaJsServer();
+
+if (explicitServer) {
+  runRemote(args);
+} else if (!installDir && configuredServer) {
+  runRemote(["--server", configuredServer]);
+} else {
+  runLocal();
+}

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

@@ -70,6 +70,37 @@ 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),
+  };
+}
+
 async function main() {
   console.log("Welcome to IdaJS Mod Creator!\n");
 
@@ -124,16 +155,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 +189,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 +208,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 +221,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 +255,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

package/install.js

@@ -141,10 +141,16 @@ function mergePackageJson() {
 // Step 2: Copy necessary files
 function copyFiles() {
   const filesToCopy = [
+    { source: "project.js" },
+    { source: "remote.js" },
     { source: "run.ps1" },
+    { source: "run-remote.js" },
+    { source: "start.js" },
     { source: "watch.js" },
     { source: "sync.js" },
     { source: "build.js" },
+    { source: "AGENTS.md" },
+    { source: "CLAUDE.md" },
     { source: isTypeScriptProject ? "tsconfig.json" : "jsconfig.json" },
     { source: "settings.json", target: ".vscode/settings.json" },
     { source: "extensions.json", target: ".vscode/extensions.json" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idajs/create-mod",
-  "version": "0.2.10",
+  "version": "0.2.15-dev.19",
   "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",