@playdrop/playdrop-cli 0.10.0 → 0.10.2

package/config/client-meta.json

@@ -1,6 +1,7 @@
 {
-  "version": "0.10.0",
+  "version": "0.10.2",
   "build": 1,
+  "runtimeSdkVersion": "0.10.0",
   "clients": {
     "all": {
       "minimumVersion": "0.7.4"

package/dist/apiClient.d.ts

@@ -5,7 +5,15 @@ type ClientOptions = {
     token?: string | null;
     onBehalfCreatorUsername?: string | null;
     agentTaskToken?: string | null;
+    agentTaskId?: number | null;
+    agentTaskAttempt?: number | null;
 };
+export declare function createCliClientHeaders(input: {
+    onBehalfCreatorUsername?: string | null;
+    agentTaskToken?: string | null;
+    agentTaskId?: number | null;
+    agentTaskAttempt?: number | null;
+}): Record<string, string>;
 export declare function createCliApiClient(options: ClientOptions): ApiClient;
 export declare function createCliAiClient(options: ClientOptions): AiClient;
 export {};

package/dist/apiClient.js

@@ -1,10 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliClientHeaders = createCliClientHeaders;
 exports.createCliApiClient = createCliApiClient;
 exports.createCliAiClient = createCliAiClient;
 const api_client_1 = require("@playdrop/api-client");
 const ai_client_1 = require("@playdrop/ai-client");
 const clientInfo_1 = require("./clientInfo");
+function readPositiveIntEnv(name) {
+    const raw = process.env[name]?.trim();
+    if (!raw) {
+        return null;
+    }
+    const parsed = Number(raw);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
 function createCliClientHeaders(input) {
     const onBehalfCreatorUsername = input.onBehalfCreatorUsername;
     const creatorUsername = typeof onBehalfCreatorUsername === 'string'
@@ -13,6 +22,15 @@ function createCliClientHeaders(input) {
     const agentTaskToken = typeof input.agentTaskToken === 'string'
         ? input.agentTaskToken.trim()
         : '';
+    const agentTaskId = Number.isInteger(input.agentTaskId) && Number(input.agentTaskId) > 0
+        ? Number(input.agentTaskId)
+        : readPositiveIntEnv('PLAYDROP_WORKER_TASK_ID');
+    const agentTaskAttempt = Number.isInteger(input.agentTaskAttempt) && Number(input.agentTaskAttempt) > 0
+        ? Number(input.agentTaskAttempt)
+        : readPositiveIntEnv('PLAYDROP_WORKER_TASK_ATTEMPT');
+    if (agentTaskToken && process.env.PLAYDROP_WORKER_CONTEXT === '1' && (!agentTaskId || !agentTaskAttempt)) {
+        throw new Error('worker_ai_generation_task_context_missing');
+    }
     return {
         ...(0, clientInfo_1.createClientHeaders)(),
         ...(creatorUsername
@@ -21,7 +39,13 @@ function createCliClientHeaders(input) {
                 'x-playdrop-ai-paid-by': 'creator',
             }
             : {}),
-        ...(agentTaskToken ? { 'x-playdrop-agent-task-token': agentTaskToken } : {}),
+        ...(agentTaskToken
+            ? {
+                'x-playdrop-agent-task-token': agentTaskToken,
+                ...(agentTaskId ? { 'x-playdrop-agent-task-id': String(agentTaskId) } : {}),
+                ...(agentTaskAttempt ? { 'x-playdrop-agent-task-attempt': String(agentTaskAttempt) } : {}),
+            }
+            : {}),
     };
 }
 function createCliApiClient(options) {
@@ -30,6 +54,8 @@ function createCliApiClient(options) {
         clientHeaders: () => createCliClientHeaders({
             onBehalfCreatorUsername: options.onBehalfCreatorUsername,
             agentTaskToken: options.agentTaskToken,
+            agentTaskId: options.agentTaskId,
+            agentTaskAttempt: options.agentTaskAttempt,
         }),
         tokenProvider: () => options.token ?? null,
     });
@@ -40,6 +66,8 @@ function createCliAiClient(options) {
         clientHeaders: () => createCliClientHeaders({
             onBehalfCreatorUsername: options.onBehalfCreatorUsername,
             agentTaskToken: options.agentTaskToken,
+            agentTaskId: options.agentTaskId,
+            agentTaskAttempt: options.agentTaskAttempt,
         }),
         tokenProvider: () => options.token ?? null,
     });

package/dist/captureRuntime.d.ts

@@ -24,8 +24,21 @@ export type RunCaptureOptions = {
     enableCaptureBridge?: boolean;
     requireHostedLaunchReady?: boolean;
     expectedHostedLaunchState?: HostedLaunchExpectedState;
+    actions?: CaptureAction[];
 };
 export type HostedLaunchExpectedState = 'ready' | 'login_required' | 'controller_required' | 'surface_unsupported';
+export type CaptureAction = {
+    type: 'click';
+    x: number;
+    y: number;
+    button?: 'left' | 'right' | 'middle';
+} | {
+    type: 'press';
+    key: string;
+} | {
+    type: 'wait';
+    ms: number;
+};
 export type CaptureHostedLaunchState = {
     state: 'ready';
 } | {

package/dist/captureRuntime.js

@@ -506,6 +506,26 @@ async function summarizeCanvasScreenshots(page, frames, summaries) {
     }
     return screenshotSummaries;
 }
+async function runCaptureActions(page, actions) {
+    if (!actions?.length) {
+        return;
+    }
+    for (const action of actions) {
+        if (action.type === 'click') {
+            await page.mouse.click(action.x, action.y, { button: action.button ?? 'left' });
+            continue;
+        }
+        if (action.type === 'press') {
+            await page.keyboard.press(action.key);
+            continue;
+        }
+        if (action.type === 'wait') {
+            await page.waitForTimeout(action.ms);
+            continue;
+        }
+        throw new Error('capture_action_type_unknown');
+    }
+}
 async function assertHostedFrameVisualReadiness(page) {
     const childFrames = page.frames().filter(frame => frame.parentFrame() !== null);
     if (childFrames.length === 0) {
@@ -922,6 +942,7 @@ async function runCapture(options) {
                 }
             }
             finalUrl = await assertPageState();
+            await runCaptureActions(page, options.actions);
             await page.waitForTimeout(options.settleAfterReadyMs ?? options.timeoutMs);
             finalUrl = await assertPageState();
             if (shouldAssertHostedVisualReadiness({

package/dist/commandContext.js

@@ -40,8 +40,24 @@ function buildContext(cfg, envConfig, account, workspaceAuth = null) {
     const token = account?.token ?? cfg.token ?? '';
     const onBehalfCreatorUsername = workspaceAuth?.config.ownerUsername ?? null;
     const agentTaskToken = workspaceAuth?.config.taskToken ?? null;
-    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token, onBehalfCreatorUsername, agentTaskToken });
-    const aiClient = (0, apiClient_1.createCliAiClient)({ baseUrl: envConfig.aiBase, token, onBehalfCreatorUsername, agentTaskToken });
+    const agentTaskId = workspaceAuth?.config.taskId ?? null;
+    const agentTaskAttempt = workspaceAuth?.config.taskAttempt ?? null;
+    const client = (0, apiClient_1.createCliApiClient)({
+        baseUrl: envConfig.apiBase,
+        token,
+        onBehalfCreatorUsername,
+        agentTaskToken,
+        agentTaskId,
+        agentTaskAttempt,
+    });
+    const aiClient = (0, apiClient_1.createCliAiClient)({
+        baseUrl: envConfig.aiBase,
+        token,
+        onBehalfCreatorUsername,
+        agentTaskToken,
+        agentTaskId,
+        agentTaskAttempt,
+    });
     return {
         client,
         aiClient,
@@ -92,8 +108,10 @@ async function migrateLegacyConfigIfNeeded(cfg, envConfig, command) {
 async function loadWorkspaceAwareConfig(command, options) {
     let cfg = (0, config_1.loadConfig)();
     let workspaceAuth = null;
+    const workspacePath = options.workspacePath
+        ?? (process.env.PLAYDROP_WORKER_CONTEXT === '1' ? process.cwd() : undefined);
     try {
-        workspaceAuth = options.workspacePath ? (0, workspaceAuth_1.findWorkspaceAuthConfig)(options.workspacePath) : null;
+        workspaceAuth = workspacePath ? (0, workspaceAuth_1.findWorkspaceAuthConfig)(workspacePath) : null;
     }
     catch (error) {
         if (error instanceof workspaceAuth_1.WorkspaceAuthConfigError) {

package/dist/commands/captureRemote.d.ts

@@ -6,6 +6,8 @@ type CaptureRemoteOptions = {
     username?: string;
     password?: string;
     loginUrl?: string;
+    actions?: string;
+    viewport?: string;
 };
 export declare function buildCaptureRemoteCommandArgs(url: string | undefined, options?: CaptureRemoteOptions): string[] | null;
 export declare function captureRemote(url: string | undefined, options?: CaptureRemoteOptions): Promise<void>;

package/dist/commands/captureRemote.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildCaptureRemoteCommandArgs = buildCaptureRemoteCommandArgs;
 exports.captureRemote = captureRemote;
+const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const types_1 = require("@playdrop/types");
 const commandContext_1 = require("../commandContext");
@@ -42,6 +43,75 @@ function parseTimeout(raw) {
     }
     return parsed;
 }
+function parseViewport(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return null;
+    }
+    const match = /^(\d{2,5})x(\d{2,5})$/i.exec(value);
+    if (!match) {
+        throw new Error('invalid_viewport');
+    }
+    const width = Number.parseInt(match[1], 10);
+    const height = Number.parseInt(match[2], 10);
+    if (width < 320 || width > 4096 || height < 320 || height > 4096) {
+        throw new Error('invalid_viewport');
+    }
+    return { width, height };
+}
+function normalizeCaptureAction(raw, index) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(`invalid_action:${index}`);
+    }
+    const action = raw;
+    const type = typeof action.type === 'string' ? action.type.trim() : '';
+    if (type === 'click') {
+        const x = typeof action.x === 'number' ? action.x : Number.NaN;
+        const y = typeof action.y === 'number' ? action.y : Number.NaN;
+        const button = typeof action.button === 'string' ? action.button.trim() : undefined;
+        if (!Number.isFinite(x) || !Number.isFinite(y) || x < 0 || y < 0) {
+            throw new Error(`invalid_action:${index}:click_coordinates`);
+        }
+        if (button !== undefined && button !== 'left' && button !== 'right' && button !== 'middle') {
+            throw new Error(`invalid_action:${index}:click_button`);
+        }
+        return button ? { type: 'click', x, y, button } : { type: 'click', x, y };
+    }
+    if (type === 'press') {
+        const key = typeof action.key === 'string' ? action.key.trim() : '';
+        if (!key) {
+            throw new Error(`invalid_action:${index}:press_key`);
+        }
+        return { type: 'press', key };
+    }
+    if (type === 'wait') {
+        const ms = typeof action.ms === 'number' ? action.ms : Number.NaN;
+        if (!Number.isInteger(ms) || ms < 0 || ms > 60000) {
+            throw new Error(`invalid_action:${index}:wait_ms`);
+        }
+        return { type: 'wait', ms };
+    }
+    throw new Error(`invalid_action:${index}:type`);
+}
+async function readCaptureActions(actionsPath) {
+    if (!actionsPath) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await (0, promises_1.readFile)(actionsPath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`invalid_actions_file:${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new Error('invalid_actions_file:expected_array');
+    }
+    if (parsed.length > 100) {
+        throw new Error('invalid_actions_file:too_many_actions');
+    }
+    return parsed.map((entry, index) => normalizeCaptureAction(entry, index));
+}
 function assertValidUrl(value, errorCode) {
     try {
         new URL(value);
@@ -77,6 +147,8 @@ function buildCaptureRemoteCommandArgs(url, options = {}) {
     pushOptionalArg(args, '--screenshot', options.screenshot);
     pushOptionalArg(args, '--log', options.log);
     pushOptionalArg(args, '--expected-url', options.expectedUrl);
+    pushOptionalArg(args, '--actions', options.actions);
+    pushOptionalArg(args, '--viewport', options.viewport);
     if (username) {
         args.push('--username', username, '--password', password);
     }
@@ -104,6 +176,8 @@ function parseOptions(url, options = {}) {
         timeoutSeconds: parseTimeout(options.timeout),
         screenshotPath: (0, node_path_1.resolve)(process.cwd(), options.screenshot?.trim() || 'output/playwright/capture-url.png'),
         logPath: options.log?.trim() ? (0, node_path_1.resolve)(process.cwd(), options.log.trim()) : null,
+        actionsPath: options.actions?.trim() ? (0, node_path_1.resolve)(process.cwd(), options.actions.trim()) : null,
+        viewport: parseViewport(options.viewport),
         login: username
             ? {
                 username,
@@ -135,6 +209,11 @@ async function captureRemote(url, options = {}) {
             process.exitCode = 1;
             return;
         }
+        if (error instanceof Error && error.message === 'invalid_viewport') {
+            (0, messages_1.printErrorWithHelp)('The --viewport value must be WIDTHxHEIGHT with each side between 320 and 4096 pixels.', [], { command: 'project capture remote' });
+            process.exitCode = 1;
+            return;
+        }
         if (error instanceof Error && error.message === 'invalid_credentials_pair') {
             (0, messages_1.printErrorWithHelp)('Use --username and --password together.', [], { command: 'project capture remote' });
             process.exitCode = 1;
@@ -149,6 +228,15 @@ async function captureRemote(url, options = {}) {
         process.exitCode = 1;
         return;
     }
+    let actions = null;
+    try {
+        actions = await readCaptureActions(parsed.actionsPath);
+    }
+    catch (error) {
+        (0, messages_1.printErrorWithHelp)(error instanceof Error ? error.message : String(error), [], { command: 'project capture remote' });
+        process.exitCode = 1;
+        return;
+    }
     await (0, commandContext_1.withEnvironment)('project capture remote', 'Capturing remote app logs', async ({ client, token }) => {
         let currentUser = null;
         try {
@@ -190,6 +278,8 @@ async function captureRemote(url, options = {}) {
                 token: parsed.login ? undefined : token,
                 user: parsed.login ? undefined : currentUser,
                 login: parsed.login,
+                actions: actions ?? undefined,
+                contextOptions: parsed.viewport ? { viewport: parsed.viewport } : undefined,
             });
             if (result.errorCount > 0) {
                 console.error(`[capture] Completed with ${result.errorCount} error(s) after ${parsed.timeoutSeconds} seconds.`);

package/dist/commands/review.d.ts

@@ -0,0 +1,46 @@
+export declare const REVIEW_CRITERIA: readonly ["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"];
+export declare const REQUIRED_REVIEW_EVIDENCE_FILES: string[];
+export type ValidateGameReviewResultInput = {
+    creatorFeedback?: string;
+    evidenceDir: string;
+    reviewMessage: string;
+    reviewState: string;
+};
+export type ReviewValidationResult = {
+    average?: number;
+    evidenceDir?: string;
+    outcome?: string;
+    primarySurface?: string;
+    reason?: string;
+    scoreCount?: number;
+    skipped: boolean;
+};
+export type ReviewValidateResultOptions = {
+    creatorFeedbackFile?: string;
+    evidenceDir: string;
+    messageFile: string;
+    state: string;
+};
+export type ReviewComposeEvidenceOptions = {
+    core?: string;
+    win?: string;
+    loss?: string;
+    out: string;
+};
+export type ReviewRatingCardOptions = {
+    reviewMessageFile: string;
+    out: string;
+    punchline?: string;
+    title?: string;
+};
+export declare function validateGameReviewResult(input: ValidateGameReviewResultInput): Promise<ReviewValidationResult>;
+export declare function validateReviewResultCommand(options: ReviewValidateResultOptions): Promise<void>;
+export declare function composeReviewEvidence(options: ReviewComposeEvidenceOptions): Promise<{
+    outputPath: string;
+    imageCount: number;
+}>;
+export declare function createReviewRatingCard(options: ReviewRatingCardOptions): Promise<{
+    outputPath: string;
+    width: number;
+    height: number;
+}>;