launch-unity 0.8.0 → 0.10.0

package/README.ja.md

@@ -19,6 +19,7 @@ npx launch-unity
 ```bash
 # 構文
 launch-unity [OPTIONS] [PROJECT_PATH] [PLATFORM] [-- UNITY_ARGS...]
+launch-unity update
 
 # 引数
 #   PROJECT_PATH    Unityプロジェクトのディレクトリ（省略時は3階層下まで探索）
@@ -40,6 +41,12 @@ npx launch-unity -a                # Unity Hub に登録のみ（Unityは起動
 npx launch-unity -f                # Unity Hub にお気に入り登録（Unityは起動しない）
 npx launch-unity . -- -batchmode -quit -nographics -logFile -  # Unity引数を渡す
 npx launch-unity /path Android -- -executeMethod My.Build.Entry
+
+# 自己更新（npmグローバルインストール向け）
+launch-unity update
+
+# `update` という名前のディレクトリを開きたい場合は明示する
+launch-unity ./update
 ```
 
 指定した Unity プロジェクトの `ProjectSettings/ProjectVersion.txt` から必要な Unity Editor のバージョンを読み取り、

package/README.md

@@ -19,6 +19,7 @@ npx launch-unity
 ```bash
 # Syntax
 launch-unity [OPTIONS] [PROJECT_PATH] [PLATFORM] [-- UNITY_ARGS...]
+launch-unity update
 
 # Arguments
 #   PROJECT_PATH    Unity project directory (searches up to 3 levels deep if omitted)
@@ -40,6 +41,12 @@ npx launch-unity -a                # Register to Unity Hub only (does not launch
 npx launch-unity -f                # Register as favorite (does not launch Unity)
 npx launch-unity . -- -batchmode -quit -nographics -logFile -  # Pass Unity args
 npx launch-unity /path Android -- -executeMethod My.Build.Entry
+
+# Self update (for npm global install)
+launch-unity update
+
+# If you have a project directory named "update", specify it explicitly
+launch-unity ./update
 ```
 
 A TypeScript CLI for macOS and Windows that reads the required Unity Editor version from

package/dist/launch.js

@@ -6,7 +6,8 @@
 import { execFile, spawn } from "node:child_process";
 import { existsSync, readFileSync, readdirSync, lstatSync, realpathSync } from "node:fs";
 import { rm } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { ensureProjectEntryAndUpdate, updateLastModifiedIfExists } from "./unityHub.js";
 const execFileAsync = promisify(execFile);
@@ -18,11 +19,128 @@ const PROCESS_LIST_ARGS_MAC = ["-axo", "pid=,command=", "-ww"];
 const WINDOWS_POWERSHELL = "powershell";
 const UNITY_LOCKFILE_NAME = "UnityLockfile";
 const TEMP_DIRECTORY_NAME = "Temp";
