@kzheart_/mc-pilot 0.8.0 → 0.9.0

package/dist/commands/chat.js

@@ -11,7 +11,7 @@ function normalizeChatCommand(text) {
     return command;
 }
 async function executeServerCommand(context, serverName, command) {
-    const manager = new ServerInstanceManager(context.globalState, context.projectName);
+    const manager = new ServerInstanceManager(context.globalState, context.projectId);
     const result = await manager.exec(serverName, command);
     return {
         ...result,
@@ -50,7 +50,7 @@ export function createChatCommand() {
             if (preferredClient) {
                 return sendClientRequest(context, preferredClient, "chat.command", { command: commandText });
             }
-            if (!context.projectName) {
+            if (!context.projectId) {
                 return sendClientRequest(context, undefined, "chat.command", { command: commandText });
             }
             const serverName = options.server ?? context.activeProfile?.server;
@@ -65,7 +65,7 @@ export function createChatCommand() {
         if (via !== "server") {
             throw new MctError({ code: "INVALID_PARAMS", message: `--via must be \"auto\", \"server\" or \"client\", got: ${via}` }, 4);
         }
-        if (!context.projectName) {
+        if (!context.projectId) {
             throw new MctError({ code: "NO_PROJECT", message: "--via server requires a project context. Use --via client or run inside an mct project." }, 4);
         }
         const serverName = options.server ?? context.activeProfile?.server;

package/dist/commands/client.d.ts

@@ -1,4 +1,4 @@
 import { Command } from "commander";
 import type { CommandContext } from "../util/context.js";
-export declare function resolveProfileServerAddress(context: Pick<CommandContext, "projectName" | "activeProfile" | "globalState">, explicitServer: string | undefined, loadPort?: (projectName: string, serverName: string) => Promise<number>): Promise<string | undefined>;
+export declare function resolveProfileServerAddress(context: Pick<CommandContext, "projectId" | "activeProfile" | "globalState">, explicitServer: string | undefined, loadPort?: (projectId: string, serverName: string) => Promise<number>): Promise<string | undefined>;
 export declare function createClientCommand(): Command;

package/dist/commands/client.js

@@ -17,13 +17,13 @@ export async function resolveProfileServerAddress(context, explicitServer, loadP
     if (explicitServer) {
         return explicitServer;
     }
-    if (!context.projectName || !context.activeProfile?.server) {
+    if (!context.projectId || !context.activeProfile?.server) {
         return undefined;
     }
     try {
         const port = loadPort
-            ? await loadPort(context.projectName, context.activeProfile.server)
-            : (await new ServerInstanceManager(context.globalState, context.projectName).loadMeta(context.activeProfile.server)).port;
+            ? await loadPort(context.projectId, context.activeProfile.server)
+            : (await new ServerInstanceManager(context.globalState, context.projectId).loadMeta(context.activeProfile.server)).port;
         return `127.0.0.1:${port}`;
     }
     catch {

package/dist/commands/gui.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
-import { createRequestAction, parseNumberList, withTransportTimeoutBuffer } from "./request-helpers.js";
+import { wrapCommand } from "../util/command.js";
+import { createRequestAction, parseNumberList, resolveScreenshotOutputPath, sendClientRequest, withTransportTimeoutBuffer } from "./request-helpers.js";
 export function createGuiCommand() {
     const command = new Command("gui").description("GUI / container interaction (use \"gui snapshot\" to inspect slot indices and contents)");
     command.command("info").description("Get current GUI info (title, type, slot count)").action(createRequestAction("gui.info", () => ({})));
@@ -43,7 +44,11 @@ export function createGuiCommand() {
     command
         .command("screenshot")
         .description("Take a screenshot of the current GUI")
-        .requiredOption("--output <path>", "Output file path")
-        .action(createRequestAction("gui.screenshot", ({ options }) => ({ output: options.output })));
+        .option("--output <path>", "Output file path (default: project screenshot directory)")
+        .action(wrapCommand(async (context, { options, globalOptions }) => {
+        return sendClientRequest(context, globalOptions.client ?? context.activeProfile?.clients[0], "gui.screenshot", {
+            output: resolveScreenshotOutputPath(context, options.output, "gui")
+        });
+    }));
     return command;
 }

package/dist/commands/plugin.js

@@ -69,11 +69,11 @@ export function createPluginCommand() {
         .description("Install a plugin (with dependencies) to a server")
         .argument("<id>", "Plugin ID")
         .requiredOption("--server <name>", "Target server instance name")
-        .option("--project <name>", "Project name")
+        .option("--project <id>", "Project ID")
         .action(wrapCommand(async (context, { args, options }) => {
-        const project = options.project ?? context.projectName;
+        const project = options.project ?? context.projectId;
         if (!project) {
-            throw new MctError({ code: "NO_PROJECT", message: "No project specified. Use --project or run from a project directory." }, 4);
+            throw new MctError({ code: "NO_PROJECT", message: "No project specified. Use --project <id> or run from a project directory." }, 4);
         }
         const manager = new PluginCatalogManager();
         return manager.install(args[0], project, options.server);

package/dist/commands/project.js

@@ -4,34 +4,26 @@ import { ServerInstanceManager } from "../instance/ServerInstanceManager.js";
 import { ClientInstanceManager } from "../instance/ClientInstanceManager.js";
 import { MctError } from "../util/errors.js";
 import { wrapCommand } from "../util/command.js";
-import { loadProjectFile, resolveProfile, writeProjectFile } from "../util/project.js";
+import { createDefaultProjectFile, loadProjectFileForCwd, resolveProjectFilePath, resolveProfile, writeProjectFile, } from "../util/project.js";
 export function createInitCommand() {
     return new Command("init")
-        .description("Initialize a new MC Pilot project in the current directory")
+        .description("Initialize a new MC Pilot project for the current directory")
         .option("--name <name>", "Project name (default: directory name)")
         .action(wrapCommand(async (context, { options }) => {
-        const existing = await loadProjectFile(context.cwd);
+        const existing = await loadProjectFileForCwd(context.cwd);
         if (existing) {
-            throw new MctError({ code: "PROJECT_EXISTS", message: "mct.project.json already exists in this directory" }, 4);
+            throw new MctError({ code: "PROJECT_EXISTS", message: `Project config already exists for this directory: ${existing.filePath}` }, 4);
         }
         const projectName = options.name ?? path.basename(context.cwd);
-        const project = {
-            project: projectName,
-            profiles: {},
-            screenshot: {
-                outputDir: "./screenshots"
-            },
-            timeout: {
-                serverReady: 120,
-                clientReady: 60,
-                default: 10
-            }
-        };
-        await writeProjectFile(context.cwd, project);
+        const project = createDefaultProjectFile(context.cwd, projectName);
+        await writeProjectFile(project.projectId, project);
         return {
             created: true,
+            projectId: project.projectId,
             project: projectName,
-            file: "mct.project.json"
+            rootDir: project.rootDir,
+            file: resolveProjectFilePath(project.projectId),
+            configPath: resolveProjectFilePath(project.projectId)
         };
     }));
 }
@@ -40,8 +32,8 @@ export function createDeployCommand() {
         .description("Deploy plugin JARs to the server instance")
         .option("--profile <name>", "Profile name")
         .action(wrapCommand(async (context, { options }) => {
-        const { projectFile, projectName } = context;
-        if (!projectFile || !projectName) {
+        const { projectFile, projectId, projectRootDir } = context;
+        if (!projectFile || !projectId || !projectRootDir) {
             throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first." }, 4);
         }
         const profile = resolveProfile(projectFile, options.profile ?? projectFile.defaultProfile);
@@ -51,8 +43,8 @@ export function createDeployCommand() {
         if (!profile.deployPlugins || profile.deployPlugins.length === 0) {
             return { deployed: [], message: "No deployPlugins configured in profile" };
         }
-        const manager = new ServerInstanceManager(context.globalState, projectName);
-        const deployed = await manager.deploy(profile.server, profile.deployPlugins, context.cwd);
+        const manager = new ServerInstanceManager(context.globalState, projectId);
+        const deployed = await manager.deploy(profile.server, profile.deployPlugins, projectRootDir);
         return { deployed, server: profile.server };
     }));
 }
@@ -62,20 +54,20 @@ export function createUpCommand() {
         .option("--profile <name>", "Profile name")
         .option("--eula", "Auto-accept EULA")
         .action(wrapCommand(async (context, { options }) => {
-        const { projectFile, projectName } = context;
-        if (!projectFile || !projectName) {
+        const { projectFile, projectId, projectRootDir } = context;
+        if (!projectFile || !projectId || !projectRootDir) {
             throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first." }, 4);
         }
         const profile = resolveProfile(projectFile, options.profile ?? projectFile.defaultProfile);
         if (!profile) {
             throw new MctError({ code: "NO_PROFILE", message: "No profile specified and no defaultProfile set" }, 4);
         }
-        const serverManager = new ServerInstanceManager(context.globalState, projectName);
+        const serverManager = new ServerInstanceManager(context.globalState, projectId);
         const clientManager = new ClientInstanceManager(context.globalState);
         const results = {};
         // 1. Deploy plugins
         if (profile.deployPlugins && profile.deployPlugins.length > 0) {
-            results.deployed = await serverManager.deploy(profile.server, profile.deployPlugins, context.cwd);
+            results.deployed = await serverManager.deploy(profile.server, profile.deployPlugins, projectRootDir);
         }
         // 2. Start server
         results.server = await serverManager.start(profile.server, { eula: options.eula });
@@ -109,15 +101,15 @@ export function createDownCommand() {
         .description("Stop server and clients for the active profile")
         .option("--profile <name>", "Profile name")
         .action(wrapCommand(async (context, { options }) => {
-        const { projectFile, projectName } = context;
-        if (!projectFile || !projectName) {
+        const { projectFile, projectId } = context;
+        if (!projectFile || !projectId) {
             throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first." }, 4);
         }
         const profile = resolveProfile(projectFile, options.profile ?? projectFile.defaultProfile);
         if (!profile) {
             throw new MctError({ code: "NO_PROFILE", message: "No profile specified and no defaultProfile set" }, 4);
         }
-        const serverManager = new ServerInstanceManager(context.globalState, projectName);
+        const serverManager = new ServerInstanceManager(context.globalState, projectId);
         const clientManager = new ClientInstanceManager(context.globalState);
         const results = {};
         // Stop clients first
@@ -155,7 +147,7 @@ export function createUseCommand() {
             }, 4);
         }
         projectFile.defaultProfile = profileName;
-        await writeProjectFile(context.cwd, projectFile);
+        await writeProjectFile(projectFile.projectId, projectFile);
         return {
             defaultProfile: profileName,
             profile: projectFile.profiles[profileName]

package/dist/commands/request-helpers.d.ts

@@ -7,6 +7,8 @@ export interface RequestPayload<TOptions> {
 }
 export declare function sendClientRequest(context: CommandContext, clientName: string | undefined, action: string, params: Record<string, unknown>, timeoutSeconds?: number): Promise<unknown>;
 export declare function resolvePreferredClientName(context: CommandContext, globalOptions: GlobalOptions): string | undefined;
+export declare function resolveProjectRelativePath(context: CommandContext, targetPath: string): string;
+export declare function resolveScreenshotOutputPath(context: CommandContext, output: string | undefined, prefix: "screenshot" | "gui"): string;
 export declare function createRequestAction<TOptions = Record<string, any>>(action: string, buildParams: (payload: RequestPayload<TOptions>) => Record<string, unknown>, timeoutSelector?: (payload: RequestPayload<TOptions>, context: CommandContext) => number | undefined): (this: Command, ...input: unknown[]) => Promise<void>;
 export declare function parseJson(text: string, fieldName: string): Record<string, unknown>;
 export declare function parseNumberList(text: string): number[];

package/dist/commands/request-helpers.js

@@ -1,4 +1,5 @@
 import { Command } from "commander";
+import path from "node:path";
 import { ClientInstanceManager } from "../instance/ClientInstanceManager.js";
 import { WebSocketClient } from "../client/WebSocketClient.js";
 import { MctError } from "../util/errors.js";
@@ -12,6 +13,23 @@ export async function sendClientRequest(context, clientName, action, params, tim
 export function resolvePreferredClientName(context, globalOptions) {
     return globalOptions.client ?? context.activeProfile?.clients[0];
 }
+export function resolveProjectRelativePath(context, targetPath) {
+    if (path.isAbsolute(targetPath)) {
+        return targetPath;
+    }
+    return path.resolve(context.projectRootDir ?? context.cwd, targetPath);
+}
+export function resolveScreenshotOutputPath(context, output, prefix) {
+    if (output) {
+        return resolveProjectRelativePath(context, output);
+    }
+    const outputDir = context.projectFile?.screenshot?.outputDir;
+    if (!outputDir) {
+        throw new MctError({ code: "INVALID_PARAMS", message: "--output is required outside a project context." }, 4);
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return path.join(outputDir, `${prefix}-${timestamp}.png`);
+}
 export function createRequestAction(action, buildParams, timeoutSelector) {
     return wrapCommand(async (context, payload) => {
         const timeout = timeoutSelector?.(payload, context);

package/dist/commands/screenshot.js

@@ -1,14 +1,17 @@
 import { Command } from "commander";
-import { createRequestAction } from "./request-helpers.js";
+import { wrapCommand } from "../util/command.js";
+import { resolveScreenshotOutputPath, sendClientRequest } from "./request-helpers.js";
 export function createScreenshotCommand() {
     return new Command("screenshot")
         .description("Take a screenshot")
-        .requiredOption("--output <path>", "Output file path (e.g. ./screenshots/test.png)")
+        .option("--output <path>", "Output file path (default: project screenshot directory)")
         .option("--region <region>", "Capture a sub-region, format: x,y,w,h")
         .option("--gui", "Capture the current GUI screen")
-        .action(createRequestAction("capture.screenshot", ({ options }) => ({
-        output: options.output,
-        region: options.region,
-        gui: Boolean(options.gui)
-    })));
+        .action(wrapCommand(async (context, { options, globalOptions }) => {
+        return sendClientRequest(context, globalOptions.client ?? context.activeProfile?.clients[0], "capture.screenshot", {
+            output: resolveScreenshotOutputPath(context, options.output, "screenshot"),
+            region: options.region,
+            gui: Boolean(options.gui)
+        });
+    }));
 }

package/dist/commands/server.js

@@ -5,10 +5,10 @@ import { ServerInstanceManager } from "../instance/ServerInstanceManager.js";
 import { MctError } from "../util/errors.js";
 import { wrapCommand } from "../util/command.js";
 function requireProject(context) {
-    if (!context.projectName) {
-        throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first or use --project <name>" }, 4);
+    if (!context.projectId) {
+        throw new MctError({ code: "NO_PROJECT", message: "No project context. Run 'mct init' first or use --project <id>" }, 4);
     }
-    return context.projectName;
+    return context.projectId;
 }
 function resolveServerName(context, explicit) {
     if (explicit)
@@ -90,13 +90,13 @@ export function createServerCommand() {
         .argument("[name]", "Server instance name (omit to show all in project)")
         .option("--all", "Show running servers across all projects")
         .action(wrapCommand(async (context, { args, options }) => {
-        if (options.all || (!context.projectName && !args[0])) {
+        if (options.all || (!context.projectId && !args[0])) {
             return ServerInstanceManager.statusAll(context.globalState);
         }
-        if (!context.projectName) {
-            throw new MctError({ code: "NO_PROJECT", message: "No project context. Omit the name to inspect all running servers, or use --project <name>." }, 4);
+        if (!context.projectId) {
+            throw new MctError({ code: "NO_PROJECT", message: "No project context. Omit the name to inspect all running servers, or use --project <id>." }, 4);
         }
-        const manager = new ServerInstanceManager(context.globalState, context.projectName);
+        const manager = new ServerInstanceManager(context.globalState, context.projectId);
         return manager.status(args[0]);
     }));
     command

package/dist/index.js

@@ -37,7 +37,7 @@ export function buildProgram() {
         "Control a real Minecraft client via CLI to simulate player actions and verify plugin behavior.\n" +
         "All commands output JSON by default. Use --human for human-readable output.\n\n" +
         "Quick start:\n" +
-        "  mct init --project my-plugin\n" +
+        "  mct init --name my-plugin\n" +
         "  mct server create paper-1.20.4 --type paper --version 1.20.4\n" +
         "  mct client create fabric-1.20.4 --version 1.20.4\n" +
         "  mct up --profile 1.20\n" +
@@ -53,7 +53,10 @@ export function buildProgram() {
         .action(wrapCommand(async (context) => {
         return {
             cwd: context.cwd,
+            projectId: context.projectId,
             project: context.projectName,
+            projectRootDir: context.projectRootDir,
+            projectConfigPath: context.projectConfigPath,
             activeProfile: context.activeProfile,
             globalStateDir: context.globalState.getRootDir()
         };

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/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;

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/package.json

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