@kzheart_/mc-pilot 0.9.0 → 0.9.2

package/dist/util/global-state.js

@@ -6,6 +6,12 @@ export class GlobalStateStore extends StateStore {
     constructor() {
         super(resolveGlobalStateDir());
     }
+    async withClientLock(task) {
+        return this.withLock("clients", task);
+    }
+    async withServerLock(task) {
+        return this.withLock("servers", task);
+    }
     async readServerState() {
         return this.readJson(SERVERS_STATE_FILE, { servers: {} });
     }
@@ -18,4 +24,20 @@ export class GlobalStateStore extends StateStore {
     async writeClientState(state) {
         await this.writeJson(CLIENTS_STATE_FILE, state);
     }
+    async updateClientState(mutate) {
+        return this.withClientLock(async () => {
+            const state = await this.readClientState();
+            const result = await mutate(state);
+            await this.writeClientState(state);
+            return result;
+        });
+    }
+    async updateServerState(mutate) {
+        return this.withServerLock(async () => {
+            const state = await this.readServerState();
+            const result = await mutate(state);
+            await this.writeServerState(state);
+            return result;
+        });
+    }
 }

package/dist/util/instance-types.d.ts

@@ -16,6 +16,7 @@ export interface ClientInstanceMeta {
     wsPort: number;
     account?: string;
     headless?: boolean;
+    mute?: boolean;
     launchArgs?: string[];
     env?: Record<string, string>;
     createdAt: string;

package/dist/util/net.d.ts

@@ -1,3 +1,4 @@
+export declare function isTcpPortReachable(host: string, port: number): Promise<boolean>;
 export declare function waitForTcpPort(host: string, port: number, timeoutSeconds: number): Promise<{
     reachable: boolean;
     host: string;

package/dist/util/net.js

@@ -5,21 +5,23 @@ function wait(ms) {
         setTimeout(resolve, ms);
     });
 }
+export async function isTcpPortReachable(host, port) {
+    return await new Promise((resolve) => {
+        const socket = net.createConnection({ host, port });
+        socket.once("connect", () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once("error", () => {
+            socket.destroy();
+            resolve(false);
+        });
+    });
+}
 export async function waitForTcpPort(host, port, timeoutSeconds) {
     const deadline = Date.now() + timeoutSeconds * 1000;
     while (Date.now() < deadline) {
-        const reachable = await new Promise((resolve) => {
-            const socket = net.createConnection({ host, port });
-            socket.once("connect", () => {
-                socket.destroy();
-                resolve(true);
-            });
-            socket.once("error", () => {
-                socket.destroy();
-                resolve(false);
-            });
-        });
-        if (reachable) {
+        if (await isTcpPortReachable(host, port)) {
             return {
                 reachable: true,
                 host,

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.9.0",
+  "version": "0.9.2",
   "description": "Minecraft plugin/mod automated testing CLI – control a real Minecraft client to simulate player actions",
   "type": "module",
   "bin": {
@@ -44,10 +44,12 @@
     "@xmcl/file-transfer": "^2.0.3",
     "@xmcl/installer": "^6.1.2",
     "commander": "^14.0.1",
+    "pngjs": "^7.0.0",
     "ws": "^8.19.0"
   },
   "devDependencies": {
     "@types/node": "^24.5.2",
+    "@types/pngjs": "^6.0.5",
     "@types/ws": "^8.18.1",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2"

package/scripts/launch-fabric-client.mjs

@@ -106,6 +106,21 @@ function substitute(template, variables) {
   return template.replace(/\$\{([^}]+)\}/g, (_, key) => variables[key] ?? "");
 }
 
+function parseOptionalBoolean(value) {
+  if (value === undefined || value === null || value === "") {
+    return undefined;
+  }
+
+  const normalized = String(value).trim().toLowerCase();
+  if (["true", "1", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["false", "0", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return undefined;
+}
+
 async function ensureFile(filePath, downloadUrl) {
   try {
     await access(filePath);
@@ -126,9 +141,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);
 
@@ -162,7 +185,7 @@ async function syncConfiguredMod(gameDir) {
   await copyFile(sourceJar, targetJar);
 }
 
-async function ensureAutomationOptions(gameDir, server) {
+async function ensureAutomationOptions(gameDir, server, mute) {
   const optionsPath = path.join(gameDir, "options.txt");
   const values = new Map();
 
@@ -183,6 +206,23 @@ async function ensureAutomationOptions(gameDir, server) {
   values.set("joinedFirstServer", "true");
   values.set("tutorialStep", "none");
   values.set("pauseOnLostFocus", "false");
+  if (mute !== undefined) {
+    const volume = mute ? "0.0" : "1.0";
+    for (const category of [
+      "master",
+      "music",
+      "record",
+      "weather",
+      "block",
+      "hostile",
+      "neutral",
+      "player",
+      "ambient",
+      "voice"
+    ]) {
+      values.set(`soundCategory_${category}`, volume);
+    }
+  }
   if (server) {
     values.set("lastServer", server);
   }
@@ -193,7 +233,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 +246,8 @@ 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);
+  const mute = parseOptionalBoolean(process.env.MCT_CLIENT_MUTE);
+  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`);
@@ -255,7 +296,7 @@ async function buildLaunchSpec(options) {
   const accountName = process.env.MCT_CLIENT_ACCOUNT || options.account || "TEST1";
   const accountUuid = offlineUuid(accountName);
   const server = process.env.MCT_CLIENT_SERVER || "";
-  await ensureAutomationOptions(gameDir, server);
+  await ensureAutomationOptions(gameDir, server, mute);
   const [serverHost, serverPort = "25565"] = server.split(":");
   const classpath = [
     path.join(librariesRoot, mainJarPath),
@@ -308,12 +349,13 @@ async function buildManifestLaunchSpec(options) {
 
   const manifest = await readJson(manifestPath);
   const gameDir = manifest.gameDir;
+  const mute = parseOptionalBoolean(process.env.MCT_CLIENT_MUTE);
   await syncConfiguredMod(gameDir);
 
   const accountName = process.env.MCT_CLIENT_ACCOUNT || options.account || "TEST1";
   const accountUuid = offlineUuid(accountName);
   const server = process.env.MCT_CLIENT_SERVER || "";
-  await ensureAutomationOptions(gameDir, server);
+  await ensureAutomationOptions(gameDir, server, mute);
   const [serverHost, serverPort = "25565"] = server.split(":");
   const substitutions = {
     auth_player_name: accountName,