@kzheart_/mc-pilot 0.8.1 → 0.9.1

package/dist/instance/ClientInstanceManager.js

@@ -19,114 +19,107 @@ export class ClientInstanceManager {
         this.globalState = globalState;
     }
     async create(options) {
-        const instanceDir = resolveClientInstanceDir(options.name);
-        await mkdir(instanceDir, { recursive: true });
-        const wsPort = options.wsPort ?? (await this.findAvailablePort());
-        const meta = {
-            name: options.name,
-            loader: options.loader ?? "fabric",
-            mcVersion: options.version,
-            wsPort,
-            account: options.account,
-            headless: options.headless,
-            launchArgs: options.launchArgs,
-            env: options.env,
-            createdAt: new Date().toISOString()
-        };
-        await writeFile(path.join(instanceDir, INSTANCE_FILE), `${JSON.stringify(meta, null, 2)}\n`, "utf8");
-        return meta;
+        return this.globalState.withClientLock(async () => {
+            const instanceDir = resolveClientInstanceDir(options.name);
+            await mkdir(instanceDir, { recursive: true });
+            const wsPort = options.wsPort ?? (await this.findAvailablePort());
+            const meta = {
+                name: options.name,
+                loader: options.loader ?? "fabric",
+                mcVersion: options.version,
+                wsPort,
+                account: options.account,
+                headless: options.headless,
+                launchArgs: options.launchArgs,
+                env: options.env,
+                createdAt: new Date().toISOString()
+            };
+            await writeFile(path.join(instanceDir, INSTANCE_FILE), `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+            return meta;
+        });
     }
     async launch(clientName, options = {}) {
-        let state = await this.globalState.readClientState();
-        const existing = state.clients[clientName];
-        if (existing && isProcessRunning(existing.pid)) {
-            if (options.force) {
-                await this.stop(clientName);
-                state = await this.globalState.readClientState();
+        return this.globalState.withClientLock(async () => {
+            const state = await this.globalState.readClientState();
+            const existing = state.clients[clientName];
+            if (existing && isProcessRunning(existing.pid)) {
+                if (options.force) {
+                    await this.stopTrackedClient(state, clientName, existing);
+                }
+                else {
+                    throw new MctError({
+                        code: "CLIENT_ALREADY_RUNNING",
+                        message: `Client ${clientName} is already running. Pass --force to kill and relaunch.`,
+                        details: existing
+                    }, 3);
+                }
             }
-            else {
-                throw new MctError({
-                    code: "CLIENT_ALREADY_RUNNING",
-                    message: `Client ${clientName} is already running. Pass --force to kill and relaunch.`,
-                    details: existing
-                }, 3);
+            const meta = await this.loadMeta(clientName);
+            const instanceDir = resolveClientInstanceDir(clientName);
+            const wsPort = options.wsPort ?? meta.wsPort;
+            if (!meta.launchArgs || meta.launchArgs.length === 0) {
+                throw new MctError({ code: "INVALID_PARAMS", message: `Client ${clientName} has no launchArgs configured` }, 4);
             }
-        }
-        const meta = await this.loadMeta(clientName);
-        const instanceDir = resolveClientInstanceDir(clientName);
-        const wsPort = options.wsPort ?? meta.wsPort;
-        if (!meta.launchArgs || meta.launchArgs.length === 0) {
-            throw new MctError({ code: "INVALID_PARAMS", message: `Client ${clientName} has no launchArgs configured` }, 4);
-        }
-        // Kill any existing processes on the port
-        const listeningPids = getListeningPids(wsPort);
-        for (const pid of listeningPids) {
-            killProcessTree(pid);
-        }
-        if (listeningPids.length > 0) {
-            const deadline = Date.now() + 10_000;
-            while (Date.now() < deadline) {
-                if (getListeningPids(wsPort).length === 0) {
-                    break;
-                }
-                await new Promise((resolve) => setTimeout(resolve, 250));
+            const listeningPids = getListeningPids(wsPort);
+            for (const pid of listeningPids) {
+                killProcessTree(pid);
             }
-        }
-        const launchCommand = [process.execPath, getLaunchScriptPath(), ...meta.launchArgs];
-        const minecraftDir = path.join(instanceDir, "minecraft");
-        const logsDir = path.join(resolveMctHome(), "logs");
-        mkdirSync(logsDir, { recursive: true });
-        const logPath = path.join(logsDir, `client-${clientName}.log`);
-        const stdout = openSync(logPath, "a");
-        const child = spawn(launchCommand[0], launchCommand.slice(1), {
-            cwd: minecraftDir,
-            detached: true,
-            stdio: ["ignore", stdout, stdout],
-            env: {
-                ...process.env,
-                ...meta.env,
-                MCT_CLIENT_NAME: clientName,
-                MCT_CLIENT_VERSION: meta.mcVersion,
-                MCT_CLIENT_ACCOUNT: options.account ?? meta.account ?? "",
-                MCT_CLIENT_SERVER: options.server ?? "",
-                MCT_CLIENT_WS_PORT: String(wsPort),
-                MCT_CLIENT_HEADLESS: String(options.headless ?? meta.headless ?? false)
+            if (listeningPids.length > 0) {
+                const deadline = Date.now() + 10_000;
+                while (Date.now() < deadline) {
+                    if (getListeningPids(wsPort).length === 0) {
+                        break;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 250));
+                }
             }
+            const launchCommand = [process.execPath, getLaunchScriptPath(), ...meta.launchArgs];
+            const minecraftDir = path.join(instanceDir, "minecraft");
+            const logsDir = path.join(resolveMctHome(), "logs");
+            mkdirSync(logsDir, { recursive: true });
+            const logPath = path.join(logsDir, `client-${clientName}.log`);
+            const stdout = openSync(logPath, "a");
+            const child = spawn(launchCommand[0], launchCommand.slice(1), {
+                cwd: minecraftDir,
+                detached: true,
+                stdio: ["ignore", stdout, stdout],
+                env: {
+                    ...process.env,
+                    ...meta.env,
+                    MCT_CLIENT_NAME: clientName,
+                    MCT_CLIENT_VERSION: meta.mcVersion,
+                    MCT_CLIENT_ACCOUNT: options.account ?? meta.account ?? "",
+                    MCT_CLIENT_SERVER: options.server ?? "",
+                    MCT_CLIENT_WS_PORT: String(wsPort),
+                    MCT_CLIENT_HEADLESS: String(options.headless ?? meta.headless ?? false)
+                }
+            });
+            child.unref();
+            const entry = {
+                pid: child.pid ?? 0,
+                name: clientName,
+                wsPort,
+                startedAt: new Date().toISOString(),
+                logPath,
+                instanceDir
+            };
+            state.defaultClient ??= clientName;
+            state.clients[clientName] = entry;
+            await this.globalState.writeClientState(state);
+            return entry;
         });
-        child.unref();
-        const entry = {
-            pid: child.pid ?? 0,
-            name: clientName,
-            wsPort,
-            startedAt: new Date().toISOString(),
-            logPath,
-            instanceDir
-        };
-        state.defaultClient ??= clientName;
-        state.clients[clientName] = entry;
-        await this.globalState.writeClientState(state);
-        return entry;
     }
     async stop(clientName) {
-        const state = await this.globalState.readClientState();
-        const entry = state.clients[clientName];
-        if (!entry) {
-            return { stopped: false, alreadyStopped: true, name: clientName };
-        }
-        if (isProcessRunning(entry.pid)) {
-            killProcessTree(entry.pid);
-        }
-        for (const pid of getListeningPids(entry.wsPort)) {
-            if (pid !== entry.pid) {
-                killProcessTree(pid);
+        return this.globalState.withClientLock(async () => {
+            const state = await this.globalState.readClientState();
+            const entry = state.clients[clientName];
+            if (!entry) {
+                return { stopped: false, alreadyStopped: true, name: clientName };
             }
-        }
-        delete state.clients[clientName];
-        if (state.defaultClient === clientName) {
-            state.defaultClient = Object.keys(state.clients)[0];
-        }
-        await this.globalState.writeClientState(state);
-        return { stopped: true, name: clientName, pid: entry.pid };
+            await this.stopTrackedClient(state, clientName, entry);
+            await this.globalState.writeClientState(state);
+            return { stopped: true, name: clientName, pid: entry.pid };
+        });
     }
     async isAlreadyRunning(clientName) {
         const state = await this.globalState.readClientState();
@@ -340,4 +333,18 @@ export class ClientInstanceManager {
         }
         return port;
     }
+    async stopTrackedClient(state, clientName, entry) {
+        if (isProcessRunning(entry.pid)) {
+            killProcessTree(entry.pid);
+        }
+        for (const pid of getListeningPids(entry.wsPort)) {
+            if (pid !== entry.pid) {
+                killProcessTree(pid);
+            }
+        }
+        delete state.clients[clientName];
+        if (state.defaultClient === clientName) {
+            state.defaultClient = Object.keys(state.clients)[0];
+        }
+    }
 }

package/dist/instance/ServerInstanceManager.d.ts

@@ -70,6 +70,10 @@ export declare class ServerInstanceManager {
         reachable: boolean;
         host: string;
         port: number;
+        phase: string;
+        logPath: string;
+        lastLine: string | null;
+        recentLines: string[];
     }>;
     exec(serverName: string, command: string): Promise<{
         sent: boolean;
@@ -99,6 +103,7 @@ export declare class ServerInstanceManager {
         timedOut: boolean;
     }>;
     private requireRuntimeEntry;
+    private describeStartup;
     private requireRunning;
     list(): Promise<ServerInstanceMeta[]>;
     static listAll(globalState: GlobalStateStore): Promise<ServerInstanceMeta[]>;

package/dist/instance/ServerInstanceManager.js

@@ -4,11 +4,12 @@ import { spawn, execSync } from "node:child_process";
 import path from "node:path";
 import { resolveMctHome, resolveProjectDir, resolveServerInstanceDir } from "../util/paths.js";
 import { MctError } from "../util/errors.js";
-import { waitForTcpPort } from "../util/net.js";
+import { isTcpPortReachable } from "../util/net.js";
 import { isProcessRunning, killProcessTree } from "../util/process.js";
 import { copyFileIfMissing } from "../download/DownloadUtils.js";
 const INSTANCE_FILE = "instance.json";
 const ANSI_ESCAPE_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+const SERVER_READY_POLL_MS = 500;
 export function stripAnsiCodes(text) {
     return text.replace(ANSI_ESCAPE_PATTERN, "");
 }
@@ -108,7 +109,7 @@ export class ServerInstanceManager {
         // then exec java with stdin reading from the FIFO
         const child = spawn("bash", [
             "-c",
-            'exec 3<>"$MCT_STDIN_PIPE"; exec java "$@" <"$MCT_STDIN_PIPE"',
+            'exec 3<>"$MCT_STDIN_PIPE"; exec java "$@" 0<&3',
             "mct-server",
             ...jvmArgs, "-jar", jarFile, "nogui"
         ], {
@@ -206,7 +207,51 @@ export class ServerInstanceManager {
         if (!entry) {
             throw new MctError({ code: "SERVER_NOT_RUNNING", message: `Server ${stateKey} is not running` }, 5);
         }
-        return waitForTcpPort("127.0.0.1", entry.port, timeoutSeconds);
+        const deadline = Date.now() + timeoutSeconds * 1000;
+        let snapshot = await this.describeStartup(entry.logPath);
+        while (Date.now() < deadline) {
+            if (!isProcessRunning(entry.pid)) {
+                throw new MctError({
+                    code: "SERVER_EXITED",
+                    message: `Server ${stateKey} exited before becoming ready (${snapshot.phase})`,
+                    details: {
+                        pid: entry.pid,
+                        host: "127.0.0.1",
+                        port: entry.port,
+                        phase: snapshot.phase,
+                        logPath: snapshot.logPath,
+                        lastLine: snapshot.lastLine,
+                        recentLines: snapshot.recentLines
+                    }
+                }, 5);
+            }
+            if (await isTcpPortReachable("127.0.0.1", entry.port)) {
+                snapshot = await this.describeStartup(entry.logPath);
+                return {
+                    reachable: true,
+                    host: "127.0.0.1",
+                    port: entry.port,
+                    phase: snapshot.phase,
+                    logPath: snapshot.logPath,
+                    lastLine: snapshot.lastLine,
+                    recentLines: snapshot.recentLines
+                };
+            }
+            snapshot = await this.describeStartup(entry.logPath);
+            await new Promise((resolve) => setTimeout(resolve, SERVER_READY_POLL_MS));
+        }
+        throw new MctError({
+            code: "TIMEOUT",
+            message: `Timed out waiting for 127.0.0.1:${entry.port} (${snapshot.phase})`,
+            details: {
+                host: "127.0.0.1",
+                port: entry.port,
+                phase: snapshot.phase,
+                logPath: snapshot.logPath,
+                lastLine: snapshot.lastLine,
+                recentLines: snapshot.recentLines
+            }
+        }, 2);
     }
     async exec(serverName, command) {
         const entry = await this.requireRunning(serverName);
@@ -338,6 +383,21 @@ export class ServerInstanceManager {
         }
         return entry;
     }
+    async describeStartup(logPath) {
+        const raw = await readFile(logPath, "utf8").catch(() => "");
+        const recentLines = raw
+            .split(/\r?\n/)
+            .map((line) => stripAnsiCodes(line).trim())
+            .filter((line) => line.length > 0)
+            .slice(-10);
+        const lastLine = recentLines[recentLines.length - 1] ?? null;
+        return {
+            phase: detectServerStartupPhase(recentLines),
+            logPath,
+            recentLines,
+            lastLine
+        };
+    }
     async requireRunning(serverName) {
         const entry = await this.requireRuntimeEntry(serverName);
         if (!isProcessRunning(entry.pid)) {
@@ -430,3 +490,25 @@ export class ServerInstanceManager {
         return port;
     }
 }
+function detectServerStartupPhase(lines) {
+    const joined = lines.join("\n");
+    if (/Done \(.+\)! For help, type "help"/.test(joined)) {
+        return "ready";
+    }
+    if (/Preparing start region|Preparing level/.test(joined)) {
+        return "initializing-world";
+    }
+    if (/Starting Minecraft server on/.test(joined)) {
+        return "binding-port";
+    }
+    if (/Loading libraries, please wait|Starting org\.bukkit\.craftbukkit\.Main|Starting minecraft server version/.test(joined)) {
+        return "bootstrapping";
+    }
+    if (/Downloading |Applying patches/.test(joined)) {
+        return "downloading";
+    }
+    if (lines.length > 0) {
+        return "starting";
+    }
+    return "waiting-for-log";
+}

package/dist/util/command-log.d.ts

@@ -0,0 +1,12 @@
+export interface CommandLogEntry {
+    t: number;
+    iso: string;
+    argv: string[];
+    cwd: string;
+    projectId: string | null;
+    exitCode: number;
+    durationMs: number;
+    errorCode?: string;
+    errorMessage?: string;
+}
+export declare function appendCommandHistory(entry: CommandLogEntry): Promise<void>;

package/dist/util/command-log.js

@@ -0,0 +1,13 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { resolveCommandsLogPath } from "./paths.js";
+export async function appendCommandHistory(entry) {
+    try {
+        const filePath = resolveCommandsLogPath();
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await appendFile(filePath, `${JSON.stringify(entry)}\n`, "utf8");
+    }
+    catch {
+        // Never block the command on logging failure
+    }
+}

package/dist/util/command.js

@@ -5,8 +5,8 @@ import { printError, printSuccess } from "./output.js";
 export function attachGlobalOptions(command) {
     return command
         .option("--human", "Human-readable output (default: JSON)")
-        .option("--project <name>", "Project name (default: from mct.project.json)")
-        .option("--profile <name>", "Profile name (default: from mct.project.json)")
+        .option("--project <id>", "Project ID (default: derived from cwd and loaded from ~/.mct/projects/<id>/project.json)")
+        .option("--profile <name>", "Profile name (default: from ~/.mct/projects/<id>/project.json)")
         .option("--client <name>", "Target client name (required when multiple clients are running)");
 }
 export function wrapCommand(action) {

package/dist/util/context.d.ts

@@ -13,7 +13,10 @@ export interface CommandContext {
     globalState: GlobalStateStore;
     projectFile: MctProjectFile | null;
     activeProfile: MctProfile | null;
+    projectId: string | null;
     projectName: string | null;
+    projectRootDir: string | null;
+    projectConfigPath: string | null;
     timeout(key: "serverReady" | "clientReady" | "default"): number;
 }
 export declare function createCommandContext(options: GlobalOptions): Promise<CommandContext>;

package/dist/util/context.js

@@ -1,6 +1,6 @@
 import process from "node:process";
 import { GlobalStateStore } from "./global-state.js";
-import { loadProjectFile, resolveProfile } from "./project.js";
+import { loadProjectFileForCwd, loadProjectFileForId, resolveProfile } from "./project.js";
 const TIMEOUT_DEFAULTS = {
     serverReady: 120,
     clientReady: 60,
@@ -9,8 +9,12 @@ const TIMEOUT_DEFAULTS = {
 export async function createCommandContext(options) {
     const cwd = process.cwd();
     const globalState = new GlobalStateStore();
-    const projectFile = await loadProjectFile(cwd);
-    const projectName = options.project ?? projectFile?.project ?? null;
+    const resolvedProject = options.project
+        ? await loadProjectFileForId(options.project)
+        : await loadProjectFileForCwd(cwd);
+    const projectFile = resolvedProject?.projectFile ?? null;
+    const projectId = options.project ?? resolvedProject?.projectId ?? null;
+    const projectName = projectFile?.project ?? null;
     const activeProfile = projectFile
         ? resolveProfile(projectFile, options.profile)
         : null;
@@ -20,7 +24,10 @@ export async function createCommandContext(options) {
         globalState,
         projectFile,
         activeProfile,
+        projectId,
         projectName,
+        projectRootDir: projectFile?.rootDir ?? null,
+        projectConfigPath: resolvedProject?.filePath ?? null,
         timeout(key) {
             return projectFile?.timeout?.[key] ?? TIMEOUT_DEFAULTS[key];
         }

package/dist/util/global-state.d.ts

@@ -2,8 +2,12 @@ import { StateStore } from "./state.js";
 import type { GlobalClientState, GlobalServerState } from "./instance-types.js";
 export declare class GlobalStateStore extends StateStore {
     constructor();
+    withClientLock<T>(task: () => Promise<T>): Promise<T>;
+    withServerLock<T>(task: () => Promise<T>): Promise<T>;
     readServerState(): Promise<GlobalServerState>;
     writeServerState(state: GlobalServerState): Promise<void>;
     readClientState(): Promise<GlobalClientState>;
     writeClientState(state: GlobalClientState): Promise<void>;
+    updateClientState<T>(mutate: (state: GlobalClientState) => Promise<T> | T): Promise<T>;
+    updateServerState<T>(mutate: (state: GlobalServerState) => Promise<T> | T): Promise<T>;
 }

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/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/paths.d.ts

@@ -3,6 +3,8 @@ export declare function resolveClientsDir(): string;
 export declare function resolveClientInstanceDir(name: string): string;
 export declare function resolveProjectsDir(): string;
 export declare function resolveProjectDir(project: string): string;
+export declare function resolveProjectConfigPath(project: string): string;
+export declare function resolveProjectScreenshotsDir(project: string): string;
 export declare function resolveServerInstanceDir(project: string, server: string): string;
 export declare function resolveGlobalStateDir(): string;
 export declare function resolvePluginsDir(): string;

package/dist/util/paths.js

@@ -15,6 +15,12 @@ export function resolveProjectsDir() {
 export function resolveProjectDir(project) {
     return path.join(resolveProjectsDir(), project);
 }
+export function resolveProjectConfigPath(project) {
+    return path.join(resolveProjectDir(project), "project.json");
+}
+export function resolveProjectScreenshotsDir(project) {
+    return path.join(resolveProjectDir(project), "screenshots");
+}
 export function resolveServerInstanceDir(project, server) {
     return path.join(resolveProjectDir(project), server);
 }

package/dist/util/project.d.ts

@@ -4,7 +4,9 @@ export interface MctProfile {
     deployPlugins?: string[];
 }
 export interface MctProjectFile {
+    projectId: string;
     project: string;
+    rootDir: string;
     profiles: Record<string, MctProfile>;
     defaultProfile?: string;
     screenshot?: {
@@ -16,8 +18,18 @@ export interface MctProjectFile {
         default?: number;
     };
 }
-export declare const PROJECT_FILE_NAME = "mct.project.json";
-export declare function resolveProjectFilePath(cwd: string): string;
-export declare function loadProjectFile(cwd: string): Promise<MctProjectFile | null>;
-export declare function writeProjectFile(cwd: string, project: MctProjectFile): Promise<void>;
+export interface ResolvedProjectConfig {
+    projectId: string;
+    filePath: string;
+    projectFile: MctProjectFile;
+}
+export declare const PROJECT_FILE_NAME = "project.json";
+export declare function normalizeProjectRoot(cwd: string): string;
+export declare function slugifyProjectId(cwd: string): string;
+export declare function resolveProjectFilePath(projectId: string): string;
+export declare function loadProjectFileById(projectId: string): Promise<MctProjectFile | null>;
+export declare function loadProjectFileForCwd(cwd: string): Promise<ResolvedProjectConfig | null>;
+export declare function loadProjectFileForId(projectId: string): Promise<ResolvedProjectConfig | null>;
+export declare function writeProjectFile(projectId: string, project: MctProjectFile): Promise<void>;
+export declare function createDefaultProjectFile(cwd: string, projectName: string): MctProjectFile;
 export declare function resolveProfile(projectFile: MctProjectFile, profileName?: string): MctProfile | null;