@playdrop/playdrop-cli 0.11.9 → 0.12.0

package/dist/commands/validate.js

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = validate;
 const types_1 = require("@playdrop/types");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const apps_1 = require("../apps");
 const assetSpecs_1 = require("../assetSpecs");
 const commandContext_1 = require("../commandContext");
@@ -11,96 +9,7 @@ const externalAssetPackValidation_1 = require("../externalAssetPackValidation");
 const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
-const dev_1 = require("./dev");
 const upload_content_1 = require("./upload-content");
-function normalizePositivePort(value) {
-    const parsed = typeof value === 'number' ? value : Number.parseInt(String(value ?? ''), 10);
-    return Number.isInteger(parsed) && parsed > 0 && parsed <= 65535 ? parsed : null;
-}
-function findWorkspaceMetadataFile(startPath) {
-    let current = (0, node_path_1.resolve)(startPath);
-    if ((0, node_fs_1.existsSync)(current) && (0, node_fs_1.statSync)(current).isFile()) {
-        current = (0, node_path_1.dirname)(current);
-    }
-    while (true) {
-        const workspacePinPath = (0, node_path_1.join)(current, '.playdrop.json');
-        if ((0, node_fs_1.existsSync)(workspacePinPath) && (0, node_fs_1.statSync)(workspacePinPath).isFile()) {
-            return workspacePinPath;
-        }
-        const taskContextPath = (0, node_path_1.join)(current, '.playdrop', 'task.json');
-        if ((0, node_fs_1.existsSync)(taskContextPath) && (0, node_fs_1.statSync)(taskContextPath).isFile()) {
-            return taskContextPath;
-        }
-        const parent = (0, node_path_1.dirname)(current);
-        if (parent === current) {
-            return null;
-        }
-        current = parent;
-    }
-}
-function readTaskScopedDevRouterPort(workspacePath) {
-    const metadataPath = findWorkspaceMetadataFile(workspacePath);
-    if (!metadataPath) {
-        throw new Error('project_validate_task_dev_port_missing');
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse((0, node_fs_1.readFileSync)(metadataPath, 'utf8'));
-    }
-    catch {
-        throw new Error(`project_validate_task_dev_port_invalid_json:${metadataPath}`);
-    }
-    const port = normalizePositivePort(parsed?.devPort);
-    if (!port) {
-        throw new Error(`project_validate_task_dev_port_missing:${metadataPath}`);
-    }
-    return { file: metadataPath, port };
-}
-function readWorkerTaskDevRouterPort() {
-    if (process.env.PLAYDROP_WORKER_CONTEXT !== '1') {
-        return null;
-    }
-    const workerPortRaw = process.env.PLAYDROP_WORKER_TASK_DEV_PORT;
-    if (!workerPortRaw?.trim()) {
-        throw new Error('project_validate_worker_dev_port_missing');
-    }
-    const workerPort = normalizePositivePort(workerPortRaw);
-    if (!workerPort) {
-        throw new Error(`project_validate_worker_dev_port_invalid:${workerPortRaw}`);
-    }
-    const devRouterPortRaw = process.env.PLAYDROP_DEV_ROUTER_PORT;
-    if (devRouterPortRaw?.trim()) {
-        const devRouterPort = normalizePositivePort(devRouterPortRaw);
-        if (!devRouterPort) {
-            throw new Error(`project_validate_env_dev_port_invalid:${devRouterPortRaw}`);
-        }
-        if (devRouterPort !== workerPort) {
-            throw new Error(`project_validate_worker_dev_port_mismatch:env=${devRouterPort}:worker=${workerPort}`);
-        }
-    }
-    return workerPort;
-}
-function resolveValidationDevRouterPort(workspacePath, taskScoped) {
-    if (!taskScoped) {
-        return (0, dev_1.resolveCliDevRouterPort)();
-    }
-    const workerPort = readWorkerTaskDevRouterPort();
-    if (workerPort !== null) {
-        return workerPort;
-    }
-    const taskPort = readTaskScopedDevRouterPort(workspacePath);
-    const envPortRaw = process.env.PLAYDROP_DEV_ROUTER_PORT;
-    if (envPortRaw !== undefined && envPortRaw.trim()) {
-        const envPort = normalizePositivePort(envPortRaw);
-        if (!envPort) {
-            throw new Error(`project_validate_env_dev_port_invalid:${envPortRaw}`);
-        }
-        if (envPort !== taskPort.port) {
-            throw new Error(`project_validate_worker_dev_port_mismatch:env=${envPort}:task=${taskPort.port}:${taskPort.file}`);
-        }
-    }
-    return taskPort.port;
-}
 function buildLocalAssetSpecLookups(tasks) {
     const exactByRef = new Map();
     const uniqueByNameVersion = new Map();
@@ -172,42 +81,6 @@ async function loadAuthenticatedValidationContext(workspacePath, envOverride) {
         return null;
     }
 }
