@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/dist/commands/captureListing.js

@@ -36,6 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCaptureSurfaces = resolveCaptureSurfaces;
 exports.resolveListingCaptureRouteSegment = resolveListingCaptureRouteSegment;
 exports.resolveCaptureListingDevRouterPort = resolveCaptureListingDevRouterPort;
 exports.resolveListingCaptureLocalDevPort = resolveListingCaptureLocalDevPort;
@@ -111,6 +112,28 @@ const SURFACE_OUTPUT_SLUG = {
     MOBILE_LANDSCAPE: "mobile-landscape",
     MOBILE_PORTRAIT: "mobile-portrait",
 };
+const CAPTURE_SURFACE_BY_INPUT = {
+    desktop: "DESKTOP",
+    "mobile-landscape": "MOBILE_LANDSCAPE",
+    "mobile-portrait": "MOBILE_PORTRAIT",
+};
+function parseCaptureSurface(value) {
+    const normalized = value?.trim().toLowerCase().replace(/_/g, "-") ?? "";
+    if (!normalized)
+        return null;
+    const surface = CAPTURE_SURFACE_BY_INPUT[normalized];
+    if (!surface)
+        throw new Error("surface_invalid");
+    return surface;
+}
+function resolveCaptureSurfaces(declared, selected) {
+    if (!selected)
+        return [...declared];
+    if (!declared.includes(selected)) {
+        throw new Error(`surface_not_declared:${selected}`);
+    }
+    return [selected];
+}
 function resolveListingCaptureRouteSegment(previewable) {
     if (!previewable) {
         throw new Error("listing_preview_support_missing");
@@ -169,6 +192,10 @@ function parseCaptureListingOptions(targetArg, options = {}) {
         maximum: MAX_DIMENSION,
         integer: true,
     });
+    if (width % 2 !== 0)
+        throw new Error("width_must_be_even");
+    if (height % 2 !== 0)
+        throw new Error("height_must_be_even");
     const fps = parsePositiveNumber(options.fps, DEFAULT_FPS, "fps", {
         minimum: 1,
         maximum: MAX_FPS,
@@ -183,6 +210,7 @@ function parseCaptureListingOptions(targetArg, options = {}) {
     return {
         targetArg,
         appName: options.app?.trim() || undefined,
+        surface: parseCaptureSurface(options.surface),
         durationSeconds,
         width,
         height,
@@ -322,6 +350,10 @@ async function launchListingBrowser(initialViewport, automationOrigin, contextOp
         const context = await browser.newContext(contextOptions);
         await grantListingBrowserLocalNetworkAccess(context, automationOrigin);
         const page = await context.newPage();
+        const cdpSession = await context.newCDPSession(page);
+        await cdpSession.send("Emulation.setSafeAreaInsetsOverride", {
+            insets: { top: 0, right: 0, bottom: 0, left: 0 },
+        });
         return {
             browser,
             context,
@@ -898,7 +930,7 @@ function formatCommandError(error) {
         suggestions: [],
     };
 }
-async function encodeListingVideo(rawVideoPath, finalVideoPath, posterPath, crop, width, height, fps, posterAtSeconds, deadlineAt) {
+async function encodeListingVideo(rawVideoPath, finalVideoPath, posterPath, crop, width, height, fps, durationSeconds, posterAtSeconds, deadlineAt) {
     const filter = `crop=${crop.width}:${crop.height}:${crop.x}:${crop.y},scale=${width}:${height}:flags=lanczos,fps=${fps}`;
     runTool("ffmpeg", [
         "-y",
@@ -912,6 +944,8 @@ async function encodeListingVideo(rawVideoPath, finalVideoPath, posterPath, crop
         "yuv420p",
         "-c:a",
         "aac",
+        "-t",
+        String(durationSeconds),
         finalVideoPath,
     ], "ffmpeg_failed", deadlineAt);
     runTool("ffmpeg", ["-y", "-ss", String(posterAtSeconds), "-i", finalVideoPath, "-frames:v", "1", posterPath], "ffmpeg_failed", deadlineAt);
@@ -1081,6 +1115,16 @@ async function captureListing(targetArg, options = {}) {
     if (!resolvedTarget) {
         return;
     }
+    let requestedSurfaces;
+    try {
+        requestedSurfaces = resolveCaptureSurfaces(resolvedTarget.surfaceTargets.list, parsedOptions.surface);
+    }
+    catch (error) {
+        const detail = formatCommandError(error instanceof Error ? error : new Error(String(error)));
+        (0, messages_1.printErrorWithHelp)(detail.message, detail.suggestions, { command: "project capture" });
+        process.exitCode = 1;
+        return;
+    }
     let appName = resolvedTarget.appName;
     let appTypeSlug = (0, appUrls_1.getAppTypeSlug)(null);
     let declaresPreviewSupport = false;
@@ -1213,7 +1257,7 @@ async function captureListing(targetArg, options = {}) {
                 outputPaths,
                 parsedOptions,
                 runtimeBundleHash,
-                surfaces: resolvedTarget.surfaceTargets.list,
+                surfaces: requestedSurfaces,
                 deadlineAt: captureDeadlineAt,
             });
             if (reused) {
@@ -1321,7 +1365,7 @@ async function captureListing(targetArg, options = {}) {
             const reportFrameUrl = (0, appUrls_1.redactTaskCaptureSession)(frameUrl);
             console.log(`[listing] Opening ${reportFrameUrl}`);
             const shouldExportPreviewAudio = parsedOptions.audio && routeSegment === "dev-preview";
-            const surfaces = resolvedTarget.surfaceTargets.list;
+            const surfaces = requestedSurfaces;
             const useSurfacePrefix = surfaces.length > 1;
             const captures = [];
             const artifactHashes = {};
@@ -1379,7 +1423,7 @@ async function captureListing(targetArg, options = {}) {
                     const rawAudioTrackCount = countAudioStreams(rawProbe);
                     const crop = computeRecordedCrop(measurement, recorderMetadata, rawVideoStream.width, rawVideoStream.height);
                     console.log(`[listing] Cropping raw capture to gameplay at ${crop.width}x${crop.height}+${crop.x}+${crop.y}.`);
-                    await encodeListingVideo(surfaceOutputPaths.rawVideoPath, surfaceOutputPaths.finalVideoPath, surfaceOutputPaths.posterPath, crop, dimensions.width, dimensions.height, parsedOptions.fps, parsedOptions.posterAtSeconds, captureDeadlineAt);
+                    await encodeListingVideo(surfaceOutputPaths.rawVideoPath, surfaceOutputPaths.finalVideoPath, surfaceOutputPaths.posterPath, crop, dimensions.width, dimensions.height, parsedOptions.fps, parsedOptions.durationSeconds, parsedOptions.posterAtSeconds, captureDeadlineAt);
                     if (exportedAudioPath) {
                         await muxListingAudio(surfaceOutputPaths.finalVideoPath, exportedAudioPath, captureDeadlineAt);
                     }

package/dist/commands/chat.d.ts

@@ -5,23 +5,20 @@ export type ChatCommonOptions = {
 export type ChatWriteCommandOptions = ChatCommonOptions & {
     text?: string;
     textFile?: string;
-    file?: string[];
-    link?: string[];
     clientKey?: string;
     eventType?: string;
     eventDataFile?: string;
     asSystem?: boolean;
+    attachment?: string[];
 };
 export declare function listChatChannels(options?: ChatCommonOptions): Promise<void>;
 export declare function readChatChannel(channel: string, options?: ChatCommonOptions): Promise<void>;
 export declare function readChatThread(rawMessageId: string, options?: ChatCommonOptions): Promise<void>;
+export declare function listChatInbox(options?: ChatCommonOptions): Promise<void>;
+export declare function readChatConversation(rawConversationId: string, options?: ChatCommonOptions): Promise<void>;
 export declare function sendChatMessage(channel: string, options: ChatWriteCommandOptions): Promise<void>;
 export declare function replyChatMessage(rawMessageId: string, options: ChatWriteCommandOptions): Promise<void>;
+export declare function sendChatDirectMessage(username: string, options: ChatWriteCommandOptions): Promise<void>;
 export declare function editChatMessage(rawMessageId: string, options: ChatWriteCommandOptions): Promise<void>;
 export declare function reactChatMessage(rawMessageId: string, emoji: string, options?: ChatCommonOptions): Promise<void>;
 export declare function unreactChatMessage(rawMessageId: string, emoji: string, options?: ChatCommonOptions): Promise<void>;
-export declare function grantChatAccess(channel: string, username: string, options?: ChatCommonOptions & {
-    readOnly?: boolean;
-}): Promise<void>;
-export declare function revokeChatAccess(channel: string, username: string, options?: ChatCommonOptions): Promise<void>;
-export declare function setChatVisibility(channel: string, visibility: string, options?: ChatCommonOptions): Promise<void>;

package/dist/commands/chat.js

@@ -6,52 +6,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.listChatChannels = listChatChannels;
 exports.readChatChannel = readChatChannel;
 exports.readChatThread = readChatThread;
+exports.listChatInbox = listChatInbox;
+exports.readChatConversation = readChatConversation;
 exports.sendChatMessage = sendChatMessage;
 exports.replyChatMessage = replyChatMessage;
+exports.sendChatDirectMessage = sendChatDirectMessage;
 exports.editChatMessage = editChatMessage;
 exports.reactChatMessage = reactChatMessage;
 exports.unreactChatMessage = unreactChatMessage;
-exports.grantChatAccess = grantChatAccess;
-exports.revokeChatAccess = revokeChatAccess;
-exports.setChatVisibility = setChatVisibility;
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+const types_1 = require("@playdrop/types");
 const commandContext_1 = require("../commandContext");
 const errors_1 = require("../errors");
 const messages_1 = require("../messages");
 const output_1 = require("../output");
+const CHAT_ATTACHMENT_MAX_COUNT = 10;
+const CHAT_ATTACHMENT_CONTENT_TYPE_BY_EXTENSION = {
+    ".gif": "image/gif",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".webp": "image/webp",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".webm": "video/webm",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".markdown": "text/markdown",
+    ".json": "application/json",
+};
 function positiveId(raw, command) {
-    const value = Number(raw);
-    if (!Number.isInteger(value) || value <= 0) {
-        (0, messages_1.printErrorWithHelp)("Message id must be a positive integer.", [], { command });
-        process.exitCode = 1;
-        return null;
+    try {
+        if (BigInt(raw) > 0n)
+            return raw;
+    }
+    catch {
+        // Report the same validation error for malformed and non-positive IDs.
     }
-    return value;
-}
-function contentTypeForFile(filePath) {
-    const extension = node_path_1.default.extname(filePath).toLowerCase();
-    if (extension === ".gif")
-        return "image/gif";
-    if (extension === ".jpg" || extension === ".jpeg")
-        return "image/jpeg";
-    if (extension === ".png")
-        return "image/png";
-    if (extension === ".webp")
-        return "image/webp";
-    if (extension === ".mp4")
-        return "video/mp4";
-    if (extension === ".mov")
-        return "video/quicktime";
-    if (extension === ".webm")
-        return "video/webm";
-    if (extension === ".txt")
-        return "text/plain";
-    if (extension === ".md" || extension === ".markdown")
-        return "text/markdown";
-    if (extension === ".json")
-        return "application/json";
-    throw new Error(`unsupported_chat_file:${filePath}`);
+    (0, messages_1.printErrorWithHelp)("Message id must be a positive integer.", [], { command });
+    process.exitCode = 1;
+    return null;
 }
 async function readWriteOptions(options) {
     if (options.text !== undefined && options.textFile !== undefined) {
@@ -61,27 +57,57 @@ async function readWriteOptions(options) {
     const eventData = options.eventDataFile !== undefined
         ? JSON.parse(await node_fs_1.promises.readFile(node_path_1.default.resolve(options.eventDataFile), "utf8"))
         : undefined;
-    const files = await Promise.all((options.file ?? []).map(async (filePath) => {
-        const absolutePath = node_path_1.default.resolve(filePath);
-        const buffer = await node_fs_1.promises.readFile(absolutePath);
-        return {
-            file: new Blob([new Uint8Array(buffer)], { type: contentTypeForFile(absolutePath) }),
-            fileName: node_path_1.default.basename(absolutePath),
-        };
-    }));
     return {
+        clientMessageId: options.clientKey ?? (0, node_crypto_1.randomUUID)(),
         ...(body !== undefined ? { body } : {}),
-        ...(files.length > 0 ? { files } : {}),
-        ...(options.link?.length ? { links: options.link } : {}),
         ...(options.clientKey !== undefined ? { clientKey: options.clientKey } : {}),
         ...(options.eventType !== undefined ? { eventType: options.eventType } : {}),
         ...(eventData !== undefined ? { eventData } : {}),
         ...(options.asSystem !== undefined ? { asSystem: options.asSystem } : {}),
     };
 }
+async function uploadAttachmentFiles(client, conversationId, attachmentPaths = []) {
+    if (attachmentPaths.length > CHAT_ATTACHMENT_MAX_COUNT)
+        throw new Error("chat_attachment_limit_exceeded");
+    const files = await Promise.all(attachmentPaths.map(async (inputPath) => {
+        const filePath = node_path_1.default.resolve(inputPath);
+        const contentType = CHAT_ATTACHMENT_CONTENT_TYPE_BY_EXTENSION[node_path_1.default.extname(filePath).toLowerCase()];
+        if (!contentType)
+            throw new Error(`chat_invalid_attachment_content_type:${inputPath}`);
+        const stats = await node_fs_1.promises.stat(filePath);
+        if (!stats.isFile())
+            throw new Error(`chat_attachment_not_file:${inputPath}`);
+        if (stats.size <= 0 || stats.size > (0, types_1.maxMessageAttachmentBytes)(contentType)) {
+            throw new Error(`chat_invalid_attachment_size:${inputPath}`);
+        }
+        return {
+            fileName: node_path_1.default.basename(filePath),
+            contentType,
+            sizeBytes: stats.size,
+            bytes: await node_fs_1.promises.readFile(filePath),
+        };
+    }));
+    const createdSessionIds = [];
+    const results = await Promise.allSettled(files.map(async (file) => {
+        const session = await client.createChatAttachmentUploadSession(conversationId, file);
+        createdSessionIds.push(session.id);
+        await client.uploadChatAttachment(session, new Blob([new Uint8Array(file.bytes)], { type: file.contentType }));
+        await client.completeChatAttachmentUploadSession(session.id);
+        return session.id;
+    }));
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed) {
+        await Promise.allSettled(createdSessionIds.map((id) => client.abortChatAttachmentUploadSession(id)));
+        throw failed.reason;
+    }
+    return results.map((result) => result.value);
+}
 function printMessage(message, indent = "") {
     const edited = message.editedAt ? " edited" : "";
-    console.log(`${indent}#${message.id} ${message.author.displayName} [${message.author.kind}] | ${(0, output_1.formatTimestamp)(message.createdAt)}${edited}`);
+    const author = message.author
+        ? `${message.author.displayName} [${message.author.kind}]`
+        : "Deleted user [DELETED]";
+    console.log(`${indent}#${message.id} ${author} | ${(0, output_1.formatTimestamp)(message.createdAt)}${edited}`);
     if (message.body)
         console.log(`${indent}${message.body.replace(/\n/g, `\n${indent}`)}`);
     for (const attachment of message.attachments) {
@@ -137,9 +163,61 @@ async function readChatThread(rawMessageId, options = {}) {
         response.messages.forEach((message) => printMessage(message, "  "));
     });
 }
+async function listChatInbox(options = {}) {
+    await runChatCommand("chat inbox", options, async (client) => {
+        const response = await client.fetchChatConversations({ limit: 100 });
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        if (response.conversations.length === 0)
+            return console.log("Chat inbox is empty.");
+        for (const conversation of response.conversations) {
+            const label = conversation.channel?.displayName ?? conversation.peer?.displayName ?? "Conversation";
+            console.log(`${conversation.id}\t${label}\t${conversation.type}\t${conversation.unreadCount > 0 ? `${conversation.unreadCount} unread` : "read"}`);
+        }
+    });
+}
+async function readChatConversation(rawConversationId, options = {}) {
+    const conversationId = positiveId(rawConversationId, "chat conversation");
+    if (!conversationId)
+        return;
+    await runChatCommand("chat conversation", options, async (client) => {
+        const [conversation, messages] = await Promise.all([
+            client.fetchChatConversation(conversationId),
+            client.fetchConversationMessages(conversationId, { limit: 100 }),
+        ]);
+        if (options.json)
+            return (0, output_1.printJson)({ ...conversation, ...messages });
+        const label = conversation.conversation.channel?.displayName ?? conversation.conversation.peer?.displayName ?? conversationId;
+        console.log(`${label} (#${conversationId})`);
+        if (messages.messages.length === 0)
+            return console.log("No messages.");
+        messages.messages.forEach((message) => printMessage(message));
+    });
+}
 async function sendChatMessage(channel, options) {
     await runChatCommand("chat send", options, async (client) => {
-        const response = await client.sendChatMessage(channel, await readWriteOptions(options));
+        const write = await readWriteOptions(options);
+        if (write.asSystem && (options.attachment?.length ?? 0) > 0) {
+            throw new Error("chat_system_attachments_not_supported");
+        }
+        const response = write.asSystem
+            ? await client.sendSystemChatMessage(channel, {
+                body: write.body,
+                clientKey: write.clientKey,
+                eventType: write.eventType,
+                eventData: write.eventData,
+            })
+            : await (async () => {
+                const channelRecord = (await client.fetchChatChannels()).channels.find((candidate) => candidate.slug === channel);
+                if (!channelRecord)
+                    throw new Error("chat_channel_not_found");
+                const attachmentUploadIds = await uploadAttachmentFiles(client, channelRecord.id, options.attachment);
+                return await client.sendConversationMessage(channelRecord.id, {
+                    clientMessageId: write.clientMessageId,
+                    body: write.body,
+                    ...(attachmentUploadIds.length > 0 ? { attachmentUploadIds } : {}),
+                });
+            })();
         if (options.json)
             return (0, output_1.printJson)(response);
         (0, output_1.printSuccess)(`Message #${response.message.id} sent to ${channel}.`);
@@ -150,19 +228,59 @@ async function replyChatMessage(rawMessageId, options) {
     if (!messageId)
         return;
     await runChatCommand("chat reply", options, async (client) => {
-        const response = await client.replyChatMessage(messageId, await readWriteOptions(options));
+        const write = await readWriteOptions(options);
+        if (write.asSystem && (options.attachment?.length ?? 0) > 0) {
+            throw new Error("chat_system_attachments_not_supported");
+        }
+        const response = write.asSystem
+            ? await client.replySystemChatMessage(messageId, {
+                body: write.body,
+                clientKey: write.clientKey,
+                eventType: write.eventType,
+                eventData: write.eventData,
+            })
+            : await (async () => {
+                const context = await client.fetchChatThread(messageId, { limit: 1 });
+                if (!context.conversationId)
+                    throw new Error("chat_message_context_missing");
+                const attachmentUploadIds = await uploadAttachmentFiles(client, context.conversationId, options.attachment);
+                return await client.sendConversationMessage(context.conversationId, {
+                    clientMessageId: write.clientMessageId,
+                    body: write.body,
+                    ...(attachmentUploadIds.length > 0 ? { attachmentUploadIds } : {}),
+                    replyToMessageId: messageId,
+                    ...(context.threadingAvailable ? { threadRootMessageId: messageId } : {}),
+                });
+            })();
         if (options.json)
             return (0, output_1.printJson)(response);
         (0, output_1.printSuccess)(`Reply #${response.message.id} sent.`);
     });
 }
+async function sendChatDirectMessage(username, options) {
+    await runChatCommand("chat dm", options, async (client) => {
+        if (options.asSystem)
+            throw new Error("chat_dm_system_not_supported");
+        const write = await readWriteOptions(options);
+        const direct = await client.createDirectChatConversation(username.trim().toLowerCase());
+        const attachmentUploadIds = await uploadAttachmentFiles(client, direct.conversation.id, options.attachment);
+        const response = await client.sendConversationMessage(direct.conversation.id, {
+            clientMessageId: write.clientMessageId,
+            body: write.body,
+            ...(attachmentUploadIds.length > 0 ? { attachmentUploadIds } : {}),
+        });
+        if (options.json)
+            return (0, output_1.printJson)(response);
+        (0, output_1.printSuccess)(`Direct message #${response.message.id} sent to ${username}.`);
+    });
+}
 async function editChatMessage(rawMessageId, options) {
     const messageId = positiveId(rawMessageId, "chat edit");
     if (!messageId)
         return;
     await runChatCommand("chat edit", options, async (client) => {
         const write = await readWriteOptions(options);
-        const response = await client.editChatMessage(messageId, write);
+        const response = await client.editChatMessage(messageId, { body: write.body ?? "" });
         if (options.json)
             return (0, output_1.printJson)(response);
         (0, output_1.printSuccess)(`Message #${messageId} edited.`);
@@ -190,33 +308,3 @@ async function unreactChatMessage(rawMessageId, emoji, options = {}) {
         (0, output_1.printSuccess)(`${emoji} removed from message #${messageId}.`);
     });
 }
-async function grantChatAccess(channel, username, options = {}) {
-    await runChatCommand("chat access grant", options, async (client) => {
-        const response = await client.grantChatAccess(channel, username, !options.readOnly);
-        if (options.json)
-            return (0, output_1.printJson)(response);
-        (0, output_1.printSuccess)(`${username} now has ${response.canWrite ? "write" : "read"} access to ${channel}.`);
-    });
-}
-async function revokeChatAccess(channel, username, options = {}) {
-    await runChatCommand("chat access revoke", options, async (client) => {
-        await client.revokeChatAccess(channel, username);
-        if (options.json)
-            return (0, output_1.printJson)({ success: true, channel, username });
-        (0, output_1.printSuccess)(`${username} no longer has access to ${channel}.`);
-    });
-}
-async function setChatVisibility(channel, visibility, options = {}) {
-    const readPolicy = visibility === "public" ? "PUBLIC" : visibility === "admin-only" ? "ADMIN_ONLY" : null;
-    if (!readPolicy) {
-        (0, messages_1.printErrorWithHelp)("Visibility must be public or admin-only.", [], { command: "chat visibility" });
-        process.exitCode = 1;
-        return;
-    }
-    await runChatCommand("chat visibility", options, async (client) => {
-        const response = await client.setChatVisibility(channel, readPolicy);
-        if (options.json)
-            return (0, output_1.printJson)(response);
-        (0, output_1.printSuccess)(`${channel} visibility is now ${visibility}.`);
-    });
-}

package/dist/commands/check.js

@@ -13,6 +13,7 @@ const messages_1 = require("../messages");
 const loadCheck_1 = require("../apps/loadCheck");
 const devShared_1 = require("./devShared");
 const taskCaptureSession_1 = require("./taskCaptureSession");
+const serverBuild_1 = require("../apps/serverBuild");
 function resolveProjectCheckTarget(targetArg, appOption) {
     try {
         return (0, devShared_1.resolveDevTarget)(targetArg, appOption);
@@ -32,7 +33,7 @@ function resolveProjectCheckTarget(targetArg, appOption) {
 }
 function parseProjectCheckTimeoutMs(value) {
     if (value === undefined || value === null || value === "") {
-        return 15000;
+        return loadCheck_1.DEFAULT_HOSTED_LAUNCH_DEADLINE_MS;
     }
     const numeric = typeof value === "number" ? value : Number(value);
     if (!Number.isFinite(numeric) || numeric <= 0) {
@@ -89,6 +90,19 @@ async function check(targetArg, options = {}) {
         process.exitCode = 1;
         return;
     }
+    if (taskLookup.task.server) {
+        try {
+            const serverBuild = await (0, serverBuild_1.buildGameServer)(taskLookup.task);
+            if (!serverBuild)
+                throw new Error("server_build_missing");
+            console.log(`[check] Server contract passed: ${serverBuild.manifest.rooms.join(", ")} -> ${(0, serverBuild_1.formatServerBuildPath)(taskLookup.task, serverBuild.bundlePath)} (${serverBuild.manifest.size} bytes)`);
+        }
+        catch (error) {
+            (0, messages_1.printErrorWithHelp)(error instanceof Error ? error.message : "Server validation failed.", ["Fix the server declaration, frozen dependencies, imports, authentication, or bundle output."], { command: "project check" });
+            process.exitCode = 1;
+            return;
+        }
+    }
     let tapeSurface = null;
     let playtestTape = null;
     if (options.tape) {
@@ -183,6 +197,24 @@ async function check(targetArg, options = {}) {
             process.exitCode = 1;
             return;
         }
+        let gameServerCredential = null;
+        if (taskLookup.task?.server) {
+            if (!taskLookup.task.version || typeof registeredApp.id !== "number") {
+                (0, messages_1.printErrorWithHelp)("A registered app and exact catalogue version are required for local game-server authentication.", ["Register the app and set its version in catalogue.json."], { command: "project check" });
+                process.exitCode = 1;
+                return;
+            }
+            try {
+                gameServerCredential = await client.requestDevGameServerCredential(registeredApp.id, {
+                    version: taskLookup.task.version,
+                });
+            }
+            catch (error) {
+                (0, messages_1.printErrorWithHelp)(error instanceof Error ? error.message : "Failed to request the local game-server credential.", ["Confirm the logged-in creator owns this registered app and the catalogue version exists."], { command: "project check" });
+                process.exitCode = 1;
+                return;
+            }
+        }
         const runCheck = async (input) => await (0, loadCheck_1.runLocalHostedLoadCheck)({
             client,
             apiBase: envConfig.apiBase,
@@ -197,6 +229,7 @@ async function check(targetArg, options = {}) {
             surface: input.surface,
             playtestTape: input.tape,
             postReadyWaitMs: input.postReadyWaitMs,
+            gameServerCredential,
         });
         if (tapeSurface && playtestTape) {
             const idleScreenshotPath = buildComparisonScreenshotPath(screenshotPath, "idle");