@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/dist/commands/login.js

@@ -35,25 +35,26 @@ function storeLogin(env, data, options = {}) {
     if (!token) {
         (0, messages_1.printErrorWithHelp)("Login succeeded but no access token was returned.", ["Please try again in a moment.", "If the issue persists, contact the Playdrop team."], { command: "login" });
         process.exitCode = 1;
-        return;
+        return false;
     }
     const username = typeof data.user?.username === "string" ? data.user.username.trim() : "";
     if (!username) {
         (0, messages_1.printErrorWithHelp)("Login succeeded but the account username was missing.", ["Please try again in a moment.", "If the issue persists, contact the Playdrop team."], { command: "login" });
         process.exitCode = 1;
-        return;
+        return false;
     }
-    (0, config_1.saveAccountSession)({ username, env, token });
+    (0, config_1.saveAccountSession)({ username, env, token, deviceApiKey: options.deviceApiKey });
     if (options.json) {
         (0, output_1.printJson)({
             status: "authenticated",
             username,
             env,
         });
-        return;
+        return true;
     }
     console.log(`Logged in as ${username} on ${env}.`);
     console.log('Next: run "playdrop auth whoami" to confirm your session.');
+    return true;
 }
 async function storeDeviceLogin(env, baseUrl, initialLogin, options = {}) {
     const sessionToken = extractAccessToken(initialLogin);
@@ -64,17 +65,32 @@ async function storeDeviceLogin(env, baseUrl, initialLogin, options = {}) {
     if (!username) {
         throw new Error("Login response is missing the username required to save this computer token.");
     }
+    const sessionClient = (0, apiClient_1.createCliApiClient)({ baseUrl, token: sessionToken });
+    let createdDeviceTokenId = null;
     try {
-        const sessionClient = (0, apiClient_1.createCliApiClient)({ baseUrl, token: sessionToken });
         const deviceToken = await sessionClient.createCliApiToken({
             name: buildCliLoginTokenName(),
         });
+        createdDeviceTokenId = deviceToken.id;
         const deviceLogin = await (0, apiClient_1.createCliApiClient)({ baseUrl }).loginWithApiKey({
             apiKey: deviceToken.apiKey,
         });
-        storeLogin(env, deviceLogin, options);
+        if (!storeLogin(env, deviceLogin, { ...options, deviceApiKey: deviceToken.apiKey })) {
+            throw new Error("cli_device_session_store_failed");
+        }
     }
     catch (unknownError) {
+        if (createdDeviceTokenId !== null) {
+            try {
+                await sessionClient.deleteCliApiToken(createdDeviceTokenId);
+            }
+            catch (cleanupError) {
+                throw new Error(`cli_device_token_cleanup_failed:${createdDeviceTokenId}:${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}:original_error:${unknownError instanceof Error ? unknownError.message : String(unknownError)}`);
+            }
+        }
+        if (unknownError instanceof Error && unknownError.message === "cli_device_session_store_failed") {
+            return;
+        }
         if (unknownError instanceof types_1.UnsupportedClientError) {
             (0, http_1.handleUnsupportedError)(unknownError, "Login");
             return;
@@ -118,7 +134,7 @@ async function loginWithKey(env, baseUrl, apiKey, options = {}) {
     const client = (0, apiClient_1.createCliApiClient)({ baseUrl });
     try {
         const data = await client.loginWithApiKey({ apiKey });
-        storeLogin(env, data, options);
+        storeLogin(env, data, { ...options, deviceApiKey: apiKey });
     }
     catch (unknownError) {
         if (unknownError instanceof types_1.UnsupportedClientError) {

package/dist/commands/review.d.ts

@@ -1,4 +1,4 @@
-export declare const REVIEW_CRITERIA: readonly ["Gameplay / Core Loop", "Depth / Replayability", "Controls / Input", "UX / Usability", "First Time User Experience", "Visuals / Art Direction", "Store Listing & Metadata Accuracy", "Safety / Age Rating / Compliance", "Performance / Stability"];
+export declare const REVIEW_QUALITY_DIMENSIONS: readonly ["Request Fidelity", "Core Loop", "Controls", "Presentation", "Usability", "Engagement", "Stability", "Listing", "Marketing", "Platform Integration"];
 declare const STATE_OUTCOME: {
     readonly EXCELLENT: "Excellent";
     readonly FAILED: "Blocked";

package/dist/commands/review.js

@@ -3,7 +3,7 @@ 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.REQUIRED_REVIEW_EVIDENCE_FILES = exports.REVIEW_QUALITY_DIMENSIONS = void 0;
 exports.normalizeTerminalReviewState = normalizeTerminalReviewState;
 exports.validateGameReviewResult = validateGameReviewResult;
 exports.validateReviewResultCommand = validateReviewResultCommand;
@@ -13,16 +13,26 @@ 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",
-    "Store Listing & Metadata Accuracy",
-    "Safety / Age Rating / Compliance",
-    "Performance / Stability",
+exports.REVIEW_QUALITY_DIMENSIONS = [
+    "Request Fidelity",
+    "Core Loop",
+    "Controls",
+    "Presentation",
+    "Usability",
+    "Engagement",
+    "Stability",
+    "Listing",
+    "Marketing",
+    "Platform Integration",
+];
+const PRIMARY_REVIEW_QUALITY_DIMENSIONS = [
+    "Request Fidelity",
+    "Core Loop",
+    "Controls",
+    "Presentation",
+    "Usability",
+    "Engagement",
+    "Stability",
 ];
 const STATE_OUTCOME = {
     EXCELLENT: "Excellent",
@@ -79,19 +89,16 @@ function requireLine(text, prefix) {
     }
     return line.slice(prefix.length).trim();
 }
-function normalizeReviewText(...values) {
-    return values.join(" ").toLowerCase().replace(/\s+/g, " ").trim();
-}
 function parseScores(reviewMessage) {
     const scores = {};
-    for (const criterion of exports.REVIEW_CRITERIA) {
-        const escaped = criterion.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const regex = new RegExp(`^- ${escaped}: (10|[1-9])/10 \\| .+`, "m");
+    for (const dimension of exports.REVIEW_QUALITY_DIMENSIONS) {
+        const escaped = dimension.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`^- ${escaped}: ([1-5])/5 \\| .+`, "m");
         const match = reviewMessage.match(regex);
         if (!match) {
-            throw new Error(`missing_or_invalid_criterion_score:${criterion}`);
+            throw new Error(`missing_or_invalid_quality_score:${dimension}`);
         }
-        scores[criterion] = Number.parseInt(match[1], 10);
+        scores[dimension] = Number.parseInt(match[1], 10);
     }
     return scores;
 }
@@ -99,43 +106,36 @@ 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 primaryMinimumScore(scores) {
+    return Math.min(...PRIMARY_REVIEW_QUALITY_DIMENSIONS.map((dimension) => scores[dimension]));
 }
-function validateOutcomeAgainstScores(outcome, scores) {
+function deriveOutcomeFromScores(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`);
+    const primaryMinimum = primaryMinimumScore(scores);
+    const requestFidelity = scores["Request Fidelity"];
+    const coreLoop = scores["Core Loop"];
+    const controls = scores.Controls;
+    const stability = scores.Stability;
+    if (primaryMinimum === 1)
+        return "Blocked";
+    if (average >= 4.5 && primaryMinimum >= 4)
+        return "Excellent";
+    if (average >= 4 && primaryMinimum >= 3)
+        return "Good";
+    if (average >= 3 &&
+        primaryMinimum >= 2 &&
+        requestFidelity >= 3 &&
+        coreLoop >= 3 &&
+        controls >= 3 &&
+        stability >= 3) {
+        return "Passed";
     }
-    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`);
+    return "Limited";
+}
+function validateOutcomeAgainstScores(outcome, scores) {
+    const expected = deriveOutcomeFromScores(scores);
+    if (outcome !== expected) {
+        throw new Error(`review_outcome_score_mismatch:expected=${expected}:actual=${outcome}:average=${averageScore(scores).toFixed(2)}:primaryMinimum=${primaryMinimumScore(scores)}`);
     }
 }
 function validateRequiredEvidenceLines(reviewMessage) {
@@ -143,7 +143,6 @@ function validateRequiredEvidenceLines(reviewMessage) {
     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");
     }
@@ -156,27 +155,6 @@ function validateRequiredEvidenceLines(reviewMessage) {
     if (punchline.length < 8 || punchline.length > 160) {
         throw new Error(`punchline_assessment_invalid_length: Punchline assessment length=${punchline.length}; expected 8..160 characters.`);
     }
-    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);
@@ -211,20 +189,15 @@ async function validateGameReviewResult(input) {
     if (!["MOBILE_PORTRAIT", "MOBILE_LANDSCAPE", "DESKTOP"].includes(primarySurface)) {
         throw new Error(`invalid_primary_reviewed_surface:${primarySurface}`);
     }
+    if (!/^Quality ratings:\s*$/m.test(input.reviewMessage)) {
+        throw new Error("missing_quality_ratings_heading");
+    }
     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));
@@ -303,23 +276,23 @@ async function composeReviewEvidence(options) {
 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");
+function parseQualityRating(reviewMessage, dimension) {
+    const escaped = dimension.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`^- ${escaped}: ([1-5])/5 \\| .+`, "m");
     const match = reviewMessage.match(regex);
     if (!match) {
-        throw new Error(`missing_or_invalid_criterion_score:${criterion}`);
+        throw new Error(`missing_or_invalid_quality_score:${dimension}`);
     }
     return Number.parseInt(match[1], 10);
 }
 function ratingColor(score) {
     if (score <= 1)
         return "#ff3b30";
-    if (score <= 4)
+    if (score === 2)
         return "#ff9500";
-    if (score <= 6)
+    if (score === 3)
         return "#ffd60a";
-    if (score <= 9)
+    if (score === 4)
         return "#34c759";
     return "#bf5af2";
 }
@@ -341,15 +314,15 @@ async function createReviewRatingCard(options) {
     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 rows = exports.REVIEW_QUALITY_DIMENSIONS.map((dimension, index) => {
+        const score = parseQualityRating(reviewMessage, dimension);
         const x = index < 5 ? 56 : 628;
-        const y = 170 + (index % 5) * 92;
+        const y = 158 + (index % 5) * 82;
         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>
+      <text x="${x + 24}" y="${y + 42}" fill="#f5f5f7" font-size="22" font-weight="700">${escapeXml(dimension)}</text>
+      <text x="${x + 448}" y="${y + 44}" fill="${ratingColor(score)}" font-size="32" font-weight="800" text-anchor="end">${score}/5</text>
     `;
     }).join("");
     const svg = `

package/dist/commands/source.d.ts

@@ -0,0 +1,19 @@
+type SourceKind = "asset" | "pack";
+type ExactSourceRef = {
+    kind: SourceKind;
+    creator: string;
+    name: string;
+    version: string;
+};
+export declare function parseExactSourceRef(raw: string, expectedKind: SourceKind): ExactSourceRef;
+export declare function prepareDestination(path: string): string;
+export declare function extractArchive(bytes: Uint8Array, destination: string): number;
+export declare function showExactContentDetail(kind: SourceKind, rawRef: string, options?: {
+    env?: string;
+    json?: boolean;
+}): Promise<void>;
+export declare function downloadContentSource(kind: SourceKind, rawRef: string, directory: string | undefined, options?: {
+    env?: string;
+    json?: boolean;
+}): Promise<void>;
+export {};

package/dist/commands/source.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExactSourceRef = parseExactSourceRef;
+exports.prepareDestination = prepareDestination;
+exports.extractArchive = extractArchive;
+exports.showExactContentDetail = showExactContentDetail;
+exports.downloadContentSource = downloadContentSource;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fflate_1 = require("fflate");
+const commandContext_1 = require("../commandContext");
+const errors_1 = require("../errors");
+const output_1 = require("../output");
+function parseExactSourceRef(raw, expectedKind) {
+    const pattern = expectedKind === "asset"
+        ? /^asset:([a-z0-9]+(?:-[a-z0-9]+)*)\/([a-z0-9]+(?:-[a-z0-9]+)*)@(r[1-9][0-9]*)$/
+        : /^pack:([a-z0-9]+(?:-[a-z0-9]+)*)\/([a-z0-9]+(?:-[a-z0-9]+)*)@(\d+\.\d+\.\d+)$/;
+    const match = pattern.exec(raw.trim());
+    if (!match) {
+        throw new Error(expectedKind === "asset"
+            ? "invalid_exact_asset_ref: expected asset:creator/name@rN"
+            : "invalid_exact_pack_ref: expected pack:creator/name@X.Y.Z");
+    }
+    return { kind: expectedKind, creator: match[1], name: match[2], version: match[3] };
+}
+function prepareDestination(path) {
+    const destination = (0, node_path_1.resolve)(path);
+    if ((0, node_fs_1.existsSync)(destination)) {
+        if (!(0, node_fs_1.lstatSync)(destination).isDirectory())
+            throw new Error(`source_destination_not_directory:${destination}`);
+        if ((0, node_fs_1.readdirSync)(destination).length > 0)
+            throw new Error(`source_destination_not_empty:${destination}`);
+    }
+    else {
+        (0, node_fs_1.mkdirSync)(destination, { recursive: true });
+    }
+    return destination;
+}
+function extractArchive(bytes, destination) {
+    const entries = (0, fflate_1.unzipSync)(bytes);
+    const files = Object.entries(entries).flatMap(([archivePath, content]) => {
+        const normalized = archivePath.replace(/\\/g, "/");
+        if (!normalized || normalized.startsWith("/") || normalized.split("/").includes("..")) {
+            throw new Error(`source_archive_unsafe_path:${archivePath}`);
+        }
+        if (normalized.endsWith("/"))
+            return [];
+        const outputPath = (0, node_path_1.resolve)(destination, normalized);
+        if (!outputPath.startsWith(`${destination}${node_path_1.sep}`))
+            throw new Error(`source_archive_unsafe_path:${archivePath}`);
+        return [{ outputPath, content }];
+    });
+    let fileCount = 0;
+    for (const { outputPath, content } of files) {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(outputPath), { recursive: true });
+        (0, node_fs_1.writeFileSync)(outputPath, content);
+        fileCount += 1;
+    }
+    return fileCount;
+}
+async function showExactContentDetail(kind, rawRef, options = {}) {
+    const command = `${kind} detail`;
+    await (0, commandContext_1.withPublicEnvironment)(command, async ({ client, envConfig }) => {
+        try {
+            const ref = parseExactSourceRef(rawRef, kind);
+            if (kind === "asset") {
+                const [{ asset }, { versions }] = await Promise.all([
+                    client.fetchAssetBySlug(ref.creator, ref.name),
+                    client.listAssetVersions(ref.creator, ref.name, { limit: 100 }),
+                ]);
+                const version = versions.find((candidate) => candidate.revisionLabel === ref.version);
+                if (!version)
+                    throw new Error(`asset_revision_not_found:${rawRef}`);
+                const output = {
+                    ref: rawRef,
+                    environment: envConfig.apiBase,
+                    asset: { ...asset, currentVersion: version },
+                    urls: {
+                        source: `${envConfig.apiBase}/assets/${encodeURIComponent(ref.creator)}/${encodeURIComponent(ref.name)}/versions/${version.revision}/source`,
+                    },
+                };
+                if (options.json)
+                    (0, output_1.printJson)(output);
+                else {
+                    console.log(`${asset.displayName} (${rawRef})\n${version.format} · ${version.visibility} · ${version.license}\n${output.urls.source}`);
+                }
+                return;
+            }
+            const [{ pack }, { versions }] = await Promise.all([
+                client.fetchAssetPackBySlug(ref.creator, ref.name),
+                client.listAssetPackVersions(ref.creator, ref.name, { limit: 100 }),
+            ]);
+            const version = versions.find((candidate) => candidate.version === ref.version);
+            if (!version)
+                throw new Error(`pack_version_not_found:${rawRef}`);
+            const base = `${envConfig.apiBase}/asset-packs/${encodeURIComponent(ref.creator)}/${encodeURIComponent(ref.name)}/versions/${encodeURIComponent(version.version)}`;
+            const output = {
+                ref: rawRef,
+                environment: envConfig.apiBase,
+                pack: { ...pack, currentVersion: version },
+                urls: { source: `${base}/source`, download: `${base}/download` },
+            };
+            if (options.json)
+                (0, output_1.printJson)(output);
+            else {
+                console.log(`${pack.displayName} (${rawRef})\n${version.assets.length} assets · ${version.visibility} · ${version.license}\n${output.urls.source}`);
+            }
+        }
+        catch (error) {
+            if (!(0, errors_1.handleCommandFailure)(error, command, "Content detail"))
+                throw error;
+        }
+    }, { env: options.env });
+}
+async function downloadContentSource(kind, rawRef, directory, options = {}) {
+    const command = `${kind} source`;
+    await (0, commandContext_1.withPublicEnvironment)(command, async ({ client }) => {
+        try {
+            const ref = parseExactSourceRef(rawRef, kind);
+            const result = kind === "asset"
+                ? await client.downloadAssetSource(ref.creator, ref.name, ref.version)
+                : await client.downloadAssetPackSource(ref.creator, ref.name, ref.version);
+            const destination = prepareDestination(directory ?? ref.name);
+            const fileCount = extractArchive(new Uint8Array(await result.blob.arrayBuffer()), destination);
+            const output = {
+                ref: rawRef,
+                destination,
+                filename: result.metadata.filename,
+                sizeBytes: result.metadata.sizeBytes,
+                files: fileCount,
+            };
+            if (options.json)
+                (0, output_1.printJson)(output);
+            else
+                console.log(`Downloaded ${rawRef} source to ${destination} (${fileCount} files).`);
+        }
+        catch (error) {
+            if (!(0, errors_1.handleCommandFailure)(error, command, "Source download"))
+                throw error;
+        }
+    }, { env: options.env });
+}

package/dist/commands/tweaks.js

@@ -9,21 +9,15 @@ const errors_1 = require("../errors");
 const messages_1 = require("../messages");
 const output_1 = require("../output");
 function tweakApiMessage(error) {
-    if (error.code === "creator_latest_private_version_required") {
+    if (error.code === "creator_latest_version_required") {
         const latestVersion = typeof error.details?.["latestVersion"] === "string" ? error.details["latestVersion"] : null;
         const latestId = typeof error.details?.["latestId"] === "string" ? error.details["latestId"] : null;
         const latestVisibility = typeof error.details?.["latestVisibility"] === "string" ? error.details["latestVisibility"] : null;
         return {
-            problem: latestVersion && latestVisibility === "PUBLIC"
-                ? `The latest tweak base, ${latestVersion}, is live and cannot be edited.`
-                : latestVersion
-                    ? `Tweaks can only be changed on the latest editable version, ${latestVersion}.`
-                    : "This app has no editable tweak base version.",
-            suggestions: latestVersion && latestVisibility === "PUBLIC"
-                ? [`Create a new private version based on ${latestId ?? "the latest tweak state"}, then tune that version.`]
-                : latestId
-                    ? [`Latest tweak state: ${latestId}`]
-                    : [],
+            problem: latestVersion
+                ? `Tweaks can only be changed on the latest source version, ${latestVersion}.`
+                : "This app has no tweak base version.",
+            suggestions: latestId ? [`Latest tweak state: ${latestId}${latestVisibility ? ` (${latestVisibility.toLowerCase()})` : ""}`] : [],
         };
     }
     return { problem: `PlayDrop rejected the tweak request: ${error.code ?? error.message} (HTTP ${error.status}).` };

package/dist/commands/upload-content.d.ts

@@ -2,7 +2,7 @@ import type { ApiClient } from "@playdrop/api-client";
 import { type AssetPackUploadedLocalAsset } from "@playdrop/types";
 import type { AssetPackTask, AssetSpecTask, AssetTask, OwnedAssetTask, PackOwnedAssetTask } from "../catalogue";
 import type { CliTask } from "../taskUtils";
-export type CurrentUserRole = "CREATOR" | "ADMIN" | null;
+export type CurrentUserRole = "CREATOR" | "CLOUD_WORKER" | "ADMIN" | null;
 export type UploadedAssetInfo = {
     creatorUsername: string;
     name: string;

package/dist/commands/upload-content.js

@@ -12,7 +12,6 @@ const types_1 = require("@playdrop/types");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const model_artifacts_1 = require("../assets/model-artifacts");
 const assetSpecs_1 = require("../assetSpecs");
 const EXTENSION_TO_FORMAT = {
     ".png": "PNG",
@@ -71,6 +70,9 @@ function createListingFileFromPath(filePath, expectedMime) {
     if (expectedMime === "video/mp4" && !isMp4Signature(data)) {
         throw new Error(`Invalid listing file signature for ${filePath}. Expected video/mp4.`);
     }
+    if (expectedMime === "application/zip" && !(data[0] === 0x50 && data[1] === 0x4b)) {
+        throw new Error(`Invalid source file signature for ${filePath}. Expected application/zip.`);
+    }
     return new File([data], (0, node_path_1.basename)(filePath), { type: expectedMime });
 }
 function computeSha256Hex(buffer) {
@@ -94,6 +96,9 @@ function prepareUploadFile(filePath, fieldName, explicitMimeType) {
     };
 }
 function buildListingMediaRelativePath(mediaKey) {
+    if (mediaKey === "source") {
+        return "source.zip";
+    }
     if (mediaKey === "icon")
         return "listing/icon.png";
     if (mediaKey === "heroPortrait")
@@ -142,8 +147,8 @@ function buildPackKey(creatorUsername, name, version) {
 }
 function getTaskCreatorResult(task, defaultCreator, currentUserRole) {
     const requestedTaskOwner = "username" in task && typeof task.username === "string" ? String(task.username).trim() : "";
-    const creatorTargetError = requestedTaskOwner && currentUserRole !== "ADMIN"
-        ? `Task "${task.name}" sets username="${requestedTaskOwner}", but only admins can target another creator.`
+    const creatorTargetError = requestedTaskOwner && currentUserRole !== "ADMIN" && currentUserRole !== "CLOUD_WORKER"
+        ? `Task "${task.name}" sets username="${requestedTaskOwner}", but this account cannot target another creator.`
         : null;
     return {
         requestedTaskOwner,
@@ -232,9 +237,6 @@ function resolveAssetFormat(task) {
         const primaryFile = task.filePaths.primary;
         if (typeof primaryFile === "string") {
             const normalizedPrimary = primaryFile.trim().toLowerCase();
-            if (normalizedPrimary.endsWith(".boxel.json")) {
-                return "PLAYDROP_BOXEL_JSON";
-            }
             if (normalizedPrimary.endsWith(".vox")) {
                 return "VOX";
             }
@@ -246,10 +248,6 @@ function resolveAssetFormat(task) {
                 return "GLTF";
             }
         }
-        const boxelFile = task.filePaths.boxel;
-        if (typeof boxelFile === "string" && boxelFile.trim().toLowerCase().endsWith(".boxel.json")) {
-            return "PLAYDROP_BOXEL_JSON";
-        }
         const meshFile = task.filePaths.mesh;
         if (typeof meshFile === "string") {
             const meshExtension = (0, node_path_1.extname)(meshFile).toLowerCase();
@@ -286,7 +284,10 @@ function validateAssetSubcategoryCompatibility(task, format) {
     if (!definition.formats.includes(format)) {
         throw new Error(`Asset "${task.name}" uses format "${format}" not allowed for subcategory "${subcategory}".`);
     }
-    (0, model_artifacts_1.assertGeneratedModel3DAssetRoles)(task, format);
+    const missingRoles = (0, types_1.getRequiredModel3DFileRoles)(format).filter((role) => !task.filePaths[role]);
+    if (missingRoles.length > 0) {
+        throw new Error(`Asset "${task.name}" is missing required files.${missingRoles.join(" and files.")}.`);
+    }
     return subcategory;
 }
 async function prepareAssetTaskUploadData(task) {
@@ -311,7 +312,6 @@ async function prepareAssetTaskUploadData(task) {
     }
     const format = resolveAssetFormat(task);
     const subcategory = validateAssetSubcategoryCompatibility(task, format);
-    await (0, model_artifacts_1.prepareModel3DAssetArtifacts)(task);
     const uploadFiles = Object.entries(task.filePaths)
         .sort(([leftRole], [rightRole]) => leftRole.localeCompare(rightRole))
         .map(([role, filePath]) => prepareUploadFile(filePath, role));
@@ -548,6 +548,9 @@ async function buildPackMembersAndExistingAssets(client, task, mutationCreatorUs
 }
 function buildPackListingUploads(task) {
     const listingUploads = [];
+    if (task.sourcePath) {
+        listingUploads.push(prepareListingMediaUpload("source", task.sourcePath, "application/zip"));
+    }
     if (task.listing?.iconPath) {
         listingUploads.push(prepareListingMediaUpload("icon", task.listing.iconPath, "image/png"));
     }
@@ -609,6 +612,7 @@ function buildPackInitializeRequest(task, ownedAssets, existingAssets, members,
         ownedAssets,
         existingAssets,
         members,
+        source: listingUploads.find((entry) => entry.mediaKey === "source")?.entry,
         listing: buildPackListingPayload(listingUploads),
     };
 }