-async function loadHostedLaunchValidationContext(workspacePath, envOverride) {
-    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)('project validate', 'run hosted app launch validation', {
-        env: envOverride,
-        workspacePath,
-    });
-    if (!ctx) {
-        return null;
-    }
-    const username = typeof ctx.account?.username === 'string' ? ctx.account.username.trim() : '';
-    if (!username) {
-        process.exitCode = 1;
-        return null;
-    }
-    let currentUserRole = null;
-    let currentUser = null;
-    try {
-        const me = await ctx.client.me();
-        currentUserRole = me.user.role ?? null;
-        currentUser = me.user ?? null;
-    }
-    catch {
-        currentUserRole = null;
-        currentUser = null;
-    }
-    return {
-        client: ctx.client,
-        currentUserRole,
-        currentUser,
-        username,
-        apiBase: ctx.envConfig.apiBase,
-        webBase: ctx.envConfig.webBase ?? null,
-        token: ctx.token,
-        devRouterPort: resolveValidationDevRouterPort(workspacePath, Boolean(ctx.workspaceAuth?.config.taskToken)),
-        taskScoped: Boolean(ctx.workspaceAuth?.config.taskToken),
-    };
-}
 function printResolvedValidationAccount(ctx) {
     const username = typeof ctx.account?.username === 'string' && ctx.account.username.trim().length > 0
         ? ctx.account.username.trim()
@@ -314,40 +187,12 @@ async function validate(pathOrName, options = {}) {
     const assetSpecTasks = tasks.filter((task) => task.kind === 'asset-spec');
     const assetSpecLookups = buildLocalAssetSpecLookups(assetSpecTasks);
     const sortedTasks = (0, taskUtils_1.sortTasks)(tasks);
-    const hostedLaunchValidationRequired = sortedTasks.some((task) => task.kind === 'app' && task.hostingMode !== 'EXTERNAL' && !task.externalUrl);
-    const hostedLaunchValidationContext = hostedLaunchValidationRequired
-        ? await loadHostedLaunchValidationContext(workspacePath, options.env)
-        : null;
-    if (hostedLaunchValidationRequired && !hostedLaunchValidationContext) {
-        return;
-    }
     for (const task of sortedTasks) {
         const entityId = task.name;
         try {
             if (task.kind === 'app') {
                 await (0, apps_1.validateAppTask)(task);
                 (0, apps_1.collectAppValidationWarnings)(task, 'source').forEach((warning) => warnings.add(warning));
-                if (task.hostingMode !== 'EXTERNAL' && !task.externalUrl) {
-                    const launchContext = hostedLaunchValidationContext;
-                    const creatorResult = (0, upload_content_1.getTaskCreatorResult)(task, launchContext.username, launchContext.currentUserRole);
-                    if (creatorResult.creatorTargetError) {
-                        throw new Error(creatorResult.creatorTargetError);
-                    }
-                    const launchCheck = await (0, apps_1.runLocalHostedLaunchCheck)({
-                        client: launchContext.client,
-                        apiBase: launchContext.apiBase,
-                        webBase: launchContext.webBase,
-                        creatorUsername: creatorResult.taskCreator,
-                        task,
-                        token: launchContext.token,
-                        currentUser: launchContext.currentUser,
-                        devRouterPort: launchContext.devRouterPort,
-                        allowUnregisteredViewerLaunch: launchContext.taskScoped,
-                    });
-                    if (launchCheck.status !== 'PASSED') {
-                        throw new Error((0, apps_1.formatHostedLaunchCheckFailure)(task.name, launchCheck, 'local'));
-                    }
-                }
             }
             else if (task.kind === 'asset-spec') {
                 // Parsing already validates the contract, symbol, and documentation files.

package/dist/commands/worker/runtime.d.ts

@@ -66,6 +66,7 @@ export declare function readCodexSandboxMode(env?: NodeJS.ProcessEnv): CodexSand
 export declare function buildClaudeExecArgs(input: {
     model: string;
     effort?: string | null;
+    chrome?: boolean;
     workspaceDir?: string | null;
     denyReadRoots?: string[] | null;
     pluginDir?: string | null;

package/dist/commands/worker/runtime.js

@@ -461,7 +461,13 @@ function buildClaudeExecArgs(input) {
         throw new Error('agent_task_assignment_model_missing');
     }
     const permissionSettings = buildClaudePermissionSettings(input.denyReadRoots ?? []);
-    const tools = 'Bash,Edit,Write,Read,Glob,Grep';
+    const permissionMode = input.chrome ? 'bypassPermissions' : 'acceptEdits';
+    const tools = input.chrome
+        ? [...CLAUDE_BASE_TOOL_NAMES, ...CLAUDE_CHROME_TOOL_NAMES].join(',')
+        : CLAUDE_BASE_TOOL_NAMES.join(',');
+    const allowedTools = input.chrome
+        ? [...CLAUDE_ALLOWED_PERMISSION_RULES, ...CLAUDE_CHROME_TOOL_NAMES]
+        : CLAUDE_ALLOWED_PERMISSION_RULES;
     const args = [
         '-p',
         '--model',
@@ -472,16 +478,19 @@ function buildClaudeExecArgs(input) {
         '--include-partial-messages',
         '--no-session-persistence',
         '--permission-mode',
-        'acceptEdits',
+        permissionMode,
         '--tools',
         tools,
         '--allowedTools',
-        ...CLAUDE_ALLOWED_PERMISSION_RULES,
+        ...allowedTools,
         '--disallowedTools',
         ...buildClaudeDeniedPermissionRules(input.denyReadRoots ?? []),
         '--settings',
         JSON.stringify(permissionSettings),
     ];
+    if (input.chrome) {
+        args.unshift('--chrome');
+    }
     const pluginDir = typeof input.pluginDir === 'string' ? input.pluginDir.trim() : '';
     if (pluginDir) {
         args.push('--plugin-dir', pluginDir);
@@ -492,6 +501,37 @@ function buildClaudeExecArgs(input) {
     }
     return args;
 }
+const CLAUDE_BASE_TOOL_NAMES = [
+    'Bash',
+    'Edit',
+    'Write',
+    'Read',
+    'Glob',
+    'Grep',
+];
+const CLAUDE_CHROME_TOOL_NAMES = [
+    'mcp__claude-in-chrome__browser_batch',
+    'mcp__claude-in-chrome__computer',
+    'mcp__claude-in-chrome__file_upload',
+    'mcp__claude-in-chrome__find',
+    'mcp__claude-in-chrome__form_input',
+    'mcp__claude-in-chrome__get_page_text',
+    'mcp__claude-in-chrome__javascript_tool',
+    'mcp__claude-in-chrome__list_connected_browsers',
+    'mcp__claude-in-chrome__navigate',
+    'mcp__claude-in-chrome__read_console_messages',
+    'mcp__claude-in-chrome__read_network_requests',
+    'mcp__claude-in-chrome__read_page',
+    'mcp__claude-in-chrome__resize_window',
+    'mcp__claude-in-chrome__select_browser',
+    'mcp__claude-in-chrome__shortcuts_execute',
+    'mcp__claude-in-chrome__shortcuts_list',
+    'mcp__claude-in-chrome__switch_browser',
+    'mcp__claude-in-chrome__tabs_close_mcp',
+    'mcp__claude-in-chrome__tabs_context_mcp',
+    'mcp__claude-in-chrome__tabs_create_mcp',
+    'mcp__claude-in-chrome__upload_image',
+];
 const CLAUDE_ALLOWED_PERMISSION_RULES = [
     'Read',
     'Edit',

package/dist/commands/worker.d.ts

@@ -5,7 +5,7 @@ import { type LoggedProcessResult, type LoggedProcessTranscriptChunk } from './w
 export { assertWorkerTokenUsageWithinCap, buildClaudeExecArgs, buildClaudePermissionSettings, buildCodexExecArgs, buildWorkerChildEnv, DEFAULT_CODEX_TIMEOUT_MS, DEFAULT_WORKER_TOKEN_CAP, extractAgentTokenUsage, extractCodexRolloutTokenUsage, extractCodexThreadId, extractCodexTokensUsed, readCodexRolloutTokenUsageForThread, readCodexSandboxMode, readEnvBoolean, runLoggedProcess } from './worker/runtime';
 export type { AgentTokenUsage, LoggedProcessResult, LoggedProcessTranscriptChunk } from './worker/runtime';
 export declare const WORKER_SESSION_EXPIRED_MESSAGE = "worker session expired: run \"playdrop auth login\" and start the worker again";
-export declare const WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = "worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task claim-slug, task upload/done/fail, assigned app scaffolding, project validation/build/dev/capture, read-only help/catalogue/documentation lookup, and PlayDrop AI generation are permitted.";
+export declare const WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = "worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task claim-slug, task upload/done/fail, assigned app scaffolding, project validation/build/dev/check/capture, read-only help/catalogue/documentation lookup, and PlayDrop AI generation are permitted.";
 type WorkerStartOptions = {
     env?: string;
     once?: boolean;

package/dist/commands/worker.js

@@ -120,11 +120,14 @@ const WORKER_CONTEXT_ALLOWED_COMMANDS = [
     ['task', 'submit-eval'],
     ['task', 'fail'],
     ['review', 'validate-result'],
+    ['review', 'list-windows'],
+    ['review', 'screenshot'],
     ['review', 'compose-evidence'],
     ['review', 'rating-card'],
     ['project', 'validate'],
     ['project', 'build'],
     ['project', 'dev'],
+    ['project', 'check'],
     ['project', 'capture'],
     ['browse'],
     ['search'],
@@ -138,7 +141,7 @@ const WORKER_CONTEXT_ALLOWED_COMMANDS = [
     ['ai', 'jobs', 'detail'],
     ['ai', 'generations'],
 ];
-exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = 'worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task claim-slug, task upload/done/fail, assigned app scaffolding, project validation/build/dev/capture, read-only help/catalogue/documentation lookup, and PlayDrop AI generation are permitted.';
+exports.WORKER_CONTEXT_COMMAND_NOT_ALLOWED_MESSAGE = 'worker_context_command_not_allowed: inside a PlayDrop worker task only task progress, task claim-slug, task upload/done/fail, assigned app scaffolding, project validation/build/dev/check/capture, read-only help/catalogue/documentation lookup, and PlayDrop AI generation are permitted.';
 function allocateWorkerDevPort(input) {
     const basePort = input.basePort ?? DEFAULT_WORKER_DEV_PORT_BASE;
     const maxParallelTasks = input.maxParallelTasks ?? DEFAULT_WORKER_MAX_PARALLEL_TASKS;
@@ -727,15 +730,6 @@ async function readTaskNextStepsFileForCommand(input) {
         return NEXT_STEPS_READ_FAILED;
     }
 }
-function isFinalOwnerRouteLaunchCheckFailure(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.startsWith('hosted_launch_check_failed:')
-        && message.includes('final owner play route');
-}
-function formatTerminalFinalOwnerRouteFailure(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return `agent_task_final_owner_route_failed: final owner play route validation failed after the task version was created. Task uploads have a fixed outputVersion and cannot be retried by bumping catalogue.json. ${message}`;
-}
 function assertTaskUploadResultMatchesContext(input) {
     if (input.uploadResult.taskId !== input.taskContext.taskId) {
         throw new Error('task_upload_result_task_mismatch');
@@ -1851,6 +1845,7 @@ async function runClaude(input) {
             workspaceDir: input.workspaceDir,
             denyReadRoots,
             pluginDir: input.playdropPluginRoot,
+            chrome: input.enableChrome,
         }),
         cwd: input.workspaceDir,
         env: (0, runtime_1.buildWorkerChildEnv)({
@@ -3529,6 +3524,7 @@ async function startWorker(options = {}) {
                         binDir,
                         eventDir,
                         prompt,
+                        enableChrome: task.kind === 'GAME_REVIEW' || task.kind === 'GAME_EVAL',
                         envName: env,
                         taskId: task.id,
                         attempt: taskContext.attempt,
@@ -3966,40 +3962,22 @@ async function uploadTask(options = {}) {
         return;
     }
     const projectDir = discoverWorkerProjectRoot(node_process_1.default.cwd());
-    let published;
-    try {
-        published = await (0, upload_1.publishWorkerAppProject)({
-            client: ctx.client,
-            taskId: taskContext.taskId,
-            kind: taskContext.kind,
-            expectedAppName: taskContext.outputAppName ?? undefined,
-            remixSourceRef: taskContext.remixSourceRef ?? null,
-            playdropAssetRequirement: resolvePlaydropAssetRequirementFromTaskRequest(taskContext.creatorRequest),
-            creatorRequest: taskContext.creatorRequest,
-            projectDir,
-            creatorUsername: taskContext.creatorUsername,
-            apiBase: ctx.envConfig.apiBase,
-            webBase: ctx.envConfig.webBase ?? null,
-            token: ctx.token,
-            user: ctx.user,
-        });
-    }
-    catch (error) {
-        if (isFinalOwnerRouteLaunchCheckFailure(error)) {
-            const terminalError = formatTerminalFinalOwnerRouteFailure(error);
-            await ctx.client.workerFailAgentTask(taskContext.taskId, {
-                taskToken: taskContext.taskToken,
-                error: terminalError,
-                result: {
-                    failedBy: 'worker_upload_final_owner_route',
-                    finalOwnerRouteFailure: true,
-                    originalError: error instanceof Error ? error.message : String(error),
-                },
-            });
-            throw new Error(terminalError);
-        }
-        throw error;
-    }
+    const published = await (0, upload_1.publishWorkerAppProject)({
+        client: ctx.client,
+        taskId: taskContext.taskId,
+        kind: taskContext.kind,
+        executionTarget: taskContext.target,
+        expectedAppName: taskContext.outputAppName ?? undefined,
+        remixSourceRef: taskContext.remixSourceRef ?? null,
+        playdropAssetRequirement: resolvePlaydropAssetRequirementFromTaskRequest(taskContext.creatorRequest),
+        creatorRequest: taskContext.creatorRequest,
+        projectDir,
+        creatorUsername: taskContext.creatorUsername,
+        apiBase: ctx.envConfig.apiBase,
+        webBase: ctx.envConfig.webBase ?? null,
+        token: ctx.token,
+        user: ctx.user,
+    });
     const result = {
         taskId: taskContext.taskId,
         appId: published.appId,

package/dist/index.js

@@ -30,10 +30,9 @@ const create_1 = require("./commands/create");
 const createRemixContent_1 = require("./commands/createRemixContent");
 const dev_1 = require("./commands/dev");
 const devBrowser_1 = require("./commands/devBrowser");
-const capture_1 = require("./commands/capture");
+const check_1 = require("./commands/check");
 const devServer_1 = require("./commands/devServer");
 const captureListing_1 = require("./commands/captureListing");
-const captureRemote_1 = require("./commands/captureRemote");
 const marketing_1 = require("./commands/marketing");
 const review_1 = require("./commands/review");
 const validate_1 = require("./commands/validate");
@@ -290,6 +289,23 @@ task
     await (0, worker_1.failTask)(opts);
 });
 const review = program.command('review').description('Review helper commands for PlayDrop worker tasks');
+review
+    .command('list-windows')
+    .description('List native capture windows for review evidence')
+    .requiredOption('--pid <pid>', 'Browser process id')
+    .action(async (opts) => {
+    await (0, review_1.listReviewCaptureWindows)(opts);
+});
+review
+    .command('screenshot')
+    .description('Capture a native screenshot for review evidence')
+    .requiredOption('--pid <pid>', 'Browser process id')
+    .option('--window-id <id>', 'Native capture window id')
+    .requiredOption('--out <path>', 'Output PNG path')
+    .option('--metadata <path>', 'Output metadata JSON path')
+    .action(async (opts) => {
+    await (0, review_1.captureReviewScreenshot)(opts);
+});
 review
     .command('validate-result')
     .description('Validate a canonical game review result')
@@ -986,37 +1002,24 @@ project
         player: opts.player,
     });
 });
-const projectCapture = project.command('capture').description('Run a Playwright capture');
-projectCapture
-    .argument('[target]')
+project
+    .command('check [target]')
+    .description('Run the deterministic hosted game load-check in installed Chrome')
     .option('--app <name>', 'App name when the target is a workspace')
-    .option('--timeout <seconds>', 'Capture timeout in seconds')
-    .option('--log-level <level>', 'debug, info, warn, or error')
+    .option('--timeout <seconds>', 'Load-check timeout in seconds')
     .option('--screenshot <path>', 'Screenshot output path')
-    .option('--surface <surface>', 'desktop, mobile-landscape, or mobile-portrait')
-    .option('--dev-auth <mode>', 'anonymous, viewer, or player')
-    .option('--player <slot>', '1, 2, 3, or 4 when --dev-auth player is selected')
-    .option('--reset-dev-player <mode>', 'before, after, before-and-after, or never')
-    .option('--username <username>', 'Override saved login username for this run')
-    .option('--password <password>', 'Override saved login password for this run')
-    .action(async (target, opts) => {
-    const timeoutSeconds = opts.timeout !== undefined ? Number.parseFloat(String(opts.timeout)) : undefined;
-    await (0, capture_1.capture)(target, {
-        timeoutSeconds,
-        appName: opts.app,
-        logLevel: opts.logLevel,
-        screenshotPath: opts.screenshot,
-        surfaceTarget: opts.surface,
-        devAuth: opts.devAuth,
-        player: opts.player,
-        resetDevPlayer: opts.resetDevPlayer,
-        username: opts.username,
-        password: opts.password,
+    .option('--actions <path>', 'JSON action script to dispatch after the game frame is ready')
+    .action(async (target, opts = {}) => {
+    await (0, check_1.check)(target, {
+        app: opts.app,
+        timeout: opts.timeout,
+        screenshot: opts.screenshot,
+        actions: opts.actions,
     });
 });
+const projectCapture = project.command('capture').description('Record game media with the native macOS recorder');
 projectCapture
-    .command('listing [target]', { hidden: true })
-    .description('Record private listing video for a hosted app')
+    .argument('[target]')
     .option('--app <name>', 'App name when the target is a workspace')
     .option('--duration <seconds>', 'Recording duration in seconds')
     .option('--width <pixels>', 'Final gameplay width in pixels')
@@ -1026,6 +1029,7 @@ projectCapture
     .option('--audio', 'Capture gameplay audio')
     .option('--output-dir <path>', 'Output directory for the capture artifacts')
     .option('--keep-raw', 'Keep the raw intermediate recording')
+    .option('--content-hash <sha256>', 'Uploaded build content hash to bind this capture to')
     .action(async (target, opts) => {
     await (0, captureListing_1.captureListing)(target, {
         app: opts.app,
@@ -1037,27 +1041,7 @@ projectCapture
         audio: opts.audio,
         outputDir: opts.outputDir,
         keepRaw: opts.keepRaw,
-    });
-});
-projectCapture
-    .command('remote <url>')
-    .description('Run a Playwright capture against a published URL')
-    .option('--timeout <seconds>', 'Readiness timeout in seconds')
-    .option('--settle <seconds>', 'Post-ready settle delay before screenshot in seconds')
-    .option('--screenshot <path>', 'Screenshot output path')
-    .option('--log <path>', 'Log output path')
-    .option('--expected-url <url>', 'Expected final URL after redirects')
-    .option('--actions <path>', 'JSON action file with click, press, and wait steps before screenshot')
-    .option('--viewport <size>', 'Viewport size as WIDTHxHEIGHT')
-    .option('--surface <surface>', 'Browser surface preset: desktop, mobile-landscape, or mobile-portrait')
-    .option('--fps-sample-ms <milliseconds>', 'Sample frame rate for this many milliseconds after capture')
-    .option('--username <username>', 'Login username')
-    .option('--password <password>', 'Login password')
-    .option('--login-url <url>', 'Explicit login URL')
-    .action(async (url, _opts, command) => {
-    await (0, captureRemote_1.captureRemote)(url, {
-        ...(command.parent?.opts() ?? {}),
-        ...command.opts(),
+        contentHash: opts.contentHash,
     });
 });
 const projectMarketing = project.command('marketing').description('Prepare local marketing captures and assets');

package/dist/playwright.d.ts

@@ -1,6 +1,7 @@
 import type { Browser, BrowserContext, BrowserContextOptions, Page } from 'playwright-core';
 export declare const HEADLESS_CHROMIUM_ARGS: readonly ["--no-sandbox", "--disable-web-security", "--use-gl=angle", "--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--ignore-gpu-blocklist"];
 export declare const INTERACTIVE_CHROMIUM_ARGS: readonly ["--no-sandbox", "--disable-web-security", "--ignore-gpu-blocklist"];
+export declare const INSTALLED_CHROME_ARGS: readonly ["--no-sandbox", "--disable-web-security", "--ignore-gpu-blocklist"];
 export declare const CHROMIUM_ARGS: readonly ["--no-sandbox", "--disable-web-security", "--use-gl=angle", "--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--ignore-gpu-blocklist"];
 type PlaywrightModule = {
     chromium: {
@@ -8,11 +9,13 @@ type PlaywrightModule = {
             headless?: boolean;
             args?: readonly string[];
             chromiumSandbox?: boolean;
+            channel?: string;
         }): Promise<Browser>;
         launchPersistentContext?(userDataDir: string, options: BrowserContextOptions & {
             headless?: boolean;
             args?: readonly string[];
             chromiumSandbox?: boolean;
+            channel?: string;
         }): Promise<BrowserContext>;
     };
 };
@@ -21,11 +24,13 @@ type PlaydropBrowserContextOptions = BrowserContextOptions & {
 };
 export declare function setPlaywrightLoader(loader: (() => Promise<PlaywrightModule>) | null): void;
 export declare function createPlaywrightLaunchError(tool: string, error: unknown): Error;
+export declare function createInstalledChromeLaunchError(tool: string, error: unknown): Error;
 type PageCallback<T> = (context: {
     browser: Browser;
     context: BrowserContext;
     page: Page;
 }) => Promise<T>;
 export declare function withChromiumPage<T>(callback: PageCallback<T>, options?: PlaydropBrowserContextOptions): Promise<T>;
+export declare function withInstalledChromePage<T>(callback: PageCallback<T>, options?: PlaydropBrowserContextOptions): Promise<T>;
 export declare function launchPersistentChromiumContext(userDataDir: string, options?: PlaydropBrowserContextOptions): Promise<BrowserContext>;
 export {};

package/dist/playwright.js

@@ -33,13 +33,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CHROMIUM_ARGS = exports.INTERACTIVE_CHROMIUM_ARGS = exports.HEADLESS_CHROMIUM_ARGS = void 0;
+exports.CHROMIUM_ARGS = exports.INSTALLED_CHROME_ARGS = exports.INTERACTIVE_CHROMIUM_ARGS = exports.HEADLESS_CHROMIUM_ARGS = void 0;
 exports.setPlaywrightLoader = setPlaywrightLoader;
 exports.createPlaywrightLaunchError = createPlaywrightLaunchError;
+exports.createInstalledChromeLaunchError = createInstalledChromeLaunchError;
 exports.withChromiumPage = withChromiumPage;
+exports.withInstalledChromePage = withInstalledChromePage;
 exports.launchPersistentChromiumContext = launchPersistentChromiumContext;
 const node_url_1 = require("node:url");
 const TOOL_NAME = 'playdrop';
+const INSTALLED_CHROME_CHANNEL = 'chrome';
 const COMMON_CHROMIUM_ARGS = [
     '--no-sandbox',
     '--disable-web-security',
@@ -57,6 +60,8 @@ exports.INTERACTIVE_CHROMIUM_ARGS = [
     ...COMMON_CHROMIUM_ARGS,
     '--ignore-gpu-blocklist',
 ];
+// Deterministic project checks must exercise the installed Chrome GPU path.
+exports.INSTALLED_CHROME_ARGS = exports.INTERACTIVE_CHROMIUM_ARGS;
 // Backward-compatible alias for older imports.
 exports.CHROMIUM_ARGS = exports.HEADLESS_CHROMIUM_ARGS;
 let customLoader = null;
@@ -101,6 +106,19 @@ function createPlaywrightLaunchError(tool, error) {
     }
     return error instanceof Error ? error : new Error(message);
 }
+function createInstalledChromeLaunchError(tool, error) {
+    const message = error && typeof error === 'object' && 'message' in error ? String(error.message) : String(error);
+    return new Error([
+        `[${tool}] Failed to launch installed Google Chrome.`,
+        '',
+        'Required setup:',
+        '  1. Install Google Chrome for this macOS user.',
+        '  2. Run from a logged-in GUI session with WindowServer access.',
+        '  3. If invoked over SSH, keep keychain unlock and the command in the same SSH session.',
+        '',
+        `Original error: ${message}`,
+    ].join('\n'));
+}
 async function grantAutomationLocalNetworkAccess(context, origin) {
     if (!origin?.trim()) {
         return;
@@ -153,6 +171,47 @@ async function withChromiumPage(callback, options = {}) {
         }
     }
 }
+async function withInstalledChromePage(callback, options = {}) {
+    const { chromium } = await loadPlaywright();
+    let browser;
+    try {
+        browser = await chromium.launch({
+            channel: INSTALLED_CHROME_CHANNEL,
+            headless: false,
+            args: [...exports.INSTALLED_CHROME_ARGS],
+            chromiumSandbox: false,
+        });
+    }
+    catch (error) {
+        throw createInstalledChromeLaunchError(TOOL_NAME, error);
+    }
+    let context = null;
+    try {
+        const { automationOrigin, ...contextOptions } = options;
+        context = await browser.newContext(contextOptions);
+        await grantAutomationLocalNetworkAccess(context, automationOrigin);
+        const page = await context.newPage();
+        return await callback({ browser, context, page });
+    }
+    finally {
+        if (context) {
+            try {
+                await context.close();
+            }
+            catch (closeError) {
+                const message = closeError instanceof Error ? closeError.message : String(closeError);
+                console.warn(`[${TOOL_NAME}] Failed to close Playwright context: ${message}`);
+            }
+        }
+        try {
+            await browser.close();
+        }
+        catch (closeError) {
+            const message = closeError instanceof Error ? closeError.message : String(closeError);
+            console.warn(`[${TOOL_NAME}] Failed to close Playwright browser: ${message}`);
+        }
+    }
+}
 async function launchPersistentChromiumContext(userDataDir, options = {}) {
     const { chromium } = await loadPlaywright();
     if (typeof chromium.launchPersistentContext !== 'function') {