@kzheart_/mc-pilot 0.1.6 → 0.2.0

package/dist/instance/ServerInstanceManager.d.ts

@@ -0,0 +1,70 @@
+import type { GlobalStateStore } from "../util/global-state.js";
+import type { ServerInstanceMeta, ServerRuntimeEntry, ServerType } from "../util/instance-types.js";
+export interface CreateServerOptions {
+    name: string;
+    project: string;
+    type: ServerType;
+    version: string;
+    port?: number;
+    jvmArgs?: string[];
+    eula?: boolean;
+    cachedJarPath?: string;
+}
+export interface StartServerOptions {
+    eula?: boolean;
+    jvmArgs?: string[];
+}
+export declare class ServerInstanceManager {
+    private readonly globalState;
+    private readonly project;
+    constructor(globalState: GlobalStateStore, project: string);
+    create(options: CreateServerOptions): Promise<ServerInstanceMeta>;
+    start(serverName: string, options?: StartServerOptions): Promise<ServerRuntimeEntry & {
+        running: true;
+    }>;
+    stop(serverName: string): Promise<{
+        running: boolean;
+        stopped: boolean;
+        pid?: undefined;
+    } | {
+        running: boolean;
+        stopped: boolean;
+        pid: number;
+    }>;
+    status(serverName?: string): Promise<{
+        [key: string]: unknown;
+        running: boolean;
+    }[] | {
+        running: boolean;
+    } | {
+        pid: number;
+        project: string;
+        name: string;
+        port: number;
+        startedAt: string;
+        logPath: string;
+        instanceDir: string;
+        running: boolean;
+        stale: boolean;
+    } | {
+        pid: number;
+        project: string;
+        name: string;
+        port: number;
+        startedAt: string;
+        logPath: string;
+        instanceDir: string;
+        running: boolean;
+    }>;
+    waitReady(serverName: string, timeoutSeconds: number): Promise<{
+        reachable: boolean;
+        host: string;
+        port: number;
+    }>;
+    list(): Promise<ServerInstanceMeta[]>;
+    static listAll(globalState: GlobalStateStore): Promise<ServerInstanceMeta[]>;
+    deploy(serverName: string, jarPaths: string[], cwd: string): Promise<string[]>;
+    loadMeta(serverName: string): Promise<ServerInstanceMeta>;
+    private findJarFile;
+    private findAvailablePort;
+}

package/dist/instance/ServerInstanceManager.js

