unity-hub-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Masamichi Hatayama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# UnityHub CLI
+
+A CLI tool that reads Unity Hub's `projects-v1.json`, displays projects in an Ink-based TUI, allows navigation with arrow keys/`j`/`k`, and launches Unity Editor by pressing Enter.
+
+## Requirements
+
+- macOS
+- Node.js 20+
+- Unity Hub (with `~/Library/Application Support/UnityHub/projects-v1.json` present)
+
+## Usage
+
+### Development
+
+```bash
+npm install
+npm run dev
+```
+
+### Build
+
+```bash
+npm run build
+```
+
+### Run
+
+After building, `dist/index.js` will be generated. You can also run it directly via npx.
+
+```bash
+npx unity-hub-cli
+# or
+node dist/index.js
+```
+
+By default, the project list uses the Git repository root folder name when available.
+
+### CLI Options
+
+- `--no-git-root-name`: Display Unity project titles instead of Git repository root folder names.
+- `--hide-branch`: Hide the Git branch column.
+- `--hide-path`: Hide the project path column.
+
+## Release Automation
+
+Version and release management is automated using release-please and GitHub Actions.
+
+- `.github/workflows/release-please.yml` runs on push to `main` or manual trigger
+- The action references `release-please-config.json` and `.release-please-manifest.json` to create release PRs and tags
+- When a PR is merged, GitHub Releases and changelog are automatically updated
+- **npm publish is automated with provenance** for supply chain security
+
+### Initial Setup Notes
+
+- If existing releases are present, set the latest release commit in `bootstrap-sha` of `release-please-config.json`
+- The workflow uses GitHub's `GITHUB_TOKEN` and operates with `contents`/`pull-requests` permissions
+
+### Manual Execution
+
+You can manually trigger the `release-please` workflow from the Actions tab by selecting `Run workflow`
+
+## Security
+
+This package implements multiple security measures to protect against supply chain attacks:
+
+1. **Automated Publishing with Provenance**: All npm releases are published via GitHub Actions with `--provenance` flag, providing cryptographic proof of the build environment
+2. **Minimal Dependencies**: Only 2 runtime dependencies (`ink` and `react`), both from highly trusted sources
+3. **Locked Dependencies**: `package-lock.json` is committed to ensure reproducible builds
+4. **Regular Security Audits**: Dependencies are regularly checked with `npm audit`
+
+### Verifying Package Authenticity
+
+You can verify the authenticity of published packages:
+
+```bash
+# Check provenance information
+npm view unity-hub-cli --json | jq .dist.attestations
+
+# Verify package integrity
+npm audit signatures
+```
+
+## Controls
+
+- Arrow keys / `j` / `k`: Navigate selection
+ - `o`: Launch selected project in Unity
+- Ctrl + C (twice): Exit
+
+The display includes Git branch (if present), Unity version, project path, and last modified time (`lastModified`).
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,783 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import process2 from "process";
+import { render } from "ink";
+
+// src/application/usecases.ts
+var ListProjectsUseCase = class {
+  constructor(unityHubProjectsReader, gitRepositoryInfoReader, unityProjectOptionsReader) {
+    this.unityHubProjectsReader = unityHubProjectsReader;
+    this.gitRepositoryInfoReader = gitRepositoryInfoReader;
+    this.unityProjectOptionsReader = unityProjectOptionsReader;
+  }
+  async execute() {
+    const projects = await this.unityHubProjectsReader.listProjects();
+    const repositoryInfoResults = await Promise.allSettled(
+      projects.map((project) => this.gitRepositoryInfoReader.readRepositoryInfo(project.path))
+    );
+    return projects.map((project, index) => {
+      const repositoryResult = repositoryInfoResults[index];
+      if (repositoryResult.status === "fulfilled") {
+        return { project, repository: repositoryResult.value ?? void 0 };
+      }
+      return { project };
+    });
+  }
+};
+var LaunchCancelledError = class extends Error {
+  constructor() {
+    super("Launch cancelled by user");
+    this.name = "LaunchCancelledError";
+  }
+};
+var LaunchProjectUseCase = class {
+  constructor(editorPathResolver, processLauncher, unityHubProjectsReader, unityProjectOptionsReader, unityProcessLockChecker) {
+    this.editorPathResolver = editorPathResolver;
+    this.processLauncher = processLauncher;
+    this.unityHubProjectsReader = unityHubProjectsReader;
+    this.unityProjectOptionsReader = unityProjectOptionsReader;
+    this.unityProcessLockChecker = unityProcessLockChecker;
+  }
+  async execute(project) {
+    const lockDecision = await this.unityProcessLockChecker.check(project.path);
+    if (lockDecision === "skip") {
+      throw new LaunchCancelledError();
+    }
+    const editorPath = await this.editorPathResolver.resolve(project.version);
+    const extraArgs = await this.unityProjectOptionsReader.readCliArgs(project.path);
+    const launchArgs = ["-projectPath", project.path, ...extraArgs];
+    await this.processLauncher.launch(editorPath, launchArgs, {
+      detached: true
+    });
+    await this.unityHubProjectsReader.updateLastModified(project.path, /* @__PURE__ */ new Date());
+  }
+};
+
+// src/infrastructure/editor.ts
+import { constants } from "fs";
+import { access } from "fs/promises";
+import { join } from "path";
+var UNITY_EDITOR_BASE = "/Applications/Unity/Hub/Editor";
+var UNITY_BINARY_PATH = "Unity.app/Contents/MacOS/Unity";
+var MacEditorPathResolver = class {
+  async resolve(version) {
+    const editorPath = join(UNITY_EDITOR_BASE, version.value, UNITY_BINARY_PATH);
+    try {
+      await access(editorPath, constants.X_OK);
+    } catch {
+      throw new Error(`\u5BFE\u5FDC\u3059\u308BUnity Editor\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\uFF08${version.value}\uFF09`);
+    }
+    return editorPath;
+  }
+};
+
+// src/infrastructure/git.ts
+import { readFile, stat } from "fs/promises";
+import { dirname, join as join2, resolve } from "path";
+var HEAD_FILE = "HEAD";
+var GIT_DIR = ".git";
+var MAX_ASCENT = 50;
+var isDirectory = async (path) => {
+  try {
+    const stats = await stat(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+};
+var isFile = async (path) => {
+  try {
+    const stats = await stat(path);
+    return stats.isFile();
+  } catch {
+    return false;
+  }
+};
+var findGitDir = async (start) => {
+  let current = resolve(start);
+  for (let depth = 0; depth < MAX_ASCENT; depth += 1) {
+    const candidate = join2(current, GIT_DIR);
+    if (await isDirectory(candidate)) {
+      return candidate;
+    }
+    if (await isFile(candidate)) {
+      const content = await readFile(candidate, "utf8");
+      const match = content.match(/^gitdir:\s*(.+)$/m);
+      if (match) {
+        const gitdirPath = match[1]?.trim();
+        if (gitdirPath) {
+          const target = gitdirPath.startsWith("/") ? gitdirPath : resolve(current, gitdirPath);
+          return target;
+        }
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return void 0;
+};
+var parseHead = (content) => {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (trimmed.startsWith("ref:")) {
+    const refName = trimmed.split(" ")[1]?.trim();
+    if (refName?.startsWith("refs/heads/")) {
+      return { type: "branch", name: refName.replace("refs/heads/", "") };
+    }
+    return void 0;
+  }
+  return { type: "detached", sha: trimmed.slice(0, 7) };
+};
+var GitRepositoryInfoReader = class {
+  async readRepositoryInfo(projectPath) {
+    const gitDir = await findGitDir(projectPath);
+    if (!gitDir) {
+      return void 0;
+    }
+    try {
+      const headPath = join2(gitDir, HEAD_FILE);
+      const content = await readFile(headPath, "utf8");
+      const branch = parseHead(content);
+      const root = dirname(gitDir);
+      return { branch, root };
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/infrastructure/process.ts
+import { spawn } from "child_process";
+var NodeProcessLauncher = class {
+  async launch(command, args, options) {
+    const detached = options?.detached ?? false;
+    await new Promise((resolve2, reject) => {
+      const child = spawn(command, args, {
+        detached,
+        stdio: "ignore"
+      });
+      const handleError = (error) => {
+        child.off("spawn", handleSpawn);
+        reject(error);
+      };
+      const handleSpawn = () => {
+        child.off("error", handleError);
+        child.unref();
+        resolve2();
+      };
+      child.once("error", handleError);
+      child.once("spawn", handleSpawn);
+    });
+  }
+};
+
+// src/infrastructure/unityhub.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { basename } from "path";
+var HUB_PROJECTS_PATH = `${process.env.HOME ?? ""}/Library/Application Support/UnityHub/projects-v1.json`;
+var schemaVersion = "v1";
+var toUnityProject = (entry) => {
+  const safePath = entry.path;
+  if (!safePath) {
+    throw new Error("Unity Hub entry is missing project path");
+  }
+  const version = entry.version;
+  if (!version) {
+    throw new Error(`Unity Hub entry ${safePath} is missing version`);
+  }
+  const lastModified = typeof entry.lastModified === "number" ? new Date(entry.lastModified) : void 0;
+  return {
+    id: safePath,
+    title: entry.title?.trim() || basename(safePath),
+    path: safePath,
+    version: { value: version },
+    lastModified,
+    favorite: entry.isFavorite === true
+  };
+};
+var normalizeValue = (value) => value.toLocaleLowerCase();
+var sortByFavoriteThenLastModified = (projects) => {
+  return [...projects].sort((a, b) => {
+    const favoriteRankA = a.favorite ? 0 : 1;
+    const favoriteRankB = b.favorite ? 0 : 1;
+    if (favoriteRankA !== favoriteRankB) {
+      return favoriteRankA - favoriteRankB;
+    }
+    const fallbackTime = 0;
+    const timeA = a.lastModified?.getTime() ?? fallbackTime;
+    const timeB = b.lastModified?.getTime() ?? fallbackTime;
+    if (timeA === timeB) {
+      const titleA = normalizeValue(a.title);
+      const titleB = normalizeValue(b.title);
+      if (titleA === titleB) {
+        return normalizeValue(a.path).localeCompare(normalizeValue(b.path));
+      }
+      return titleA.localeCompare(titleB);
+    }
+    return timeB - timeA;
+  });
+};
+var UnityHubProjectsReader = class {
+  async listProjects() {
+    let content;
+    try {
+      content = await readFile2(HUB_PROJECTS_PATH, "utf8");
+    } catch {
+      throw new Error(
+        `Unity Hub\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u4E00\u89A7\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\uFF08${HUB_PROJECTS_PATH}\uFF09`
+      );
+    }
+    let json;
+    try {
+      json = JSON.parse(content);
+    } catch {
+      throw new Error("Unity Hub\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u4E00\u89A7\u3092\u8AAD\u307F\u53D6\u308C\u307E\u305B\u3093\uFF08\u6A29\u9650/\u5F62\u5F0F\u30A8\u30E9\u30FC\uFF09");
+    }
+    if (json.schema_version && json.schema_version !== schemaVersion) {
+      throw new Error(`\u672A\u5BFE\u5FDC\u306Eschema_version\u3067\u3059\uFF08${json.schema_version}\uFF09`);
+    }
+    const entries = Object.values(json.data ?? {});
+    if (entries.length === 0) {
+      return [];
+    }
+    const projects = entries.map(toUnityProject);
+    return sortByFavoriteThenLastModified(projects);
+  }
+  async updateLastModified(projectPath, date) {
+    let content;
+    try {
+      content = await readFile2(HUB_PROJECTS_PATH, "utf8");
+    } catch {
+      throw new Error(
+        `Unity Hub\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u4E00\u89A7\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\uFF08${HUB_PROJECTS_PATH}\uFF09`
+      );
+    }
+    let json;
+    try {
+      json = JSON.parse(content);
+    } catch {
+      throw new Error("Unity Hub\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u4E00\u89A7\u3092\u8AAD\u307F\u53D6\u308C\u307E\u305B\u3093\uFF08\u6A29\u9650/\u5F62\u5F0F\u30A8\u30E9\u30FC\uFF09");
+    }
+    if (!json.data) {
+      return;
+    }
+    const projectKey = Object.keys(json.data).find((key) => json.data?.[key]?.path === projectPath);
+    if (!projectKey) {
+      return;
+    }
+    const original = json.data[projectKey];
+    if (!original) {
+      return;
+    }
+    json.data[projectKey] = {
+      ...original,
+      lastModified: date.getTime()
+    };
+    await writeFile(HUB_PROJECTS_PATH, JSON.stringify(json, void 0, 2), "utf8");
+  }
+  async readCliArgs(projectPath) {
+    const infoPath = `${process.env.HOME ?? ""}/Library/Application Support/UnityHub/projectsInfo.json`;
+    let content;
+    try {
+      content = await readFile2(infoPath, "utf8");
+    } catch {
+      return [];
+    }
+    let json;
+    try {
+      json = JSON.parse(content);
+    } catch {
+      return [];
+    }
+    const entry = json[projectPath];
+    if (!entry?.cliArgs) {
+      return [];
+    }
+    const tokens = entry.cliArgs.match(/(?:"[^"]*"|'[^']*'|[^\s"']+)/g);
+    if (!tokens) {
+      return [];
+    }
+    return tokens.map((token) => token.replace(/^['"]|['"]$/g, ""));
+  }
+};
+
+// src/infrastructure/unityLock.ts
+import { constants as constants2, createReadStream, createWriteStream } from "fs";
+import { access as access2, rm } from "fs/promises";
+import { join as join3 } from "path";
+import readline from "readline";
+var RAW_PROMPT_MESSAGE = "Delete UnityLockfile and continue? Type 'y' to continue; anything else aborts: ";
+var isRawModeSupported = () => {
+  const stdin = process.stdin;
+  return Boolean(stdin?.isTTY && typeof stdin.setRawMode === "function" && process.stdout.isTTY);
+};
+var createPromptInterface = () => {
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const close = () => rl.close();
+    return { rl, close };
+  }
+  try {
+    if (process.platform === "win32") {
+      const inCandidates = ["\\\\.\\CONIN$", "CONIN$"];
+      const outCandidates = ["\\\\.\\CONOUT$", "CONOUT$"];
+      for (const inPath of inCandidates) {
+        for (const outPath of outCandidates) {
+          try {
+            const input = createReadStream(inPath);
+            const output = createWriteStream(outPath);
+            const rl = readline.createInterface({ input, output });
+            const close = () => {
+              rl.close();
+              input.destroy();
+              output.end();
+            };
+            return { rl, close };
+          } catch {
+            continue;
+          }
+        }
+      }
+    } else {
+      const input = createReadStream("/dev/tty");
+      const output = createWriteStream("/dev/tty");
+      const rl = readline.createInterface({ input, output });
+      const close = () => {
+        rl.close();
+        input.destroy();
+        output.end();
+      };
+      return { rl, close };
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+};
+var promptYesNoSingleKey = async () => {
+  const stdin = process.stdin;
+  const supportsRaw = isRawModeSupported();
+  const previousRaw = supportsRaw ? stdin.isRaw === true : false;
+  const wasPaused = stdin.isPaused();
+  return await new Promise((resolve2) => {
+    const cleanup = () => {
+      stdin.removeListener("data", handleData);
+      if (wasPaused) {
+        stdin.pause();
+      }
+      if (supportsRaw) {
+        stdin.setRawMode(previousRaw);
+      }
+    };
+    const handleData = (data) => {
+      const char = data.toString();
+      const firstByte = data[0] ?? 0;
+      let result = false;
+      if (char === "y") {
+        result = true;
+      } else if (char === "n" || char === "N" || firstByte === 3 || firstByte === 27 || firstByte === 13) {
+        result = false;
+      } else {
+        result = false;
+      }
+      process.stdout.write("\n");
+      cleanup();
+      resolve2(result);
+    };
+    process.stdout.write(RAW_PROMPT_MESSAGE);
+    if (supportsRaw) {
+      stdin.setRawMode(true);
+    }
+    if (wasPaused) {
+      stdin.resume();
+    }
+    stdin.once("data", handleData);
+  });
+};
+var promptYesNoLine = async () => {
+  const prompt = createPromptInterface();
+  if (!prompt) {
+    console.error("UnityLockfile exists. No interactive console available for confirmation.");
+    return false;
+  }
+  const confirmed = await new Promise((resolve2) => {
+    prompt.rl.question(RAW_PROMPT_MESSAGE, (answer) => {
+      resolve2(answer.trim() === "y");
+    });
+  });
+  prompt.close();
+  return confirmed;
+};
+var pathExists = async (target) => {
+  try {
+    await access2(target, constants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var UnityLockChecker = class {
+  async check(projectPath) {
+    const lockfilePath = join3(projectPath, "Temp", "UnityLockfile");
+    const hasLockfile = await pathExists(lockfilePath);
+    if (!hasLockfile) {
+      return "allow";
+    }
+    console.log(`UnityLockfile found: ${lockfilePath}`);
+    console.log("Another Unity process may be using this project.");
+    const confirmed = isRawModeSupported() ? await promptYesNoSingleKey() : await promptYesNoLine();
+    if (!confirmed) {
+      console.log("Aborted by user.");
+      return "skip";
+    }
+    await rm(lockfilePath, { force: true });
+    console.log("Deleted UnityLockfile. Continuing launch.");
+    return "allow";
+  }
+};
+
+// src/presentation/App.tsx
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var extractRootFolder = (repository) => {
+  if (!repository?.root) {
+    return void 0;
+  }
+  const segments = repository.root.split("/").filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    return void 0;
+  }
+  return segments[segments.length - 1];
+};
+var formatProjectName = (project, repository, useGitRootName) => {
+  if (!useGitRootName) {
+    return `${project.title} (${project.version.value})`;
+  }
+  const rootFolder = extractRootFolder(repository);
+  if (!rootFolder) {
+    return `${project.title} (${project.version.value})`;
+  }
+  return `${rootFolder} (${project.version.value})`;
+};
+var formatBranch = (branch) => {
+  if (!branch) {
+    return "-";
+  }
+  if (branch.type === "branch") {
+    return branch.name;
+  }
+  return `detached@${branch.sha}`;
+};
+var homeDirectory = process.env.HOME ?? "";
+var homePrefix = homeDirectory ? `${homeDirectory}/` : "";
+var minimumVisibleProjectCount = 4;
+var defaultHintMessage = "Move with arrows or j/k \xB7 Launch with o \xB7 Exit with Ctrl+C twice";
+var PROJECT_COLOR = "#abd8e7";
+var BRANCH_COLOR = "#e3839c";
+var PATH_COLOR = "#719bd8";
+var shortenHomePath = (targetPath) => {
+  if (!homeDirectory) {
+    return targetPath;
+  }
+  if (targetPath === homeDirectory) {
+    return "~";
+  }
+  if (homePrefix && targetPath.startsWith(homePrefix)) {
+    return `~/${targetPath.slice(homePrefix.length)}`;
+  }
+  return targetPath;
+};
+var App = ({
+  projects,
+  onLaunch,
+  useGitRootName = true,
+  showBranch = true,
+  showPath = true
+}) => {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [visibleCount, setVisibleCount] = useState(minimumVisibleProjectCount);
+  const [index, setIndex] = useState(0);
+  const [hint, setHint] = useState("Move with j/k \xB7 Launch with o \xB7 Exit with Ctrl+C twice");
+  const [pendingExit, setPendingExit] = useState(false);
+  const linesPerProject = (showBranch ? 1 : 0) + (showPath ? 1 : 0) + 2;
+  const sortedProjects = useMemo(() => {
+    const fallbackTime = 0;
+    const toSortKey = (view) => {
+      if (useGitRootName) {
+        const rootName = extractRootFolder(view.repository);
+        if (rootName) {
+          return rootName.toLocaleLowerCase();
+        }
+      }
+      return view.project.title.toLocaleLowerCase();
+    };
+    const toTieBreaker = (view) => view.project.path.toLocaleLowerCase();
+    return [...projects].sort((a, b) => {
+      if (a.project.favorite !== b.project.favorite) {
+        return a.project.favorite ? -1 : 1;
+      }
+      const timeA = a.project.lastModified?.getTime() ?? fallbackTime;
+      const timeB = b.project.lastModified?.getTime() ?? fallbackTime;
+      if (timeA !== timeB) {
+        return timeB - timeA;
+      }
+      const keyA = toSortKey(a);
+      const keyB = toSortKey(b);
+      if (keyA === keyB) {
+        return toTieBreaker(a).localeCompare(toTieBreaker(b));
+      }
+      return keyA.localeCompare(keyB);
+    });
+  }, [projects, useGitRootName]);
+  useEffect(() => {
+    const handleSigint = () => {
+      if (!pendingExit) {
+        setPendingExit(true);
+        setHint("Press Ctrl+C again to exit");
+        setTimeout(() => {
+          setPendingExit(false);
+          setHint(defaultHintMessage);
+        }, 2e3);
+        return;
+      }
+      exit();
+    };
+    process.on("SIGINT", handleSigint);
+    return () => {
+      process.off("SIGINT", handleSigint);
+    };
+  }, [exit, pendingExit]);
+  useEffect(() => {
+    const updateVisibleCount = () => {
+      if (!stdout || typeof stdout.columns !== "number" || typeof stdout.rows !== "number") {
+        setVisibleCount(minimumVisibleProjectCount);
+        return;
+      }
+      const reservedRows = 6;
+      const availableRows = stdout.rows - reservedRows;
+      const rowsPerProject = Math.max(linesPerProject, 1);
+      const calculatedCount = Math.max(
+        minimumVisibleProjectCount,
+        Math.floor(availableRows / rowsPerProject)
+      );
+      setVisibleCount(calculatedCount);
+    };
+    updateVisibleCount();
+    stdout?.on("resize", updateVisibleCount);
+    return () => {
+      stdout?.off("resize", updateVisibleCount);
+    };
+  }, [linesPerProject, stdout]);
+  const move = useCallback(
+    (delta) => {
+      setIndex((prev) => {
+        if (sortedProjects.length === 0) {
+          return 0;
+        }
+        let next = prev + delta;
+        if (next < 0) {
+          next = 0;
+        }
+        if (next >= sortedProjects.length) {
+          next = sortedProjects.length - 1;
+        }
+        return next;
+      });
+    },
+    [sortedProjects.length]
+  );
+  const launchSelected = useCallback(async () => {
+    const project = sortedProjects[index]?.project;
+    if (!project) {
+      return;
+    }
+    try {
+      await onLaunch(project);
+      setHint(`Launched Unity: ${project.title}`);
+      setTimeout(() => {
+        setHint(defaultHintMessage);
+      }, 2e3);
+    } catch (error) {
+      if (error instanceof LaunchCancelledError) {
+        setHint("Launch cancelled");
+        setTimeout(() => {
+          setHint(defaultHintMessage);
+        }, 3e3);
+        return;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      setHint(`Failed to launch: ${message}`);
+      setTimeout(() => {
+        setHint(defaultHintMessage);
+      }, 3e3);
+    }
+  }, [index, onLaunch, sortedProjects]);
+  useInput((input, key) => {
+    if (input === "j" || key.downArrow) {
+      move(1);
+    }
+    if (input === "k" || key.upArrow) {
+      move(-1);
+    }
+    if (input === "o") {
+      void launchSelected();
+    }
+  });
+  const { startIndex, visibleProjects } = useMemo(() => {
+    const limit = Math.max(minimumVisibleProjectCount, visibleCount);
+    if (sortedProjects.length <= limit) {
+      return {
+        startIndex: 0,
+        endIndex: sortedProjects.length,
+        visibleProjects: sortedProjects
+      };
+    }
+    const halfWindow = Math.floor(limit / 2);
+    let start = index - halfWindow;
+    let end = index + halfWindow + limit % 2;
+    if (start < 0) {
+      start = 0;
+      end = limit;
+    }
+    if (end > sortedProjects.length) {
+      end = sortedProjects.length;
+      start = Math.max(0, end - limit);
+    }
+    return {
+      startIndex: start,
+      visibleProjects: sortedProjects.slice(start, end)
+    };
+  }, [index, sortedProjects, visibleCount]);
+  const scrollbarChars = useMemo(() => {
+    const totalProjects = projects.length;
+    const totalLines = totalProjects * linesPerProject;
+    const windowProjects = visibleProjects.length;
+    const visibleLines = windowProjects * linesPerProject;
+    if (totalLines === 0 || visibleLines === 0) {
+      return [];
+    }
+    if (totalLines <= visibleLines) {
+      return Array.from({ length: visibleLines }, () => "\u2588");
+    }
+    const trackLength = visibleLines;
+    const sliderSize = Math.max(1, Math.round(visibleLines / totalLines * trackLength));
+    const maxSliderStart = Math.max(0, trackLength - sliderSize);
+    const topLine = startIndex * linesPerProject;
+    const denominator = Math.max(1, totalLines - visibleLines);
+    const sliderStart = Math.min(
+      maxSliderStart,
+      Math.round(topLine / denominator * maxSliderStart)
+    );
+    return Array.from({ length: trackLength }, (_, position) => {
+      if (position >= sliderStart && position < sliderStart + sliderSize) {
+        return "\u2588";
+      }
+      return "|";
+    });
+  }, [linesPerProject, projects.length, startIndex, visibleProjects]);
+  const rows = useMemo(() => {
+    return visibleProjects.map(({ project, repository }, offset) => {
+      const rowIndex = startIndex + offset;
+      const isSelected = rowIndex === index;
+      const arrow = isSelected ? ">" : " ";
+      const titleLine = formatProjectName(project, repository, useGitRootName);
+      const pathLine = shortenHomePath(project.path);
+      const branchLine = formatBranch(repository?.branch);
+      const baseScrollbarIndex = offset * linesPerProject;
+      const titleScrollbar = scrollbarChars[baseScrollbarIndex] ?? " ";
+      const branchScrollbar = showBranch ? scrollbarChars[baseScrollbarIndex + 1] ?? " " : " ";
+      const pathScrollbar = showPath ? scrollbarChars[baseScrollbarIndex + 1 + (showBranch ? 1 : 0)] ?? " " : " ";
+      const spacerScrollbar = scrollbarChars[baseScrollbarIndex + linesPerProject - 1] ?? " ";
+      const versionStart = titleLine.indexOf("(");
+      const versionText = versionStart >= 0 ? titleLine.slice(versionStart) : "";
+      const nameText = versionStart >= 0 ? titleLine.slice(0, versionStart).trimEnd() : titleLine;
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsxs(Box, { flexGrow: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: isSelected ? "green" : PROJECT_COLOR, bold: true, children: [
+              arrow,
+              " ",
+              nameText
+            ] }),
+            versionText ? /* @__PURE__ */ jsxs(Text, { color: isSelected ? "green" : void 0, children: [
+              " ",
+              versionText
+            ] }) : null
+          ] }),
+          showBranch ? /* @__PURE__ */ jsxs(Text, { color: isSelected ? "green" : BRANCH_COLOR, children: [
+            "  ",
+            branchLine
+          ] }) : null,
+          showPath ? /* @__PURE__ */ jsxs(Text, { color: isSelected ? "green" : PATH_COLOR, children: [
+            "  ",
+            pathLine
+          ] }) : null,
+          /* @__PURE__ */ jsx(Text, { children: " " })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { marginLeft: 1, width: 1, flexDirection: "column", alignItems: "center", children: [
+          /* @__PURE__ */ jsx(Text, { children: titleScrollbar }),
+          showBranch ? /* @__PURE__ */ jsx(Text, { children: branchScrollbar }) : null,
+          showPath ? /* @__PURE__ */ jsx(Text, { children: pathScrollbar }) : null,
+          /* @__PURE__ */ jsx(Text, { children: spacerScrollbar })
+        ] })
+      ] }, project.id);
+    });
+  }, [index, scrollbarChars, showBranch, showPath, startIndex, useGitRootName, visibleProjects]);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", children: rows.length === 0 ? /* @__PURE__ */ jsx(Text, { children: "Unity Hub\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3067\u3057\u305F" }) : rows }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: hint }) })
+  ] });
+};
+
+// src/index.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var bootstrap = async () => {
+  const unityHubReader = new UnityHubProjectsReader();
+  const gitRepositoryInfoReader = new GitRepositoryInfoReader();
+  const listProjectsUseCase = new ListProjectsUseCase(
+    unityHubReader,
+    gitRepositoryInfoReader,
+    unityHubReader
+  );
+  const editorPathResolver = new MacEditorPathResolver();
+  const processLauncher = new NodeProcessLauncher();
+  const lockChecker = new UnityLockChecker();
+  const launchProjectUseCase = new LaunchProjectUseCase(
+    editorPathResolver,
+    processLauncher,
+    unityHubReader,
+    unityHubReader,
+    lockChecker
+  );
+  const useGitRootName = !process2.argv.includes("--no-git-root-name");
+  const showBranch = !process2.argv.includes("--hide-branch");
+  const showPath = !process2.argv.includes("--hide-path");
+  try {
+    const projects = await listProjectsUseCase.execute();
+    render(
+      /* @__PURE__ */ jsx2(
+        App,
+        {
+          projects,
+          onLaunch: (project) => launchProjectUseCase.execute(project),
+          useGitRootName,
+          showBranch,
+          showPath
+        }
+      )
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process2.exitCode = 1;
+  }
+};
+await bootstrap();

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "unity-hub-cli",
+  "version": "0.1.0",
+  "description": "A CLI tool that reads Unity Hub's projects and launches Unity Editor with an interactive TUI",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "tsx src/index.ts",
+    "build": "tsup",
+    "start": "node dist/index.js",
+    "lint": "eslint . --ext .ts,.tsx",
+    "lint:fix": "eslint . --ext .ts,.tsx --fix",
+    "format": "prettier --write .",
+    "typecheck": "tsc -noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hatayama/UnityHubCli.git"
+  },
+  "keywords": [
+    "unity",
+    "unity-hub",
+    "cli",
+    "tui",
+    "ink",
+    "terminal",
+    "interactive"
+  ],
+  "author": "masamichi hatayama",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "unity-hub-cli": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "ink": "^4.4.1",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.20",
+    "@types/react": "^18.3.26",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.2",
+    "eslint-import-resolver-typescript": "^3.10.1",
+    "eslint-plugin-import": "^2.32.0",
+    "prettier": "^3.6.2",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  }
+}