@playdrop/playdrop-cli 0.9.6 → 0.10.1

package/dist/commands/review.js

@@ -0,0 +1,353 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUIRED_REVIEW_EVIDENCE_FILES = exports.REVIEW_CRITERIA = void 0;
+exports.validateGameReviewResult = validateGameReviewResult;
+exports.validateReviewResultCommand = validateReviewResultCommand;
+exports.composeReviewEvidence = composeReviewEvidence;
+exports.createReviewRatingCard = createReviewRatingCard;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const sharp_1 = __importDefault(require("sharp"));
+const output_1 = require("../output");
+exports.REVIEW_CRITERIA = [
+    'Gameplay / Core Loop',
+    'Depth / Replayability',
+    'Controls / Input',
+    'UX / Usability',
+    'First Time User Experience',
+    'Visuals / Art Direction',
+    'Audio / Feedback',
+    'Store Listing & Metadata Accuracy',
+    'Safety / Age Rating / Compliance',
+    'Performance / Stability',
+];
+const TERMINAL_REVIEW_STATES = new Set([
+    'FAILED',
+    'LOW_QUALITY',
+    'PASSED',
+    'GOOD',
+    'EXCELLENT',
+]);
+const STATE_OUTCOME = {
+    EXCELLENT: 'Excellent',
+    FAILED: 'Blocked',
+    GOOD: 'Good',
+    LOW_QUALITY: 'Limited',
+    PASSED: 'Passed',
+};
+exports.REQUIRED_REVIEW_EVIDENCE_FILES = [
+    'core.png',
+    'win.png',
+    'loss.png',
+    'composite.png',
+    'rating-card.png',
+];
+const REVIEW_EVIDENCE_MAX_BYTES = 10 * 1024 * 1024;
+function resolveFilePath(filePath, code) {
+    const normalized = typeof filePath === 'string' ? filePath.trim() : '';
+    if (!normalized) {
+        throw new Error(code);
+    }
+    return node_path_1.default.isAbsolute(normalized) ? normalized : node_path_1.default.resolve(process.cwd(), normalized);
+}
+async function readRequiredTextFile(filePath, code) {
+    const resolved = resolveFilePath(filePath, code);
+    const content = await node_fs_1.promises.readFile(resolved, 'utf8');
+    if (!content.trim()) {
+        throw new Error(code);
+    }
+    return content;
+}
+function requireLine(text, prefix) {
+    const line = text.split(/\r?\n/).find((entry) => entry.startsWith(prefix));
+    if (!line) {
+        throw new Error(`missing_review_line:${prefix}`);
+    }
+    return line.slice(prefix.length).trim();
+}
+function normalizeReviewText(...values) {
+    return values
+        .join(' ')
+        .toLowerCase()
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function parseScores(reviewMessage) {
+    if (/\/5\b/.test(reviewMessage)) {
+        throw new Error('review_scores_must_use_10_point_scale');
+    }
+    const scores = {};
+    for (const criterion of exports.REVIEW_CRITERIA) {
+        const escaped = criterion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`^- ${escaped}: (10|[1-9])/10 \\| .+`, 'm');
+        const match = reviewMessage.match(regex);
+        if (!match) {
+            throw new Error(`missing_or_invalid_criterion_score:${criterion}`);
+        }
+        scores[criterion] = Number.parseInt(match[1], 10);
+    }
+    return scores;
+}
+function averageScore(scores) {
+    const values = Object.values(scores);
+    return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function minimumScore(scores) {
+    return Math.min(...Object.values(scores));
+}
+function validateOutcomeAgainstScores(outcome, scores) {
+    const average = averageScore(scores);
+    const minimum = minimumScore(scores);
+    const gameplay = scores['Gameplay / Core Loop'];
+    const controls = scores['Controls / Input'];
+    const ux = scores['UX / Usability'];
+    const ftue = scores['First Time User Experience'];
+    const visuals = scores['Visuals / Art Direction'];
+    const performance = scores['Performance / Stability'];
+    const actual = `actual=average=${average.toFixed(2)},minimum=${minimum},gameplay=${gameplay},controls=${controls},ux=${ux},ftue=${ftue},visuals=${visuals},performance=${performance}`;
+    if (outcome === 'Excellent' && (average < 8.5 || minimum < 7 || gameplay < 8 || controls < 8 || ux < 8 || ftue < 7 || visuals < 8 || performance < 8)) {
+        throw new Error(`excellent_outcome_not_supported_by_scores:requires=average>=8.5,minimum>=7,gameplay>=8,controls>=8,ux>=8,ftue>=7,visuals>=8,performance>=8:${actual}:use_good_or_lower_outcome_unless_scores_are_supported_by_evidence`);
+    }
+    if (outcome === 'Good' && (average < 7.5 || minimum < 6 || gameplay < 7 || controls < 7 || ux < 7 || ftue < 6 || visuals < 7 || performance < 7)) {
+        throw new Error(`good_outcome_not_supported_by_scores:requires=average>=7.5,minimum>=6,gameplay>=7,controls>=7,ux>=7,ftue>=6,visuals>=7,performance>=7:${actual}:use_passed_or_lower_outcome_unless_scores_are_supported_by_evidence`);
+    }
+    if (outcome === 'Passed' && (average < 6 || minimum < 4 || gameplay < 5 || controls < 5 || performance < 5)) {
+        throw new Error(`passed_outcome_not_supported_by_scores:requires=average>=6,minimum>=4,gameplay>=5,controls>=5,performance>=5:${actual}:use_low_quality_or_failed_unless_scores_are_supported_by_evidence`);
+    }
+}
+function validateRequiredEvidenceLines(reviewMessage) {
+    const primaryVerb = requireLine(reviewMessage, 'Primary player verb: ');
+    const primaryEvidence = requireLine(reviewMessage, 'Primary interaction evidence: ');
+    const challengeEvidence = requireLine(reviewMessage, 'Challenge evidence: ');
+    const punchline = requireLine(reviewMessage, 'Punchline assessment: ');
+    const benchmark = requireLine(reviewMessage, 'Comparable benchmark: ');
+    if (primaryVerb.length < 3) {
+        throw new Error('primary_player_verb_too_vague');
+    }
+    if (primaryEvidence.length < 20) {
+        throw new Error('primary_interaction_evidence_too_vague');
+    }
+    if (challengeEvidence.length < 20) {
+        throw new Error('challenge_evidence_too_vague');
+    }
+    if (punchline.length < 8 || punchline.length > 160) {
+        throw new Error('punchline_assessment_invalid_length');
+    }
+    if (benchmark.length < 8) {
+        throw new Error('comparable_benchmark_too_vague');
+    }
+}
+function isNoScoreCaps(scoreCapsApplied) {
+    return scoreCapsApplied.trim().toLowerCase() === 'none';
+}
+function validateCapConsistency(input) {
+    const normalizedText = normalizeReviewText(input.reviewMessage, input.creatorFeedback);
+    const describesZeroChallenge = /\bzero challenge\b|\bno (?:real |meaningful )?challenge\b(?!-)|\bchallenge (?:is )?(?:absent|missing|nonexistent)\b/.test(normalizedText);
+    const describesPrimaryMissing = /\bprimary (?:interaction|verb) (?:is )?(?:absent|missing|unavailable)\b/.test(normalizedText);
+    if (isNoScoreCaps(input.scoreCapsApplied) && (describesZeroChallenge || describesPrimaryMissing)) {
+        const trigger = describesZeroChallenge ? 'zero_or_missing_challenge' : 'primary_interaction_missing';
+        throw new Error(`missing_required_score_cap:${trigger}:score_caps_applied_must_name_the_triggered_cap_or_adjust_the_evidence_wording`);
+    }
+    if (describesZeroChallenge && (['Passed', 'Good', 'Excellent'].includes(input.outcome) || input.scores['Gameplay / Core Loop'] > 3 || input.scores['Depth / Replayability'] > 3)) {
+        throw new Error('gameplay_challenge_absent_score_cap_required');
+    }
+}
+async function assertPngFile(filePath) {
+    const bytes = await node_fs_1.promises.readFile(filePath);
+    if (bytes.length <= 0 || bytes.length > REVIEW_EVIDENCE_MAX_BYTES) {
+        throw new Error(`invalid_review_evidence_size:${filePath}`);
+    }
+    const signature = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+    for (let index = 0; index < signature.length; index += 1) {
+        if (bytes[index] !== signature[index]) {
+            throw new Error(`review_evidence_not_png:${filePath}`);
+        }
+    }
+}
+async function validateGameReviewResult(input) {
+    const normalizedState = String(input.reviewState || '').trim().toUpperCase();
+    if (!TERMINAL_REVIEW_STATES.has(normalizedState)) {
+        return { skipped: true, reason: 'non_terminal_state' };
+    }
+    if (!input.reviewMessage.trim()) {
+        throw new Error('missing_review_message');
+    }
+    const creatorFeedback = input.creatorFeedback ?? '';
+    if (!creatorFeedback.trim()) {
+        throw new Error('missing_creator_feedback');
+    }
+    if (!input.evidenceDir.trim()) {
+        throw new Error('missing_evidence_dir');
+    }
+    const expectedOutcome = STATE_OUTCOME[normalizedState];
+    const actualOutcome = requireLine(input.reviewMessage, 'Outcome: ');
+    if (actualOutcome !== expectedOutcome) {
+        throw new Error(`review_outcome_state_mismatch:${actualOutcome}:${normalizedState}`);
+    }
+    const primarySurface = requireLine(input.reviewMessage, 'Primary reviewed surface: ');
+    if (!['MOBILE_PORTRAIT', 'MOBILE_LANDSCAPE', 'DESKTOP'].includes(primarySurface)) {
+        throw new Error(`invalid_primary_reviewed_surface:${primarySurface}`);
+    }
+    validateRequiredEvidenceLines(input.reviewMessage);
+    const scoreCapsApplied = requireLine(input.reviewMessage, 'Score caps applied: ');
+    if (!creatorFeedback.includes(`Reviewed surface: ${primarySurface}`)) {
+        throw new Error('creator_feedback_missing_reviewed_surface');
+    }
+    const scores = parseScores(input.reviewMessage);
+    validateOutcomeAgainstScores(actualOutcome, scores);
+    validateCapConsistency({
+        creatorFeedback,
+        outcome: actualOutcome,
+        reviewMessage: input.reviewMessage,
+        scoreCapsApplied,
+        scores,
+    });
+    const evidenceDir = resolveFilePath(input.evidenceDir, 'missing_evidence_dir');
+    for (const filename of exports.REQUIRED_REVIEW_EVIDENCE_FILES) {
+        await assertPngFile(node_path_1.default.join(evidenceDir, filename));
+    }
+    return {
+        average: averageScore(scores),
+        evidenceDir,
+        outcome: actualOutcome,
+        primarySurface,
+        scoreCount: Object.keys(scores).length,
+        skipped: false,
+    };
+}
+async function validateReviewResultCommand(options) {
+    const result = await validateGameReviewResult({
+        creatorFeedback: options.creatorFeedbackFile ? await readRequiredTextFile(options.creatorFeedbackFile, 'invalid_creator_feedback_file') : '',
+        evidenceDir: options.evidenceDir,
+        reviewMessage: await readRequiredTextFile(options.messageFile, 'invalid_review_message_file'),
+        reviewState: options.state,
+    });
+    console.log(JSON.stringify(result, null, 2));
+}
+async function resizeForComposite(filePath) {
+    const image = (0, sharp_1.default)(resolveFilePath(filePath, 'invalid_review_evidence_file'));
+    const metadata = await image.metadata();
+    if (!metadata.width || !metadata.height) {
+        throw new Error('invalid_review_evidence_image');
+    }
+    const buffer = await image
+        .resize({ width: 540, height: 960, fit: 'inside', withoutEnlargement: true })
+        .png()
+        .toBuffer();
+    const resizedMetadata = await (0, sharp_1.default)(buffer).metadata();
+    if (!resizedMetadata.width || !resizedMetadata.height) {
+        throw new Error('invalid_review_evidence_image');
+    }
+    return { buffer, width: resizedMetadata.width, height: resizedMetadata.height };
+}
+async function composeReviewEvidence(options) {
+    const entries = [
+        options.core ? { label: 'core', path: options.core } : null,
+        options.win ? { label: 'win', path: options.win } : null,
+        options.loss ? { label: 'loss', path: options.loss } : null,
+    ].filter((entry) => Boolean(entry));
+    if (entries.length === 0) {
+        throw new Error('missing_review_evidence_images');
+    }
+    const images = await Promise.all(entries.map((entry) => resizeForComposite(entry.path)));
+    const padding = 16;
+    const width = images.reduce((sum, image) => sum + image.width, padding * (images.length + 1));
+    const height = Math.max(...images.map((image) => image.height)) + padding * 2;
+    let left = padding;
+    const composites = images.map((image) => {
+        const composite = { input: image.buffer, left, top: padding };
+        left += image.width + padding;
+        return composite;
+    });
+    const outputPath = resolveFilePath(options.out, 'missing_out');
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(outputPath), { recursive: true });
+    await (0, sharp_1.default)({
+        create: {
+            width,
+            height,
+            channels: 4,
+            background: { r: 12, g: 12, b: 16, alpha: 1 },
+        },
+    })
+        .composite(composites)
+        .png()
+        .toFile(outputPath);
+    (0, output_1.printSuccess)(`Review evidence composite written to ${outputPath}`);
+    return { outputPath, imageCount: images.length };
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function parseCriterionRating(reviewMessage, criterion) {
+    const escaped = criterion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`^- ${escaped}: (10|[1-9])/10 \\| .+`, 'm');
+    const match = reviewMessage.match(regex);
+    if (!match) {
+        throw new Error(`missing_or_invalid_criterion_score:${criterion}`);
+    }
+    return Number.parseInt(match[1], 10);
+}
+function ratingColor(score) {
+    if (score <= 1)
+        return '#ff3b30';
+    if (score <= 4)
+        return '#ff9500';
+    if (score <= 6)
+        return '#ffd60a';
+    if (score <= 9)
+        return '#34c759';
+    return '#bf5af2';
+}
+function outcomeColor(outcome) {
+    if (outcome === 'Blocked')
+        return '#ff3b30';
+    if (outcome === 'Limited')
+        return '#ff9500';
+    if (outcome === 'Passed')
+        return '#ffd60a';
+    if (outcome === 'Good')
+        return '#34c759';
+    if (outcome === 'Excellent')
+        return '#bf5af2';
+    return '#ff9500';
+}
+async function createReviewRatingCard(options) {
+    const reviewMessage = await readRequiredTextFile(options.reviewMessageFile, 'invalid_review_message_file');
+    const outcome = requireLine(reviewMessage, 'Outcome: ');
+    const punchline = (options.punchline?.trim() || requireLine(reviewMessage, 'Punchline assessment: ')).slice(0, 160);
+    const title = (options.title?.trim() || 'Game review ratings').slice(0, 80);
+    const rows = exports.REVIEW_CRITERIA.map((criterion, index) => {
+        const score = parseCriterionRating(reviewMessage, criterion);
+        const x = index < 5 ? 56 : 628;
+        const y = 170 + (index % 5) * 92;
+        return `
+      <rect x="${x}" y="${y}" width="516" height="70" rx="6" fill="#15151c" stroke="#333340"/>
+      <rect x="${x}" y="${y}" width="8" height="70" fill="${ratingColor(score)}"/>
+      <text x="${x + 24}" y="${y + 42}" fill="#f5f5f7" font-size="22" font-weight="700">${escapeXml(criterion)}</text>
+      <text x="${x + 448}" y="${y + 44}" fill="${ratingColor(score)}" font-size="32" font-weight="800" text-anchor="end">${score}/10</text>
+    `;
+    }).join('');
+    const svg = `
+    <svg width="1200" height="760" xmlns="http://www.w3.org/2000/svg">
+      <rect width="1200" height="760" fill="#000"/>
+      <text x="56" y="82" fill="#fff" font-size="38" font-weight="800">${escapeXml(title)}</text>
+      <text x="1144" y="82" fill="${outcomeColor(outcome)}" font-size="30" font-weight="800" text-anchor="end">${escapeXml(outcome)}</text>
+      <line x1="56" y1="122" x2="1144" y2="122" stroke="#333340"/>
+      ${rows}
+      <line x1="56" y1="650" x2="1144" y2="650" stroke="#333340"/>
+      <text x="600" y="708" fill="${outcomeColor(outcome)}" font-size="32" font-weight="800" text-anchor="middle">${escapeXml(punchline)}</text>
+    </svg>
+  `;
+    const outputPath = resolveFilePath(options.out, 'missing_out');
+    await node_fs_1.promises.mkdir(node_path_1.default.dirname(outputPath), { recursive: true });
+    await (0, sharp_1.default)(Buffer.from(svg)).png().toFile(outputPath);
+    (0, output_1.printSuccess)(`Review rating card written to ${outputPath}`);
+    return { outputPath, width: 1200, height: 760 };
+}

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