@playdrop/playdrop-cli 0.9.6 → 0.10.0

package/dist/commands/generation.js

@@ -1,10 +1,44 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveImageAttachment = resolveImageAttachment;
 exports.generate = generate;
 exports.browseGenerationJobs = browseGenerationJobs;
 exports.showGenerationJob = showGenerationJob;
 exports.generations = generations;
+const config_1 = require("@playdrop/config");
 const types_1 = require("@playdrop/types");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -40,6 +74,8 @@ const LOCAL_IMAGE_MIME_BY_EXTENSION = {
     '.jpeg': 'image/jpeg',
     '.webp': 'image/webp',
 };
+const OUTPUT_IMAGE_MIME_BY_EXTENSION = LOCAL_IMAGE_MIME_BY_EXTENSION;
+const GENERATED_PNG_OUTPUT_MAX_BYTES = config_1.MAX_VERSION_HERO_BYTES;
 function isPlaydropSpeechVoiceId(value) {
     return types_1.PLAYDROP_SPEECH_VOICE_IDS.includes(value);
 }
@@ -596,6 +632,211 @@ function printGenerateResult(modality, payload) {
         console.log('Generated Asset: none');
     }
 }
+let pngOutputCrcTable = null;
+function getPngOutputCrcTable() {
+    if (pngOutputCrcTable) {
+        return pngOutputCrcTable;
+    }
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+        }
+        table[n] = c >>> 0;
+    }
+    pngOutputCrcTable = table;
+    return table;
+}
+function pngOutputCrc32(buffer) {
+    const table = getPngOutputCrcTable();
+    let crc = 0xffffffff;
+    for (let index = 0; index < buffer.length; index++) {
+        const byte = buffer[index];
+        crc = table[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function createPngOutputTextChunk(keyword, value) {
+    const keywordText = keyword.trim().slice(0, 79);
+    if (!/^[\x20-\x7e]+$/.test(keywordText) || keywordText.includes('\0')) {
+        throw new Error('ai_generation_image_output_metadata_failed');
+    }
+    const textValue = value.replace(/[^\x20-\xff]/g, ' ').slice(0, 4096);
+    const data = Buffer.concat([
+        Buffer.from(keywordText, 'latin1'),
+        Buffer.from([0]),
+        Buffer.from(textValue, 'latin1'),
+    ]);
+    const type = Buffer.from('tEXt', 'ascii');
+    const length = Buffer.alloc(4);
+    length.writeUInt32BE(data.length, 0);
+    const crc = Buffer.alloc(4);
+    crc.writeUInt32BE(pngOutputCrc32(Buffer.concat([type, data])), 0);
+    return Buffer.concat([length, type, data, crc]);
+}
+function extractGeneratedImageUrl(payload) {
+    if (typeof payload?.imageUrl === 'string' && payload.imageUrl.trim()) {
+        return payload.imageUrl.trim();
+    }
+    if (typeof payload?.outputImage === 'string' && payload.outputImage.trim()) {
+        return payload.outputImage.trim();
+    }
+    return null;
+}
+function embedGeneratedImageOutputMetadata(buffer, inputPrompt, payload) {
+    if (!isPngSignature(buffer)) {
+        return buffer;
+    }
+    const generationId = typeof payload?.billing?.generationId === 'string'
+        ? payload.billing.generationId
+        : typeof payload?.generationId === 'string'
+            ? payload.generationId
+            : '';
+    const chunks = [
+        createPngOutputTextChunk('playdrop:cliOutputTool', 'playdrop ai create image --output'),
+        createPngOutputTextChunk('playdrop:cliOutputPrompt', inputPrompt),
+        ...(generationId ? [createPngOutputTextChunk('playdrop:generationId', generationId)] : []),
+    ];
+    const signature = buffer.subarray(0, 8);
+    const parts = [signature];
+    let offset = 8;
+    let inserted = false;
+    while (offset + 12 <= buffer.length) {
+        const length = buffer.readUInt32BE(offset);
+        const chunkEnd = offset + 12 + length;
+        if (chunkEnd > buffer.length) {
+            throw new Error('ai_generation_image_output_metadata_failed');
+        }
+        const chunkType = buffer.toString('ascii', offset + 4, offset + 8);
+        if (chunkType === 'IEND' && !inserted) {
+            parts.push(...chunks);
+            inserted = true;
+        }
+        parts.push(buffer.subarray(offset, chunkEnd));
+        offset = chunkEnd;
+        if (chunkType === 'IEND') {
+            break;
+        }
+    }
+    if (!inserted) {
+        throw new Error('ai_generation_image_output_metadata_failed');
+    }
+    return Buffer.concat(parts);
+}
+async function writeGeneratedImageOutput(payload, outputPath, inputPrompt) {
+    const imageUrl = extractGeneratedImageUrl(payload);
+    if (!imageUrl) {
+        throw new Error('ai_generation_image_output_missing');
+    }
+    const response = await fetch(imageUrl);
+    if (!response.ok) {
+        throw new Error(`ai_generation_image_output_fetch_failed:${response.status}`);
+    }
+    const contentType = response.headers.get('content-type')?.toLowerCase() ?? '';
+    if (!contentType.startsWith('image/')) {
+        throw new Error(`ai_generation_image_output_invalid_content_type:${contentType || 'unknown'}`);
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.length === 0) {
+        throw new Error('ai_generation_image_output_empty');
+    }
+    const normalizedBuffer = await normalizeGeneratedImageOutputBuffer(buffer, outputPath);
+    const outputBuffer = embedGeneratedImageOutputMetadata(normalizedBuffer, inputPrompt, payload);
+    const resolvedPath = (0, node_path_1.resolve)(process.cwd(), outputPath);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(resolvedPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(resolvedPath, outputBuffer);
+    console.log(`Saved Image: ${resolvedPath}`);
+}
+async function normalizeGeneratedImageOutputBuffer(buffer, outputPath) {
+    const extension = (0, node_path_1.extname)(outputPath).toLowerCase();
+    const targetMimeType = OUTPUT_IMAGE_MIME_BY_EXTENSION[extension];
+    if (!targetMimeType) {
+        return buffer;
+    }
+    const detectedMimeType = detectLocalImageMimeType(buffer);
+    if (!detectedMimeType) {
+        throw new Error('ai_generation_image_output_unsupported_type');
+    }
+    if (detectedMimeType === targetMimeType) {
+        if (targetMimeType === 'image/png' && buffer.length > GENERATED_PNG_OUTPUT_MAX_BYTES) {
+            return optimizeGeneratedPngOutputBuffer(buffer);
+        }
+        return buffer;
+    }
+    let sharp;
+    try {
+        const sharpModule = await Promise.resolve().then(() => __importStar(require('sharp')));
+        sharp = sharpModule.default ?? sharpModule;
+    }
+    catch {
+        throw new Error('ai_generation_image_output_conversion_unavailable');
+    }
+    try {
+        if (targetMimeType === 'image/png') {
+            return await optimizeGeneratedPngOutputBuffer(buffer, sharp);
+        }
+        const pipeline = sharp(buffer, { failOn: 'error' });
+        if (targetMimeType === 'image/jpeg') {
+            return await pipeline.jpeg({ quality: 92 }).toBuffer();
+        }
+        if (targetMimeType === 'image/webp') {
+            return await pipeline.webp({ quality: 92 }).toBuffer();
+        }
+    }
+    catch {
+        throw new Error('ai_generation_image_output_conversion_failed');
+    }
+    return buffer;
+}
+async function optimizeGeneratedPngOutputBuffer(buffer, loadedSharp) {
+    let sharp = loadedSharp;
+    if (!sharp) {
+        try {
+            const sharpModule = await Promise.resolve().then(() => __importStar(require('sharp')));
+            sharp = sharpModule.default ?? sharpModule;
+        }
+        catch {
+            throw new Error('ai_generation_image_output_conversion_unavailable');
+        }
+    }
+    const metadata = await sharp(buffer, { failOn: 'error' }).metadata();
+    const sourceWidth = typeof metadata.width === 'number' && metadata.width > 0 ? metadata.width : null;
+    const sourceHeight = typeof metadata.height === 'number' && metadata.height > 0 ? metadata.height : null;
+    const attempts = [
+        { scale: 1, palette: false, quality: 100 },
+        { scale: 1, palette: true, quality: 92 },
+        { scale: 0.9, palette: true, quality: 88 },
+        { scale: 0.8, palette: true, quality: 84 },
+        { scale: 0.7, palette: true, quality: 80 },
+        { scale: 0.6, palette: true, quality: 76 },
+        { scale: 0.5, palette: true, quality: 72 },
+    ];
+    let smallest = null;
+    for (const attempt of attempts) {
+        let pipeline = sharp(buffer, { failOn: 'error' }).rotate();
+        if (attempt.scale < 1 && sourceWidth && sourceHeight) {
+            pipeline = pipeline.resize({
+                width: Math.max(1, Math.round(sourceWidth * attempt.scale)),
+                height: Math.max(1, Math.round(sourceHeight * attempt.scale)),
+                fit: 'inside',
+                withoutEnlargement: true,
+            });
+        }
+        const output = await pipeline.png({
+            compressionLevel: 9,
+            adaptiveFiltering: true,
+            ...(attempt.palette ? { palette: true, quality: attempt.quality } : {}),
+        }).toBuffer();
+        if (!smallest || output.length < smallest.length) {
+            smallest = output;
+        }
+        if (output.length <= GENERATED_PNG_OUTPUT_MAX_BYTES) {
+            return output;
+        }
+    }
+    throw new Error(`ai_generation_image_output_too_large:${smallest?.length ?? buffer.length}:${GENERATED_PNG_OUTPUT_MAX_BYTES}`);
+}
 function formatJobStatus(job) {
     const progress = typeof job.progressPercent === 'number'
         ? ` progress=${Math.max(0, Math.min(100, Math.round(job.progressPercent)))}%`
@@ -624,6 +865,16 @@ async function generate(typeInput, promptInput, options = {}) {
         process.exitCode = 1;
         return;
     }
+    const outputPath = typeof options.output === 'string' && options.output.trim().length > 0
+        ? options.output.trim()
+        : null;
+    if (outputPath && parsed.modality !== 'IMAGE') {
+        (0, messages_1.printErrorWithHelp)('The --output option is only supported for image generation.', ['Use "playdrop ai create image ... --output <file>".'], {
+            command: 'ai create',
+        });
+        process.exitCode = 1;
+        return;
+    }
     await (0, commandContext_1.withEnvironment)('ai create', 'Generating AI assets', async ({ aiClient }) => {
         try {
             const created = await aiClient.createGenerationJob(parsed.request);
@@ -656,6 +907,9 @@ async function generate(typeInput, promptInput, options = {}) {
                 throw new Error(`${errorCode}: ${errorMessage}`);
             }
             const payload = (job.resultData && typeof job.resultData === 'object') ? job.resultData : {};
+            if (outputPath) {
+                await writeGeneratedImageOutput(payload, outputPath, parsed.request.input);
+            }
             if (options.json) {
                 (0, output_1.printJson)({ job, result: payload });
                 return;
@@ -711,6 +965,26 @@ function handleAiFailure(error, command, context) {
         process.exitCode = 1;
         return true;
     }
+    if (message === 'ai_generation_image_output_unsupported_type') {
+        (0, messages_1.printErrorWithHelp)('AI create returned an image format that Playdrop CLI could not identify.', ['Retry the command. If the problem persists, contact Playdrop support.'], { command });
+        process.exitCode = 1;
+        return true;
+    }
+    if (message === 'ai_generation_image_output_conversion_unavailable') {
+        (0, messages_1.printErrorWithHelp)('AI create could not convert the generated image to the requested output file type.', ['Install the Playdrop CLI dependencies again, then retry.'], { command });
+        process.exitCode = 1;
+        return true;
+    }
+    if (message === 'ai_generation_image_output_conversion_failed') {
+        (0, messages_1.printErrorWithHelp)('AI create failed while converting the generated image to the requested output file type.', ['Retry with a matching output extension such as .jpg, or retry the generation.'], { command });
+        process.exitCode = 1;
+        return true;
+    }
+    if (message === 'ai_generation_image_output_metadata_failed') {
+        (0, messages_1.printErrorWithHelp)('AI create failed while writing PlayDrop metadata to the generated image.', ['Retry the generation. The output image must keep prompt metadata for worker validation.'], { command });
+        process.exitCode = 1;
+        return true;
+    }
     if (message.startsWith('ai_generation_job_timeout:')) {
         const detail = message.split(':').slice(1).join(':').trim();
         (0, messages_1.printErrorWithHelp)(detail || 'AI create timed out while waiting for the job to finish.', ['Retry the command with a higher --timeout value if the job normally takes longer.'], { command });

package/dist/commands/upload.d.ts

@@ -1,8 +1,34 @@
+import type { ApiClient } from '@playdrop/api-client';
+import type { UserResponse } from '@playdrop/types';
 export type UploadCommandOptions = {
     env?: string;
     skipEcs?: boolean;
     skipReview?: boolean;
     clearTags?: boolean;
-    gameIdea?: string;
 };
 export declare function upload(pathOrName: string, options?: UploadCommandOptions): Promise<void>;
+export type WorkerAppPublishInput = {
+    client: ApiClient;
+    taskId: number;
+    kind: 'NEW_GAME' | 'GAME_UPDATE';
+    expectedAppName?: string | null;
+    playdropAssetRequirement?: WorkerPlaydropAssetRequirement | null;
+    creatorRequest?: string | null;
+    projectDir: string;
+    creatorUsername: string;
+    apiBase: string;
+    webBase?: string | null;
+    token: string;
+    user: UserResponse;
+};
+export type WorkerAppPublishResult = {
+    appId: number;
+    appVersionId: number;
+    versionNodeId: string;
+    version: string;
+    appName: string;
+    creatorUsername: string;
+    warnings: string[];
+};
+export type WorkerPlaydropAssetRequirement = 'PACK' | 'ASSET_OR_PACK';
+export declare function publishWorkerAppProject(input: WorkerAppPublishInput): Promise<WorkerAppPublishResult>;