+const npmExecutableName = () => {
+    return process.platform === "win32" ? "npm.cmd" : "npm";
+};
+const runCommand = async (command, args) => {
+    return await new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", (error) => {
+            resolve({ exitCode: 127, stdout, stderr: `${stderr}${error.message}\n` });
+        });
+        child.on("close", (code) => {
+            resolve({ exitCode: code ?? 1, stdout, stderr });
+        });
+    });
+};
+const parseSemverTriplet = (value) => {
+    const normalized = value.trim();
+    const withoutBuild = normalized.split("+")[0] ?? normalized;
+    const match = withoutBuild.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+    if (!match) {
+        return undefined;
+    }
+    const major = Number.parseInt(match[1] ?? "", 10);
+    const minor = Number.parseInt(match[2] ?? "", 10);
+    const patch = Number.parseInt(match[3] ?? "", 10);
+    if (!Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(patch)) {
+        return undefined;
+    }
+    const prereleaseRaw = match[4] ?? undefined;
+    if (!prereleaseRaw) {
+        return { major, minor, patch };
+    }
+    const prereleaseIdentifiers = prereleaseRaw
+        .split(".")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .map((part) => {
+        const numeric = part.match(/^\d+$/);
+        if (numeric) {
+            const value = Number.parseInt(part, 10);
+            if (Number.isFinite(value)) {
+                return value;
+            }
+        }
+        return part;
+    });
+    if (prereleaseIdentifiers.length === 0) {
+        return { major, minor, patch };
+    }
+    return { major, minor, patch, prereleaseIdentifiers };
+};
+const compareSemverTriplet = (left, right) => {
+    if (left.major !== right.major) {
+        return left.major < right.major ? -1 : 1;
+    }
+    if (left.minor !== right.minor) {
+        return left.minor < right.minor ? -1 : 1;
+    }
+    if (left.patch !== right.patch) {
+        return left.patch < right.patch ? -1 : 1;
+    }
+    const leftPre = left.prereleaseIdentifiers;
+    const rightPre = right.prereleaseIdentifiers;
+    if (!leftPre && !rightPre) {
+        return 0;
+    }
+    if (!leftPre && rightPre) {
+        return 1;
+    }
+    if (leftPre && !rightPre) {
+        return -1;
+    }
+    const leftIdentifiers = leftPre ?? [];
+    const rightIdentifiers = rightPre ?? [];
+    const length = Math.max(leftIdentifiers.length, rightIdentifiers.length);
+    for (let i = 0; i < length; i++) {
+        const leftId = leftIdentifiers[i];
+        const rightId = rightIdentifiers[i];
+        if (leftId === undefined && rightId === undefined) {
+            return 0;
+        }
+        if (leftId === undefined) {
+            return -1;
+        }
+        if (rightId === undefined) {
+            return 1;
+        }
+        if (leftId === rightId) {
+            continue;
+        }
+        const leftIsNumber = typeof leftId === "number";
+        const rightIsNumber = typeof rightId === "number";
+        if (leftIsNumber && rightIsNumber) {
+            return leftId < rightId ? -1 : 1;
+        }
+        if (leftIsNumber !== rightIsNumber) {
+            return leftIsNumber ? -1 : 1;
+        }
+        const leftText = String(leftId);
+        const rightText = String(rightId);
+        return leftText < rightText ? -1 : 1;
+    }
+    return 0;
+};
 function parseArgs(argv) {
     const args = argv.slice(2);
     const doubleDashIndex = args.indexOf("--");
-    const cliArgs = doubleDashIndex >= 0 ? args.slice(0, doubleDashIndex) : args;
+    let cliArgs = doubleDashIndex >= 0 ? args.slice(0, doubleDashIndex) : args;
     const unityArgs = doubleDashIndex >= 0 ? args.slice(doubleDashIndex + 1) : [];
+    let subcommand;
+    const firstToken = cliArgs[0];
+    if (firstToken === "update") {
+        subcommand = "update";
+        cliArgs = cliArgs.slice(1);
+    }
     const positionals = [];
     let maxDepth = 3; // default 3; -1 means unlimited
     let restart = false;
@@ -34,6 +152,10 @@ function parseArgs(argv) {
             printHelp();
             process.exit(0);
         }
+        if (arg === "--version" || arg === "-v") {
+            console.log(getVersion());
+            process.exit(0);
+        }
         if (arg === "-r" || arg === "--restart") {
             restart = true;
             continue;
@@ -97,7 +219,16 @@ function parseArgs(argv) {
         projectPath = resolve(positionals[0] ?? "");
         platform = String(positionals[1] ?? "");
     }
-    const options = { unityArgs, searchMaxDepth: maxDepth, restart, addUnityHub, favoriteUnityHub };
+    const options = {
+        unityArgs,
+        searchMaxDepth: maxDepth,
+        restart,
+        addUnityHub,
+        favoriteUnityHub,
+    };
+    if (subcommand) {
+        options.subcommand = subcommand;
+    }
     if (projectPath !== undefined) {
         options.projectPath = projectPath;
     }
@@ -106,14 +237,23 @@ function parseArgs(argv) {
     }
     return options;
 }
+function getVersion() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const currentDir = dirname(currentFilePath);
+    const packageJsonPath = join(currentDir, "..", "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return packageJson.version;
+}
 function printHelp() {
     const help = `
-Usage: launch-unity [PROJECT_PATH] [PLATFORM] -- [UNITY_ARGS...]
+Usage:
+  launch-unity [PROJECT_PATH] [PLATFORM] -- [UNITY_ARGS...]
+  launch-unity update
 
 Open a Unity project with the matching Unity Editor version installed by Unity Hub.
 
 Arguments:
-  PROJECT_PATH  Optional. Defaults to current directory
+  PROJECT_PATH  Optional. If omitted, searches under the current directory (see --max-depth)
   PLATFORM      Optional. Passed to Unity as -buildTarget (e.g., StandaloneOSX, Android, iOS)
 
 Forwarding:
@@ -122,11 +262,15 @@ Forwarding:
 
 Flags:
   -h, --help          Show this help message
+  -v, --version       Show version number
   -r, --restart       Kill running Unity and restart
   --max-depth <N>     Search depth when PROJECT_PATH is omitted (default 3, -1 unlimited)
   -u, -a, --unity-hub-entry, --add-unity-hub
                       Add to Unity Hub if missing and update lastModified (does not launch Unity)
   -f, --favorite      Add to Unity Hub as favorite (does not launch Unity)
+
+Commands:
+  update              Update launch-unity to the latest version (npm global install)
 `;
     process.stdout.write(help);
 }
@@ -577,6 +721,10 @@ function launch(opts) {
 }
 async function main() {
     const options = parseArgs(process.argv);
+    if (options.subcommand === "update") {
+        await runSelfUpdate();
+        return;
+    }
     let resolvedProjectPath = options.projectPath;
     if (!resolvedProjectPath) {
         const searchRoot = process.cwd();
@@ -639,6 +787,59 @@ async function main() {
         console.warn(`Failed to update Unity Hub lastModified: ${message}`);
     }
 }
+async function runSelfUpdate() {
+    const currentVersion = getVersion();
+    const npmCmd = npmExecutableName();
+    const latestResult = await runCommand(npmCmd, ["view", "launch-unity", "version"]);
+    if (latestResult.exitCode !== 0) {
+        console.error("Error: Failed to retrieve latest version from npm.");
+        if (latestResult.stderr.trim().length > 0) {
+            process.stderr.write(latestResult.stderr);
+        }
+        process.exit(1);
+        return;
+    }
+    const latestVersion = latestResult.stdout.trim();
+    if (latestVersion.length === 0) {
+        console.error("Error: npm returned an empty version.");
+        process.exit(1);
+        return;
+    }
+    console.log(`Current: ${currentVersion}`);
+    console.log(`Latest:  ${latestVersion}`);
+    const currentSemver = parseSemverTriplet(currentVersion);
+    const latestSemver = parseSemverTriplet(latestVersion);
+    if (currentSemver && latestSemver) {
+        const cmp = compareSemverTriplet(currentSemver, latestSemver);
+        if (cmp >= 0) {
+            console.log("Already up to date.");
+            return;
+        }
+    }
+    else {
+        if (currentVersion === latestVersion) {
+            console.log("Already up to date.");
+            return;
+        }
+    }
+    const installArgs = ["install", "-g", `launch-unity@${latestVersion}`, "--ignore-scripts"];
+    console.log(`Running: ${npmCmd} ${installArgs.join(" ")}`);
+    const installResult = await runCommand(npmCmd, installArgs);
+    if (installResult.exitCode === 0) {
+        console.log("Update complete.");
+        return;
+    }
+    console.error(`Error: Update failed (exit code ${installResult.exitCode}).`);
+    if (installResult.stderr.trim().length > 0) {
+        process.stderr.write(installResult.stderr);
+    }
+    if (process.platform === "darwin") {
+        const sudoSuggestion = `sudo ${npmCmd} ${installArgs.join(" ")}`;
+        console.error("If this is a permissions issue, try:");
+        console.error(`  ${sudoSuggestion}`);
+    }
+    process.exit(1);
+}
 main().catch((error) => {
     console.error(error);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launch-unity",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Open a Unity project with the matching Editor version (macOS/Windows)",
   "type": "module",
   "main": "dist/launch.js",