@@ -0,0 +1,223 @@
+import { copyFile, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { mkdirSync, openSync } from "node:fs";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { resolveProjectDir, resolveServerInstanceDir } from "../util/paths.js";
+import { MctError } from "../util/errors.js";
+import { waitForTcpPort } from "../util/net.js";
+import { isProcessRunning, killProcessTree } from "../util/process.js";
+import { copyFileIfMissing } from "../download/DownloadUtils.js";
+const INSTANCE_FILE = "instance.json";
+export class ServerInstanceManager {
+    globalState;
+    project;
+    constructor(globalState, project) {
+        this.globalState = globalState;
+        this.project = project;
+    }
+    async create(options) {
+        const instanceDir = resolveServerInstanceDir(options.project, options.name);
+        await mkdir(instanceDir, { recursive: true });
+        const port = options.port ?? (await this.findAvailablePort());
+        const jarPath = options.cachedJarPath;
+        if (jarPath) {
+            const targetJar = path.join(instanceDir, path.basename(jarPath));
+            await copyFileIfMissing(jarPath, targetJar);
+        }
+        if (options.eula) {
+            await writeFile(path.join(instanceDir, "eula.txt"), "eula=true\n", "utf8");
+        }
+        await mkdir(path.join(instanceDir, "plugins"), { recursive: true });
+        const meta = {
+            name: options.name,
+            project: options.project,
+            type: options.type,
+            mcVersion: options.version,
+            port,
+            jvmArgs: options.jvmArgs ?? [],
+            createdAt: new Date().toISOString()
+        };
+        await writeFile(path.join(instanceDir, INSTANCE_FILE), `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+        return meta;
+    }
+    async start(serverName, options = {}) {
+        const stateKey = `${this.project}/${serverName}`;
+        const state = await this.globalState.readServerState();
+        const existing = state.servers[stateKey];
+        if (existing && isProcessRunning(existing.pid)) {
+            throw new MctError({ code: "SERVER_ALREADY_RUNNING", message: `Server ${stateKey} is already running`, details: existing }, 5);
+        }
+        const meta = await this.loadMeta(serverName);
+        const instanceDir = resolveServerInstanceDir(this.project, serverName);
+        const jarFile = await this.findJarFile(instanceDir);
+        if (!jarFile) {
+            throw new MctError({ code: "INVALID_PARAMS", message: `No server jar found in ${instanceDir}` }, 4);
+        }
+        if (options.eula) {
+            await writeFile(path.join(instanceDir, "eula.txt"), "eula=true\n", "utf8");
+        }
+        const logsDir = path.join(this.globalState.getRootDir(), "logs");
+        mkdirSync(logsDir, { recursive: true });
+        const logPath = path.join(logsDir, `server-${this.project}-${serverName}.log`);
+        const stdout = openSync(logPath, "a");
+        const jvmArgs = options.jvmArgs ?? meta.jvmArgs;
+        const child = spawn("java", [...jvmArgs, "-jar", jarFile, "nogui"], {
+            cwd: instanceDir,
+            detached: true,
+            stdio: ["ignore", stdout, stdout],
+            env: {
+                ...process.env,
+                MCT_SERVER_PORT: String(meta.port)
+            }
+        });
+        child.unref();
+        const entry = {
+            pid: child.pid ?? 0,
+            project: this.project,
+            name: serverName,
+            port: meta.port,
+            startedAt: new Date().toISOString(),
+            logPath,
+            instanceDir
+        };
+        state.servers[stateKey] = entry;
+        await this.globalState.writeServerState(state);
+        return { running: true, ...entry };
+    }
+    async stop(serverName) {
+        const stateKey = `${this.project}/${serverName}`;
+        const state = await this.globalState.readServerState();
+        const entry = state.servers[stateKey];
+        if (!entry) {
+            return { running: false, stopped: false };
+        }
+        if (isProcessRunning(entry.pid)) {
+            killProcessTree(entry.pid);
+        }
+        delete state.servers[stateKey];
+        await this.globalState.writeServerState(state);
+        return { running: false, stopped: true, pid: entry.pid };
+    }
+    async status(serverName) {
+        const state = await this.globalState.readServerState();
+        if (serverName) {
+            const stateKey = `${this.project}/${serverName}`;
+            const entry = state.servers[stateKey];
+            if (!entry) {
+                return { running: false };
+            }
+            const running = isProcessRunning(entry.pid);
+            if (!running) {
+                delete state.servers[stateKey];
+                await this.globalState.writeServerState(state);
+                return { running: false, stale: true, ...entry };
+            }
+            return { running: true, ...entry };
+        }
+        const results = [];
+        for (const [key, entry] of Object.entries(state.servers)) {
+            if (entry.project === this.project) {
+                const running = isProcessRunning(entry.pid);
+                if (!running) {
+                    delete state.servers[key];
+                }
+                results.push({ running, ...entry });
+            }
+        }
+        await this.globalState.writeServerState(state);
+        return results;
+    }
+    async waitReady(serverName, timeoutSeconds) {
+        const stateKey = `${this.project}/${serverName}`;
+        const state = await this.globalState.readServerState();
+        const entry = state.servers[stateKey];
+        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);
+    }
+    async list() {
+        const projectDir = resolveProjectDir(this.project);
+        try {
+            const entries = await readdir(projectDir, { withFileTypes: true });
+            const results = [];
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    try {
+                        const meta = await this.loadMeta(entry.name);
+                        results.push(meta);
+                    }
+                    catch {
+                        // not a valid instance
+                    }
+                }
+            }
+            return results;
+        }
+        catch {
+            return [];
+        }
+    }
+    static async listAll(globalState) {
+        const { resolveProjectsDir } = await import("../util/paths.js");
+        const projectsDir = resolveProjectsDir();
+        const results = [];
+        try {
+            const projects = await readdir(projectsDir, { withFileTypes: true });
+            for (const project of projects) {
+                if (project.isDirectory()) {
+                    const manager = new ServerInstanceManager(globalState, project.name);
+                    const instances = await manager.list();
+                    results.push(...instances);
+                }
+            }
+        }
+        catch {
+            // projects dir doesn't exist yet
+        }
+        return results;
+    }
+    async deploy(serverName, jarPaths, cwd) {
+        const instanceDir = resolveServerInstanceDir(this.project, serverName);
+        const pluginsDir = path.join(instanceDir, "plugins");
+        await mkdir(pluginsDir, { recursive: true });
+        const deployed = [];
+        for (const jarPath of jarPaths) {
+            const resolved = path.resolve(cwd, jarPath);
+            const target = path.join(pluginsDir, path.basename(resolved));
+            await copyFile(resolved, target);
+            deployed.push(target);
+        }
+        return deployed;
+    }
+    async loadMeta(serverName) {
+        const instanceDir = resolveServerInstanceDir(this.project, serverName);
+        const metaPath = path.join(instanceDir, INSTANCE_FILE);
+        try {
+            const raw = await readFile(metaPath, "utf8");
+            return JSON.parse(raw);
+        }
+        catch {
+            throw new MctError({ code: "INSTANCE_NOT_FOUND", message: `Server instance ${this.project}/${serverName} not found` }, 3);
+        }
+    }
+    async findJarFile(instanceDir) {
+        try {
+            const entries = await readdir(instanceDir);
+            const jar = entries.find((e) => e.endsWith(".jar"));
+            return jar ? path.join(instanceDir, jar) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async findAvailablePort() {
+        const state = await this.globalState.readServerState();
+        const usedPorts = new Set(Object.values(state.servers).map((s) => s.port));
+        let port = 25565;
+        while (usedPorts.has(port)) {
+            port += 1;
+        }
+        return port;
+    }
+}

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("--config <path>", "Config file path (default: ./mct.config.json)")
-        .option("--state-dir <path>", "State directory (default: ./.mct-state/)")
+        .option("--project <name>", "Project name (default: from mct.project.json)")
+        .option("--profile <name>", "Profile name (default: from mct.project.json)")
         .option("--client <name>", "Target client name (required when multiple clients are running)");
 }
 export function wrapCommand(action) {

package/dist/util/context.d.ts

@@ -1,17 +1,19 @@
-import { type MctConfig } from "./config.js";
-import { type OutputMode } from "./output.js";
-import { StateStore } from "./state.js";
+import { GlobalStateStore } from "./global-state.js";
+import type { OutputMode } from "./output.js";
+import { type MctProfile, type MctProjectFile } from "./project.js";
 export interface GlobalOptions {
     human?: boolean;
-    config?: string;
-    stateDir?: string;
     client?: string;
+    project?: string;
+    profile?: string;
 }
 export interface CommandContext {
     cwd: string;
-    configPath: string;
-    config: MctConfig;
-    state: StateStore;
     outputMode: OutputMode;
+    globalState: GlobalStateStore;
+    projectFile: MctProjectFile | null;
+    activeProfile: MctProfile | null;
+    projectName: string | null;
+    timeout(key: "serverReady" | "clientReady" | "default"): number;
 }
 export declare function createCommandContext(options: GlobalOptions): Promise<CommandContext>;

package/dist/util/context.js

@@ -1,16 +1,28 @@
 import process from "node:process";
-import { loadConfig, resolveConfigPath } from "./config.js";
-import { resolveStateDir, StateStore } from "./state.js";
+import { GlobalStateStore } from "./global-state.js";
+import { loadProjectFile, resolveProfile } from "./project.js";
+const TIMEOUT_DEFAULTS = {
+    serverReady: 120,
+    clientReady: 60,
+    default: 10
+};
 export async function createCommandContext(options) {
     const cwd = process.cwd();
-    const configPath = resolveConfigPath(options.config, cwd);
-    const config = await loadConfig(configPath, cwd);
-    const state = new StateStore(resolveStateDir(options.stateDir, cwd));
+    const globalState = new GlobalStateStore();
+    const projectFile = await loadProjectFile(cwd);
+    const projectName = options.project ?? projectFile?.project ?? null;
+    const activeProfile = projectFile
+        ? resolveProfile(projectFile, options.profile)
+        : null;
     return {
         cwd,
-        configPath,
-        config,
-        state,
-        outputMode: options.human ? "human" : "json"
+        outputMode: options.human ? "human" : "json",
+        globalState,
+        projectFile,
+        activeProfile,
+        projectName,
+        timeout(key) {
+            return projectFile?.timeout?.[key] ?? TIMEOUT_DEFAULTS[key];
+        }
     };
 }

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

@@ -0,0 +1,9 @@
+import { StateStore } from "./state.js";
+import type { GlobalClientState, GlobalServerState } from "./instance-types.js";
+export declare class GlobalStateStore extends StateStore {
+    constructor();
+    readServerState(): Promise<GlobalServerState>;
+    writeServerState(state: GlobalServerState): Promise<void>;
+    readClientState(): Promise<GlobalClientState>;
+    writeClientState(state: GlobalClientState): Promise<void>;
+}

package/dist/util/global-state.js

@@ -0,0 +1,21 @@
+import { resolveGlobalStateDir } from "./paths.js";
+import { StateStore } from "./state.js";
+const SERVERS_STATE_FILE = "servers.json";
+const CLIENTS_STATE_FILE = "clients.json";
+export class GlobalStateStore extends StateStore {
+    constructor() {
+        super(resolveGlobalStateDir());
+    }
+    async readServerState() {
+        return this.readJson(SERVERS_STATE_FILE, { servers: {} });
+    }
+    async writeServerState(state) {
+        await this.writeJson(SERVERS_STATE_FILE, state);
+    }
+    async readClientState() {
+        return this.readJson(CLIENTS_STATE_FILE, { clients: {} });
+    }
+    async writeClientState(state) {
+        await this.writeJson(CLIENTS_STATE_FILE, state);
+    }
+}

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

@@ -0,0 +1,46 @@
+export type ServerType = "paper" | "purpur" | "vanilla" | "spigot";
+export type LoaderType = "fabric" | "forge" | "neoforge";
+export interface ServerInstanceMeta {
+    name: string;
+    project: string;
+    type: ServerType;
+    mcVersion: string;
+    port: number;
+    jvmArgs: string[];
+    createdAt: string;
+}
+export interface ClientInstanceMeta {
+    name: string;
+    loader: LoaderType;
+    mcVersion: string;
+    wsPort: number;
+    account?: string;
+    headless?: boolean;
+    launchArgs?: string[];
+    env?: Record<string, string>;
+    createdAt: string;
+}
+export interface ServerRuntimeEntry {
+    pid: number;
+    project: string;
+    name: string;
+    port: number;
+    startedAt: string;
+    logPath: string;
+    instanceDir: string;
+}
+export interface ClientRuntimeEntry {
+    pid: number;
+    name: string;
+    wsPort: number;
+    startedAt: string;
+    logPath: string;
+    instanceDir: string;
+}
+export interface GlobalServerState {
+    servers: Record<string, ServerRuntimeEntry>;
+}
+export interface GlobalClientState {
+    defaultClient?: string;
+    clients: Record<string, ClientRuntimeEntry>;
+}

package/dist/util/instance-types.js

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

package/dist/util/paths.d.ts

@@ -0,0 +1,7 @@
+export declare function resolveMctHome(): string;
+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 resolveServerInstanceDir(project: string, server: string): string;
+export declare function resolveGlobalStateDir(): string;

package/dist/util/paths.js

@@ -0,0 +1,23 @@
+import os from "node:os";
+import path from "node:path";
+export function resolveMctHome() {
+    return process.env.MCT_HOME || path.join(os.homedir(), ".mct");
+}
+export function resolveClientsDir() {
+    return path.join(resolveMctHome(), "clients");
+}
+export function resolveClientInstanceDir(name) {
+    return path.join(resolveClientsDir(), name);
+}
+export function resolveProjectsDir() {
+    return path.join(resolveMctHome(), "projects");
+}
+export function resolveProjectDir(project) {
+    return path.join(resolveProjectsDir(), project);
+}
+export function resolveServerInstanceDir(project, server) {
+    return path.join(resolveProjectDir(project), server);
+}
+export function resolveGlobalStateDir() {
+    return path.join(resolveMctHome(), "state");
+}

package/dist/util/project.d.ts

@@ -0,0 +1,23 @@
+export interface MctProfile {
+    server: string;
+    clients: string[];
+    deployPlugins?: string[];
+}
+export interface MctProjectFile {
+    project: string;
+    profiles: Record<string, MctProfile>;
+    defaultProfile?: string;
+    screenshot?: {
+        outputDir: string;
+    };
+    timeout?: {
+        serverReady?: number;
+        clientReady?: number;
+        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 declare function resolveProfile(projectFile: MctProjectFile, profileName?: string): MctProfile | null;

package/dist/util/project.js

@@ -0,0 +1,28 @@
+import { access, 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);
+}
+export async function loadProjectFile(cwd) {
+    const filePath = resolveProjectFilePath(cwd);
+    try {
+        await access(filePath);
+    }
+    catch {
+        return null;
+    }
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+}
+export async function writeProjectFile(cwd, project) {
+    const filePath = resolveProjectFilePath(cwd);
+    await writeFile(filePath, `${JSON.stringify(project, null, 2)}\n`, "utf8");
+}
+export function resolveProfile(projectFile, profileName) {
+    const name = profileName ?? projectFile.defaultProfile;
+    if (!name) {
+        return null;
+    }
+    return projectFile.profiles[name] ?? null;
+}

package/package.json

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