@kzheart_/mc-pilot 0.8.1 → 0.9.1

package/dist/util/project.js

@@ -1,11 +1,24 @@
-import { access, readFile, writeFile } from "node:fs/promises";
+import { realpathSync } from "node:fs";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-export const PROJECT_FILE_NAME = "mct.project.json";
-export function resolveProjectFilePath(cwd) {
-    return path.join(cwd, PROJECT_FILE_NAME);
+import { resolveProjectConfigPath, resolveProjectScreenshotsDir } from "./paths.js";
+export const PROJECT_FILE_NAME = "project.json";
+export function normalizeProjectRoot(cwd) {
+    try {
+        return realpathSync(cwd);
+    }
+    catch {
+        return path.resolve(cwd);
+    }
 }
-export async function loadProjectFile(cwd) {
-    const filePath = resolveProjectFilePath(cwd);
+export function slugifyProjectId(cwd) {
+    return cwd.replace(/[^A-Za-z0-9._-]/g, "-").replace(/-+/g, "-");
+}
+export function resolveProjectFilePath(projectId) {
+    return resolveProjectConfigPath(projectId);
+}
+export async function loadProjectFileById(projectId) {
+    const filePath = resolveProjectFilePath(projectId);
     try {
         await access(filePath);
     }
@@ -15,10 +28,52 @@ export async function loadProjectFile(cwd) {
     const raw = await readFile(filePath, "utf8");
     return JSON.parse(raw);
 }
-export async function writeProjectFile(cwd, project) {
-    const filePath = resolveProjectFilePath(cwd);
+export async function loadProjectFileForCwd(cwd) {
+    const projectId = slugifyProjectId(normalizeProjectRoot(cwd));
+    const projectFile = await loadProjectFileById(projectId);
+    if (!projectFile) {
+        return null;
+    }
+    return {
+        projectId,
+        filePath: resolveProjectFilePath(projectId),
+        projectFile
+    };
+}
+export async function loadProjectFileForId(projectId) {
+    const projectFile = await loadProjectFileById(projectId);
+    if (!projectFile) {
+        return null;
+    }
+    return {
+        projectId,
+        filePath: resolveProjectFilePath(projectId),
+        projectFile
+    };
+}
+export async function writeProjectFile(projectId, project) {
+    const filePath = resolveProjectFilePath(projectId);
+    await mkdir(path.dirname(filePath), { recursive: true });
     await writeFile(filePath, `${JSON.stringify(project, null, 2)}\n`, "utf8");
 }
+export function createDefaultProjectFile(cwd, projectName) {
+    const rootDir = normalizeProjectRoot(cwd);
+    const projectId = slugifyProjectId(rootDir);
+    return {
+        projectId,
+        project: projectName,
+        rootDir,
+        profiles: {},
+        screenshot: {
+            outputDir: resolveProjectScreenshotsDir(projectId)
+        },
+        timeout: {
+            serverReady: 120,
+            clientReady: 60,
+            default: 10
+        }
+    };
+}
 export function resolveProfile(projectFile, profileName) {
     const name = profileName ?? projectFile.defaultProfile;
     if (!name) {

package/dist/util/state.d.ts

@@ -6,5 +6,10 @@ export declare class StateStore {
     readJson<T>(name: string, fallback: T): Promise<T>;
     writeJson(name: string, value: unknown): Promise<void>;
     remove(name: string): Promise<void>;
+    withLock<T>(name: string, task: () => Promise<T>, options?: {
+        timeoutMs?: number;
+        staleMs?: number;
+    }): Promise<T>;
+    private cleanupStaleLock;
 }
 export declare function resolveStateDir(stateDir: string | undefined, cwd: string): string;

package/dist/util/state.js

@@ -1,5 +1,22 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
+import process from "node:process";
+const DEFAULT_LOCK_TIMEOUT_MS = 15_000;
+const DEFAULT_LOCK_STALE_MS = 60_000;
+const LOCK_POLL_INTERVAL_MS = 50;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isPidRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export class StateStore {
     rootDir;
     constructor(rootDir) {
@@ -25,12 +42,74 @@ export class StateStore {
     async writeJson(name, value) {
         await this.ensure();
         const target = path.join(this.rootDir, name);
+        const tempTarget = `${target}.${process.pid}.${randomUUID()}.tmp`;
         const content = JSON.stringify(value, null, 2);
-        await writeFile(target, `${content}\n`, "utf8");
+        await writeFile(tempTarget, `${content}\n`, "utf8");
+        await rename(tempTarget, target);
     }
     async remove(name) {
         await rm(path.join(this.rootDir, name), { force: true });
     }
+    async withLock(name, task, options = {}) {
+        await this.ensure();
+        const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS);
+        const staleMs = options.staleMs ?? DEFAULT_LOCK_STALE_MS;
+        const safeName = name.replace(/[\\/]/g, "-");
+        const lockDir = path.join(this.rootDir, `${safeName}.lock`);
+        const ownerPath = path.join(lockDir, "owner.json");
+        while (true) {
+            try {
+                await mkdir(lockDir);
+                const owner = {
+                    pid: process.pid,
+                    acquiredAt: new Date().toISOString(),
+                    acquiredAtMs: Date.now()
+                };
+                await writeFile(ownerPath, `${JSON.stringify(owner, null, 2)}\n`, "utf8");
+                break;
+            }
+            catch (error) {
+                const lockExists = typeof error === "object"
+                    && error !== null
+                    && "code" in error
+                    && error.code === "EEXIST";
+                if (!lockExists) {
+                    throw error;
+                }
+                if (await this.cleanupStaleLock(lockDir, ownerPath, staleMs)) {
+                    continue;
+                }
+                if (Date.now() >= deadline) {
+                    throw new Error(`Timed out waiting for lock ${safeName}`);
+                }
+                await sleep(LOCK_POLL_INTERVAL_MS);
+            }
+        }
+        try {
+            return await task();
+        }
+        finally {
+            await rm(lockDir, { recursive: true, force: true });
+        }
+    }
+    async cleanupStaleLock(lockDir, ownerPath, staleMs) {
+        try {
+            const raw = await readFile(ownerPath, "utf8");
+            const owner = JSON.parse(raw);
+            const pid = Number(owner.pid);
+            const acquiredAtMs = typeof owner.acquiredAtMs === "number" ? owner.acquiredAtMs : NaN;
+            const ownerAlive = Number.isInteger(pid) && pid > 0 ? isPidRunning(pid) : false;
+            const isStale = Number.isFinite(acquiredAtMs) && Date.now() - acquiredAtMs > staleMs;
+            if (!ownerAlive || isStale) {
+                await rm(lockDir, { recursive: true, force: true });
+                return true;
+            }
+        }
+        catch {
+            // The owner file may not exist yet while another process is finalizing lock acquisition.
+        }
+        return false;
+    }
 }
 export function resolveStateDir(stateDir, cwd) {
     if (!stateDir) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kzheart_/mc-pilot",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "description": "Minecraft plugin/mod automated testing CLI – control a real Minecraft client to simulate player actions",
   "type": "module",
   "bin": {

package/scripts/launch-fabric-client.mjs

@@ -126,9 +126,17 @@ async function readJson(filePath) {
   return JSON.parse(await readFile(filePath, "utf8"));
 }
 
-async function syncBuiltMod(instanceRoot, repoRoot, variantId) {
-  const artifactName = `mct-client-mod-${variantId.endsWith("-fabric") ? "fabric" : variantId.split("-").pop()}-${variantId.replace(/-fabric$|-forge$|-neoforge$/, "")}.jar`;
-  const sourceJar = path.join(repoRoot, "client-mod", "versions", variantId, "build", "libs", artifactName);
+function getLocalBuildArtifactPath(repoRoot, variant) {
+  const artifactName = `mct-client-mod-${variant.loader ?? "fabric"}-${variant.minecraftVersion}.jar`;
+  const gradleModule = variant.gradleModule || `version-${variant.minecraftVersion}`;
+  return {
+    artifactName,
+    sourceJar: path.join(repoRoot, "client-mod", gradleModule, "build", "libs", artifactName)
+  };
+}
+
+async function syncBuiltMod(instanceRoot, repoRoot, variant) {
+  const { artifactName, sourceJar } = getLocalBuildArtifactPath(repoRoot, variant);
   const targetDir = path.join(instanceRoot, "minecraft", "mods");
   const targetJar = path.join(targetDir, artifactName);
 
@@ -193,7 +201,7 @@ async function ensureAutomationOptions(gameDir, server) {
 }
 
 async function buildLaunchSpec(options) {
-  const repoRoot = process.cwd();
+  const repoRoot = path.resolve(__dirname, "..", "..");
   const defaultVariant = getDefaultVariant();
   const minecraftVersion = process.env.MCT_CLIENT_VERSION || options["minecraft-version"] || defaultVariant.minecraftVersion;
   const modVariantId = process.env.MCT_CLIENT_MOD_VARIANT || options["mod-variant"] || `${minecraftVersion}-fabric`;
@@ -206,7 +214,7 @@ async function buildLaunchSpec(options) {
   const nativesDir = options["natives-dir"] || path.join(instanceRoot, "natives");
   const gameDir = path.join(instanceRoot, "minecraft");
   const packMeta = await readJson(path.join(instanceRoot, "mmc-pack.json"));
-  await syncBuiltMod(instanceRoot, repoRoot, modVariantId);
+  await syncBuiltMod(instanceRoot, repoRoot, selectedVariant);
   const componentMetas = new Map();
   for (const component of packMeta.components) {
     const componentMetaPath = path.join(metaRoot, component.uid, `${component.version}.json`);