@playdrop/playdrop-cli 0.12.2 → 0.12.4

package/dist/commands/devShared.js

@@ -4,6 +4,7 @@ exports.createDevError = createDevError;
 exports.isNetworkError = isNetworkError;
 exports.fetchDevUser = fetchDevUser;
 exports.fetchDevUsername = fetchDevUsername;
+exports.resolveDevCreatorUsername = resolveDevCreatorUsername;
 exports.assertAppRegistered = assertAppRegistered;
 exports.resolveDevTarget = resolveDevTarget;
 exports.findProjectInfo = findProjectInfo;
@@ -54,6 +55,14 @@ async function fetchDevUsername(client) {
     const user = await fetchDevUser(client);
     return user.username;
 }
+async function resolveDevCreatorUsername(input) {
+    const workspaceOwnerUsername = input.workspaceOwnerUsername?.trim() ?? '';
+    if (workspaceOwnerUsername) {
+        return workspaceOwnerUsername;
+    }
+    const accountUsername = input.accountUsername?.trim() ?? '';
+    return accountUsername || await fetchDevUsername(input.client);
+}
 async function assertAppRegistered(client, creatorUsername, appName) {
     const response = await client.fetchAppBySlug(creatorUsername, appName);
     if (!response?.app) {

package/dist/commands/login.d.ts

@@ -1,3 +1,4 @@
+import type { Readable } from 'stream';
 import { resetOpenBrowserForTests, setOpenBrowserForTests } from '../browser';
 export { resetOpenBrowserForTests, setOpenBrowserForTests, };
 type LoginOptions = {
@@ -5,6 +6,17 @@ type LoginOptions = {
     password?: string;
     key?: string;
     handoffToken?: string;
+    handoffTokenStdin?: boolean;
     json?: boolean;
 };
-export declare function login(env: string, options?: LoginOptions): Promise<void>;
+type LoginRuntime = {
+    stdin?: Readable;
+};
+export declare const HANDOFF_TOKEN_STDIN_MAX_BYTES: number;
+type HandoffTokenStdinErrorCode = 'empty' | 'too_large' | 'read_failed';
+export declare class HandoffTokenStdinError extends Error {
+    readonly code: HandoffTokenStdinErrorCode;
+    constructor(code: HandoffTokenStdinErrorCode);
+}
+export declare function readHandoffTokenFromStdin(input?: Readable): Promise<string>;
+export declare function login(env: string, options?: LoginOptions, runtime?: LoginRuntime): Promise<void>;

package/dist/commands/login.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setOpenBrowserForTests = exports.resetOpenBrowserForTests = void 0;
+exports.HandoffTokenStdinError = exports.HANDOFF_TOKEN_STDIN_MAX_BYTES = exports.setOpenBrowserForTests = exports.resetOpenBrowserForTests = void 0;
+exports.readHandoffTokenFromStdin = readHandoffTokenFromStdin;
 exports.login = login;
 const types_1 = require("@playdrop/types");
 const config_1 = require("../config");
@@ -12,6 +13,40 @@ Object.defineProperty(exports, "resetOpenBrowserForTests", { enumerable: true, g
 Object.defineProperty(exports, "setOpenBrowserForTests", { enumerable: true, get: function () { return browser_1.setOpenBrowserForTests; } });
 const output_1 = require("../output");
 const messages_1 = require("../messages");
+exports.HANDOFF_TOKEN_STDIN_MAX_BYTES = 8 * 1024;
+class HandoffTokenStdinError extends Error {
+    constructor(code) {
+        super(`handoff_token_stdin_${code}`);
+        this.name = 'HandoffTokenStdinError';
+        this.code = code;
+    }
+}
+exports.HandoffTokenStdinError = HandoffTokenStdinError;
+async function readHandoffTokenFromStdin(input = process.stdin) {
+    const chunks = [];
+    let byteCount = 0;
+    try {
+        for await (const chunk of input) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+            byteCount += buffer.byteLength;
+            if (byteCount > exports.HANDOFF_TOKEN_STDIN_MAX_BYTES) {
+                throw new HandoffTokenStdinError('too_large');
+            }
+            chunks.push(buffer);
+        }
+    }
+    catch (error) {
+        if (error instanceof HandoffTokenStdinError) {
+            throw error;
+        }
+        throw new HandoffTokenStdinError('read_failed');
+    }
+    const token = Buffer.concat(chunks, byteCount).toString('utf8').trim();
+    if (!token) {
+        throw new HandoffTokenStdinError('empty');
+    }
+    return token;
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -193,7 +228,7 @@ async function loginInBrowser(env, baseUrl, options = {}) {
     ], { command: 'login' });
     process.exitCode = 1;
 }
-async function login(env, options = {}) {
+async function login(env, options = {}, runtime = {}) {
     const envConfig = (0, environment_1.resolveEnvironmentConfig)(env);
     if (!envConfig) {
         const choices = (0, environment_1.formatEnvironmentList)();
@@ -207,12 +242,16 @@ async function login(env, options = {}) {
     const username = options.username?.trim();
     const password = options.password;
     const apiKey = options.key?.trim();
-    const handoffToken = options.handoffToken?.trim();
+    const argvHandoffToken = options.handoffToken?.trim();
+    const hasApiKeyArgument = options.key !== undefined;
+    const hasHandoffTokenArgument = options.handoffToken !== undefined;
+    const readsHandoffTokenFromStdin = options.handoffTokenStdin === true;
     const hasDirectCredentials = Boolean(username || password);
     const explicitLoginMethods = [
-        apiKey ? 'key' : null,
+        hasApiKeyArgument ? 'key' : null,
         hasDirectCredentials ? 'credentials' : null,
-        handoffToken ? 'handoff' : null,
+        hasHandoffTokenArgument ? 'handoff' : null,
+        readsHandoffTokenFromStdin ? 'handoff-stdin' : null,
     ].filter(Boolean);
     if (explicitLoginMethods.length > 1) {
         (0, messages_1.printErrorWithHelp)('Choose exactly one login method.', [
@@ -220,6 +259,7 @@ async function login(env, options = {}) {
             'Use "--username" with "--password" for direct login.',
             'Use "--key" by itself for API key login.',
             'Use "--handoff-token" by itself for native app handoff login.',
+            'Use "--handoff-token-stdin" by itself to read a native app handoff token from stdin.',
         ], { command: 'login' });
         process.exitCode = 1;
         return;
@@ -232,6 +272,33 @@ async function login(env, options = {}) {
         process.exitCode = 1;
         return;
     }
+    if (hasApiKeyArgument && !apiKey) {
+        (0, messages_1.printErrorWithHelp)('The API key cannot be empty.', ['Provide a non-empty value to "--key".'], { command: 'login' });
+        process.exitCode = 1;
+        return;
+    }
+    if (hasHandoffTokenArgument && !argvHandoffToken) {
+        (0, messages_1.printErrorWithHelp)('The native app handoff token cannot be empty.', ['Request a fresh handoff token from the PlayDrop app and retry.'], { command: 'login' });
+        process.exitCode = 1;
+        return;
+    }
+    let handoffToken = argvHandoffToken;
+    if (readsHandoffTokenFromStdin) {
+        try {
+            handoffToken = await readHandoffTokenFromStdin(runtime.stdin ?? process.stdin);
+        }
+        catch (error) {
+            const inputError = error instanceof HandoffTokenStdinError ? error : null;
+            const message = inputError?.code === 'too_large'
+                ? `Native app handoff input exceeded the ${exports.HANDOFF_TOKEN_STDIN_MAX_BYTES}-byte limit.`
+                : inputError?.code === 'empty'
+                    ? 'Native app handoff input was empty.'
+                    : 'Could not read native app handoff input from stdin.';
+            (0, messages_1.printErrorWithHelp)(message, ['Request a fresh handoff token from the PlayDrop app and retry.'], { command: 'login' });
+            process.exitCode = 1;
+            return;
+        }
+    }
     try {
         if (apiKey) {
             await loginWithKey(env, envConfig.apiBase, apiKey, { json: options.json });

package/dist/commands/taskCaptureSession.d.ts

@@ -0,0 +1,4 @@
+import type { AppResponse } from '@playdrop/types';
+import type { TaskCaptureSession } from '../appUrls';
+import type { ResolvedWorkspaceAuthConfig } from '../workspaceAuth';
+export declare function resolveTaskCaptureSession(workspaceAuth: ResolvedWorkspaceAuthConfig | null, app: AppResponse): TaskCaptureSession | null;

package/dist/commands/taskCaptureSession.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTaskCaptureSession = resolveTaskCaptureSession;
+function resolveTaskCaptureSession(workspaceAuth, app) {
+    const taskId = workspaceAuth?.config.taskId;
+    const taskToken = workspaceAuth?.config.taskToken?.trim() ?? '';
+    if (taskId === undefined && !taskToken) {
+        return null;
+    }
+    if (!Number.isInteger(taskId) || Number(taskId) <= 0 || !taskToken) {
+        throw new Error('worker_capture_session_incomplete');
+    }
+    if (!Number.isInteger(app.id) || Number(app.id) <= 0) {
+        throw new Error('registered_app_id_missing');
+    }
+    return {
+        appId: Number(app.id),
+        taskId: Number(taskId),
+        taskToken,
+    };
+}

package/dist/commands/upload.d.ts

@@ -9,6 +9,7 @@ export declare function upload(pathOrName: string, options?: UploadCommandOption
 export type WorkerAppPublishInput = {
     client: ApiClient;
     taskId: number;
+    taskToken: string;
     kind: 'NEW_GAME' | 'REMIX_GAME' | 'GAME_UPDATE';
     executionTarget?: AgentExecutionTarget;
     expectedAppName?: string | null;

package/dist/commands/upload.js

@@ -1225,6 +1225,11 @@ const WORKER_SUPERVISOR_SOURCE_EXCLUDES = [
     '.playdrop-task-events/',
     'bin/playdrop',
 ];
+const WORKER_SUPERVISOR_BUNDLE_EXCLUDES = [
+    ...WORKER_SUPERVISOR_SOURCE_EXCLUDES,
+    'assets/marketing/',
+    'listing/',
+];
 const MIN_HERO_PORTRAIT_WIDTH = 512;
 const MIN_HERO_PORTRAIT_HEIGHT = 768;
 const MIN_HERO_LANDSCAPE_WIDTH = 768;
@@ -2273,7 +2278,7 @@ async function publishWorkerAppProject(input) {
         ...appTask,
         versionVisibility: 'PRIVATE',
         sourceArchiveExcludeRelativeFiles: WORKER_SUPERVISOR_SOURCE_EXCLUDES,
-        bundleArchiveExcludeRelativeFiles: WORKER_SUPERVISOR_SOURCE_EXCLUDES,
+        bundleArchiveExcludeRelativeFiles: WORKER_SUPERVISOR_BUNDLE_EXCLUDES,
     };
     if (input.kind === 'REMIX_GAME') {
         const expectedRemixRef = input.remixSourceRef?.trim() ?? '';
@@ -2331,6 +2336,15 @@ async function publishWorkerAppProject(input) {
     if (typeof app.id !== 'number' || !Number.isInteger(app.id) || app.id <= 0) {
         throw new Error(`App "${task.name}" registration did not return an app id.`);
     }
+    const taskToken = input.taskToken.trim();
+    if (!taskToken) {
+        throw new Error('agent_task_token_missing');
+    }
+    const captureSession = {
+        appId: app.id,
+        taskId: input.taskId,
+        taskToken,
+    };
     if (input.kind === 'NEW_GAME' || input.kind === 'REMIX_GAME') {
         assertNewGameListingScreenshots(task);
         assertTaskPlaytestEvidenceManifest(task);
@@ -2346,6 +2360,7 @@ async function publishWorkerAppProject(input) {
         ensureRegisteredAppShell: true,
         agentTaskId: input.taskId,
         mediaCaptureRequired: input.executionTarget === 'FIRST_PARTY',
+        captureSession,
     });
     if (!uploadResult.versionCreated || !uploadResult.version) {
         throw new Error(`App "${task.name}" upload did not return a created version.`);

package/dist/commands/worker.d.ts

@@ -187,11 +187,13 @@ export declare function classifyWorkerHeartbeatError(error: unknown): 'session_e
 export declare function assertWorkerClaimErrorRetryable(error: unknown): void;
 export declare function resolvePlaydropAssetRequirementFromText(value: unknown): WorkerPlaydropAssetRequirement | null;
 export declare function loadWorkerEnvFile(envName: string | undefined, cwd?: string): string | null;
-export declare function buildWorkerCapabilities(input: string | {
+export declare function buildWorkerCapabilities(input: {
     codexVersion?: string | null;
     codexAuthenticated?: boolean | null;
+    codexModels?: string[] | null;
     claudeVersion?: string | null;
     claudeAuthenticated?: boolean | null;
+    claudeModels?: string[] | null;
     cursorVersion?: string | null;
     cursorAuthenticated?: boolean | null;
     npmVersion?: string | null;
@@ -233,6 +235,8 @@ export declare function createLocalPlaydropShim(input: {
     attempt: number;
     devPort: number;
 }): Promise<string>;
+export declare function parseCodexModelCatalog(output: string): string[];
+export declare function parseClaudeModelCatalog(output: string): string[];
 export declare function buildWorkerSetupActions(input: {
     degradedReasons: string[];
     playwright?: {