@aefree/pi-unity 0.9.0

package/src/unity-projects.ts

@@ -0,0 +1,174 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { parseUnityVersionText, resolveAbsolutePath } from "./unity-core";
+
+export type UnityProjectCandidate = {
+  projectRoot: string;
+  projectName: string;
+  unityVersion: string;
+};
+
+export type UnityProjectDiscoveryResult = {
+  candidates: UnityProjectCandidate[];
+  visitedDirectories: number;
+  truncated: boolean;
+};
+
+export type DiscoverUnityProjectsOptions = {
+  maxDepth?: number;
+  maxDirectories?: number;
+  maxCandidates?: number;
+};
+
+const DEFAULT_DISCOVERY_OPTIONS: Required<DiscoverUnityProjectsOptions> = {
+  maxDepth: 4,
+  maxDirectories: 400,
+  maxCandidates: 20,
+};
+
+const SKIPPED_DIRECTORY_NAMES = new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".vs",
+  ".idea",
+  ".pi",
+  "Library",
+  "Temp",
+  "Logs",
+  "obj",
+  "node_modules",
+  "Build",
+  "Builds",
+  "bin",
+]);
+
+async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function readUnityVersion(projectRoot: string): Promise<string> {
+  const versionFile = path.join(projectRoot, "ProjectSettings", "ProjectVersion.txt");
+  const contents = await fs.readFile(versionFile, "utf8");
+  const version = parseUnityVersionText(contents);
+  if (!version) {
+    throw new Error(`Could not parse Unity version from ${versionFile}`);
+  }
+  return version;
+}
+
+export async function isUnityProjectRoot(dirPath: string): Promise<boolean> {
+  const versionFile = path.join(dirPath, "ProjectSettings", "ProjectVersion.txt");
+  if (!(await pathExists(versionFile))) {
+    return false;
+  }
+
+  const assetsDir = path.join(dirPath, "Assets");
+  const manifestFile = path.join(dirPath, "Packages", "manifest.json");
+  return (await pathExists(assetsDir)) || (await pathExists(manifestFile));
+}
+
+export async function findAncestorUnityProject(startDir: string): Promise<UnityProjectCandidate | null> {
+  let current = path.resolve(startDir);
+
+  while (true) {
+    if (await isUnityProjectRoot(current)) {
+      return {
+        projectRoot: current,
+        projectName: path.basename(current),
+        unityVersion: await readUnityVersion(current),
+      };
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+export async function discoverUnityProjects(
+  startDir: string,
+  options: DiscoverUnityProjectsOptions = {},
+): Promise<UnityProjectDiscoveryResult> {
+  const { maxDepth, maxDirectories, maxCandidates } = { ...DEFAULT_DISCOVERY_OPTIONS, ...options };
+  const root = path.resolve(startDir);
+  const queue: Array<{ dir: string; depth: number }> = [{ dir: root, depth: 0 }];
+  const visited = new Set<string>();
+  const candidates: UnityProjectCandidate[] = [];
+  let visitedDirectories = 0;
+  let truncated = false;
+
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (!next) break;
+
+    const normalized = path.normalize(next.dir);
+    if (visited.has(normalized)) continue;
+    visited.add(normalized);
+    visitedDirectories += 1;
+
+    if (visitedDirectories > maxDirectories) {
+      truncated = true;
+      break;
+    }
+
+    if (await isUnityProjectRoot(next.dir)) {
+      candidates.push({
+        projectRoot: next.dir,
+        projectName: path.basename(next.dir),
+        unityVersion: await readUnityVersion(next.dir),
+      });
+      if (candidates.length >= maxCandidates) {
+        truncated = true;
+        break;
+      }
+      continue;
+    }
+
+    if (next.depth >= maxDepth) {
+      continue;
+    }
+
+    let entries: fs.Dirent[] = [];
+    try {
+      entries = await fs.readdir(next.dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (SKIPPED_DIRECTORY_NAMES.has(entry.name)) continue;
+      queue.push({ dir: path.join(next.dir, entry.name), depth: next.depth + 1 });
+    }
+  }
+
+  candidates.sort((left, right) => left.projectRoot.localeCompare(right.projectRoot));
+  return { candidates, visitedDirectories, truncated };
+}
+
+export async function resolveUnityProjectCandidates(cwd: string, requestedPath?: string): Promise<UnityProjectDiscoveryResult> {
+  if (requestedPath?.trim()) {
+    const absolutePath = resolveAbsolutePath(cwd, requestedPath);
+    const directProject = await findAncestorUnityProject(absolutePath);
+    if (directProject) {
+      return { candidates: [directProject], visitedDirectories: 0, truncated: false };
+    }
+
+    return discoverUnityProjects(absolutePath);
+  }
+
+  const ancestorProject = await findAncestorUnityProject(cwd);
+  if (ancestorProject) {
+    return { candidates: [ancestorProject], visitedDirectories: 0, truncated: false };
+  }
+
+  return discoverUnityProjects(cwd);
+}

package/src/unity-test-batch.ts

@@ -0,0 +1,82 @@
+import { randomUUID } from "node:crypto";
+import * as path from "node:path";
+
+export type UnityTestPlatform = "EditMode" | "PlayMode";
+
+export type UnityTestBatchPlanInput = {
+  projectRoot: string;
+  testPlatform: UnityTestPlatform;
+  testFilters?: string[];
+  testCategories?: string[];
+  now?: Date;
+  token?: string;
+  pathApi?: Pick<typeof path, "resolve" | "join" | "isAbsolute" | "relative" | "sep">;
+};
+
+export type UnityTestBatchPlan = {
+  testPlatform: UnityTestPlatform;
+  testFilters: string[];
+  testCategories: string[];
+  testResultsPath: string;
+  logFilePath: string;
+  args: string[];
+};
+
+function normalizeSelectors(values: string[] | undefined, label: string): string[] {
+  const normalized: string[] = [];
+  const seen = new Set<string>();
+  for (const [index, raw] of (values ?? []).entries()) {
+    const value = raw.trim();
+    if (!value) throw new Error(`${label}[${index}] must not be empty or whitespace-only.`);
+    if (/[\0\r\n;]/.test(value)) {
+      throw new Error(`${label}[${index}] must not contain NUL, newlines, or semicolons; pass separate selectors as separate array entries.`);
+    }
+    if (!seen.has(value)) {
+      seen.add(value);
+      normalized.push(value);
+    }
+  }
+  return normalized;
+}
+
+function safeTimestamp(date: Date): string {
+  return date.toISOString().replace(/[-:.]/g, "");
+}
+
+function safeToken(value: string): string {
+  const token = value.replace(/[^A-Za-z0-9]/g, "").slice(0, 16);
+  if (!token) throw new Error("Unity test batch token must contain at least one ASCII letter or digit.");
+  return token;
+}
+
+export function createUnityTestBatchPlan(input: UnityTestBatchPlanInput): UnityTestBatchPlan {
+  const pathApi = input.pathApi ?? path;
+  const projectRoot = pathApi.resolve(input.projectRoot);
+  const logsRoot = pathApi.join(projectRoot, "Logs");
+  const testFilters = normalizeSelectors(input.testFilters, "testFilters");
+  const testCategories = normalizeSelectors(input.testCategories, "testCategories");
+  const token = safeToken(input.token ?? randomUUID());
+  const platformSlug = input.testPlatform.toLowerCase();
+  const basename = `unity-tests-${platformSlug}-${safeTimestamp(input.now ?? new Date())}-${token}`;
+  const testResultsPath = pathApi.join(logsRoot, `${basename}.xml`);
+  const logFilePath = pathApi.join(logsRoot, `${basename}.log`);
+  const args = ["-runTests", "-testPlatform", input.testPlatform];
+  if (testFilters.length > 0) args.push("-testFilter", testFilters.join(";"));
+  if (testCategories.length > 0) args.push("-testCategory", testCategories.join(";"));
+  args.push("-testResults", testResultsPath, "-logFile", logFilePath);
+
+  if (!pathApi.isAbsolute(testResultsPath) || !pathApi.isAbsolute(logFilePath)) {
+    throw new Error("Unity test batch artifact paths must be absolute.");
+  }
+  for (const artifactPath of [testResultsPath, logFilePath]) {
+    const relative = pathApi.relative(logsRoot, artifactPath);
+    if (relative === ".." || relative.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(relative)) {
+      throw new Error("Unity test batch artifact path escaped the project Logs directory.");
+    }
+  }
+  if (args.some((arg) => arg.toLowerCase() === "-quit" || arg.toLowerCase().startsWith("-quit="))) {
+    throw new Error("Unity test batch arguments must not contain -quit.");
+  }
+
+  return { testPlatform: input.testPlatform, testFilters, testCategories, testResultsPath, logFilePath, args };
+}