@playdrop/playdrop-cli 0.13.0 → 0.13.2

package/config/client-meta.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.13.0",
+  "version": "0.13.2",
   "build": 1,
-  "runtimeSdkVersion": "0.13.0",
+  "runtimeSdkVersion": "0.13.2",
   "runtimeSdkBuild": 1,
   "clients": {
     "all": {

package/dist/commands/captureListing.d.ts

@@ -85,7 +85,7 @@ export declare function buildListingCaptureFrameUrl({ webBase, currentUsername,
 export declare function resolveListingCaptureSceneId(width: number, height: number): 'listing-landscape' | 'listing-portrait';
 export declare function parseCaptureListingOptions(targetArg: string | undefined, options?: CaptureListingOptions): ParsedCaptureListingOptions;
 export declare function assertSupportedListingEnvironment(platform?: NodeJS.Platform, macosVersion?: string): void;
-export declare function resolveListingRecorderPath(baseDir?: string): string;
+export declare function resolveListingRecorderPath(workerHome?: string): string;
 export declare function buildSurfaceOutputPaths(outputDir: string, surface: AppSurface, useSurfacePrefix: boolean): {
     rawVideoPath: string;
     metadataPath: string;

package/dist/commands/captureListing.js

@@ -59,6 +59,7 @@ const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
 const messages_1 = require("../messages");
 const playwright_1 = require("../playwright");
+const recorderRelease_1 = require("../recorderRelease");
 const listingCaptureLease_1 = require("../listingCaptureLease");
 const dev_1 = require("./dev");
 const devRuntimeAssets_1 = require("./devRuntimeAssets");
@@ -204,8 +205,8 @@ function commandExists(command) {
 async function ensureExecutableFile(filePath) {
     await (0, promises_1.access)(filePath);
 }
-function resolveListingRecorderPath(baseDir = __dirname) {
-    return (0, node_path_1.resolve)(baseDir, '..', '..', '..', '..', 'clients', 'apple', 'playdrop-listing-recorder', '.build', 'release', 'playdrop-listing-recorder');
+function resolveListingRecorderPath(workerHome) {
+    return (0, recorderRelease_1.resolveMacWorkerRecorderPath)(workerHome);
 }
 function buildTimestampFolder(date = new Date()) {
     const iso = date.toISOString();
@@ -755,7 +756,7 @@ async function ensureListingRecorderAvailable(recorderPath) {
         return true;
     }
     catch {
-        (0, messages_1.printErrorWithHelp)(`Native recorder binary was not found at ${recorderPath}.`, ['Build it with: (cd clients/apple/playdrop-listing-recorder && swift build -c release)'], { command: 'project capture' });
+        (0, messages_1.printErrorWithHelp)(`Native recorder binary was not found at ${recorderPath}.`, ['Start the PlayDrop worker once on this Mac to install the recorder from the PlayDrop CDN.'], { command: 'project capture' });
         process.exitCode = 1;
         return false;
     }

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

@@ -85,6 +85,7 @@ export declare function buildClaudeExecArgs(input: {
 }): string[];
 export declare const PLAYWRIGHT_MCP_VERSION = "0.0.78";
 export type WorkerInstrumentSurface = 'DESKTOP' | 'MOBILE_LANDSCAPE' | 'MOBILE_PORTRAIT';
+export declare function resolvePlaywrightMcpCliPath(): string;
 export declare function buildPlaywrightMcpCommand(surface?: WorkerInstrumentSurface | null): {
     command: string;
     args: string[];

package/dist/commands/worker/runtime.js

@@ -18,6 +18,7 @@ exports.runLoggedProcess = runLoggedProcess;
 exports.buildCodexExecArgs = buildCodexExecArgs;
 exports.readCodexSandboxMode = readCodexSandboxMode;
 exports.buildClaudeExecArgs = buildClaudeExecArgs;
+exports.resolvePlaywrightMcpCliPath = resolvePlaywrightMcpCliPath;
 exports.buildPlaywrightMcpCommand = buildPlaywrightMcpCommand;
 exports.buildPlaywrightMcpServerConfig = buildPlaywrightMcpServerConfig;
 exports.buildClaudePermissionSettings = buildClaudePermissionSettings;
@@ -27,6 +28,7 @@ exports.buildCleanRoomChildEnv = buildCleanRoomChildEnv;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
+const node_module_1 = require("node:module");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const surfaceProfiles_1 = require("../../apps/surfaceProfiles");
@@ -691,13 +693,32 @@ const CLAUDE_BASE_TOOL_NAMES = [
 // never through @latest drift (see the 2026-07-13 auto-update incident).
 exports.PLAYWRIGHT_MCP_VERSION = '0.0.78';
 const PLAYWRIGHT_MCP_ALLOWED_TOOL_RULE = 'mcp__playwright';
+const requireFromWorkerRuntime = (0, node_module_1.createRequire)(__filename);
+function resolvePlaywrightMcpCliPath() {
+    let packageJsonPath;
+    let packageJson;
+    try {
+        packageJsonPath = requireFromWorkerRuntime.resolve('@playwright/mcp/package.json');
+        packageJson = requireFromWorkerRuntime('@playwright/mcp/package.json');
+    }
+    catch {
+        throw new Error(`worker_preflight_playwright_mcp_missing:@playwright/mcp@${exports.PLAYWRIGHT_MCP_VERSION}`);
+    }
+    if (packageJson.version !== exports.PLAYWRIGHT_MCP_VERSION) {
+        throw new Error(`worker_preflight_playwright_mcp_version:expected=${exports.PLAYWRIGHT_MCP_VERSION}:actual=${packageJson.version ?? 'missing'}`);
+    }
+    const cliPath = node_path_1.default.join(node_path_1.default.dirname(packageJsonPath), 'cli.js');
+    if (!(0, node_fs_1.existsSync)(cliPath)) {
+        throw new Error(`worker_preflight_playwright_mcp_missing:${cliPath}`);
+    }
+    return cliPath;
+}
 function buildPlaywrightMcpCommand(surface) {
     const surfaceArgs = surface ? (0, surfaceProfiles_1.buildPlaywrightMcpSurfaceArgs)(surface) : [];
     return {
-        command: 'npx',
+        command: process.execPath,
         args: [
-            '-y',
-            `@playwright/mcp@${exports.PLAYWRIGHT_MCP_VERSION}`,
+            resolvePlaywrightMcpCliPath(),
             '--browser',
             'chrome',
             '--isolated',

package/dist/commands/worker.d.ts

@@ -304,6 +304,16 @@ export declare function parseCodexModelCatalog(output: string): string[];
 export declare function parseClaudeModelCatalog(output: string): string[];
 export declare function claudeModelProbeReportsSelection(output: string, expectedDisplayName: string): boolean;
 export declare function probeWorkerProviderIndependently<T>(probe: () => T, unavailable: T): T;
+type MacChromeAutomationProbeRunner = (command: string, args: string[]) => {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};
+export declare function probeMacChromeAutomationPermission(options?: {
+    platform?: NodeJS.Platform;
+    runner?: MacChromeAutomationProbeRunner;
+}): 'granted' | 'not_running' | 'denied' | 'not_applicable';
+export declare function describeWorkerPreflightReason(reason: string): string;
 export declare function buildWorkerSetupActions(input: {
     degradedReasons: string[];
     playwright?: {
@@ -392,6 +402,17 @@ export declare function enforceInstrumentBrowserHygiene(assignment: WorkerTaskAs
     remainingTaskTabs: number;
     blankWindows: number;
 }>;
+export declare function finalizeInstrumentBrowserHygiene(assignment: WorkerTaskAssignmentV2, options?: {
+    platform?: NodeJS.Platform;
+    runner?: InstrumentBrowserHygieneRunner;
+}): Promise<{
+    ok: true;
+    remainingTaskTabs: number;
+    blankWindows: number;
+} | {
+    ok: false;
+    error: string;
+}>;
 export declare function assignmentRequiresRegisteredBundle(assignment: WorkerTaskAssignmentV2): boolean;
 export declare function startWorker(options?: WorkerStartOptions): Promise<void>;
 export declare function reportTask(options: TaskReportOptions): Promise<void>;

package/dist/commands/worker.js

@@ -56,6 +56,8 @@ exports.parseCodexModelCatalog = parseCodexModelCatalog;
 exports.parseClaudeModelCatalog = parseClaudeModelCatalog;
 exports.claudeModelProbeReportsSelection = claudeModelProbeReportsSelection;
 exports.probeWorkerProviderIndependently = probeWorkerProviderIndependently;
+exports.probeMacChromeAutomationPermission = probeMacChromeAutomationPermission;
+exports.describeWorkerPreflightReason = describeWorkerPreflightReason;
 exports.buildWorkerSetupActions = buildWorkerSetupActions;
 exports.resolveWorkerStateDir = resolveWorkerStateDir;
 exports.resolveWorkerSupervisorLockFile = resolveWorkerSupervisorLockFile;
@@ -77,6 +79,7 @@ exports.showWorkerStatus = showWorkerStatus;
 exports.setupWorker = setupWorker;
 exports.instrumentTaskChromeTitleMatchers = instrumentTaskChromeTitleMatchers;
 exports.enforceInstrumentBrowserHygiene = enforceInstrumentBrowserHygiene;
+exports.finalizeInstrumentBrowserHygiene = finalizeInstrumentBrowserHygiene;
 exports.assignmentRequiresRegisteredBundle = assignmentRequiresRegisteredBundle;
 exports.startWorker = startWorker;
 exports.reportTask = reportTask;
@@ -108,6 +111,7 @@ const commandContext_1 = require("../commandContext");
 const config_1 = require("../config");
 const messages_1 = require("../messages");
 const output_1 = require("../output");
+const recorderRelease_1 = require("../recorderRelease");
 const shellProbe_1 = require("../shellProbe");
 const review_1 = require("./review");
 const upload_1 = require("./upload");
@@ -1548,14 +1552,6 @@ function readCodexAuthenticated(homeDir = node_os_1.default.homedir()) {
         return false;
     }
 }
-function probeNpmVersion() {
-    const result = (0, shellProbe_1.runShell)('npm --version');
-    const version = result.output.trim().split('\n')[0]?.trim() ?? '';
-    if (result.exitCode !== 0 || !version) {
-        throw new Error(`worker_preflight_npm_missing: "npm --version" exited with code ${result.exitCode}.`);
-    }
-    return version;
-}
 function probePlaywrightChromium() {
     let playwrightCore;
     let packageJson;
@@ -2833,6 +2829,146 @@ function errorMessage(error) {
 function errorCode(error) {
     return errorMessage(error).split(':')[0]?.trim() || 'unknown_error';
 }
+function workerCommandExists(command) {
+    const probe = (0, shellProbe_1.runShell)((0, shellProbe_1.buildCommandPathProbe)(command));
+    return probe.exitCode === 0 && Boolean(probe.output.trim());
+}
+function resolveInstalledChromeExecutable() {
+    if (node_process_1.default.platform === 'darwin') {
+        const executable = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+        return (0, node_fs_1.existsSync)(executable) ? executable : null;
+    }
+    if (node_process_1.default.platform === 'win32') {
+        const roots = [node_process_1.default.env.PROGRAMFILES, node_process_1.default.env['PROGRAMFILES(X86)'], node_process_1.default.env.LOCALAPPDATA]
+            .map((value) => value?.trim())
+            .filter((value) => Boolean(value));
+        for (const root of roots) {
+            const executable = node_path_1.default.join(root, 'Google', 'Chrome', 'Application', 'chrome.exe');
+            if ((0, node_fs_1.existsSync)(executable)) {
+                return executable;
+            }
+        }
+        return null;
+    }
+    return workerCommandExists('google-chrome') ? 'google-chrome' : null;
+}
+const MAC_CHROME_AUTOMATION_PREFLIGHT_APPLESCRIPT = `
+if application "Google Chrome" is not running then
+  return "not_running"
+end if
+tell application "Google Chrome"
+  count of windows
+end tell
+return "granted"
+`;
+function probeMacChromeAutomationPermission(options = {}) {
+    if ((options.platform ?? node_process_1.default.platform) !== 'darwin') {
+        return 'not_applicable';
+    }
+    const runner = options.runner ?? ((command, args) => {
+        const result = (0, node_child_process_1.spawnSync)(command, args, { encoding: 'utf8', timeout: 10000 });
+        return {
+            status: result.status,
+            stdout: result.stdout ?? '',
+            stderr: result.stderr ?? '',
+        };
+    });
+    const result = runner('osascript', ['-e', MAC_CHROME_AUTOMATION_PREFLIGHT_APPLESCRIPT]);
+    const output = result.stdout.trim();
+    if (result.status === 0 && output === 'granted') {
+        return 'granted';
+    }
+    if (result.status === 0 && output === 'not_running') {
+        return 'not_running';
+    }
+    return 'denied';
+}
+function collectWorkerInfrastructureFailures() {
+    const failures = [];
+    if (!resolveInstalledChromeExecutable()) {
+        failures.push('worker_preflight_google_chrome_missing');
+    }
+    try {
+        (0, runtime_1.resolvePlaywrightMcpCliPath)();
+    }
+    catch (error) {
+        failures.push(errorCode(error));
+    }
+    if (node_process_1.default.platform !== 'darwin') {
+        return failures;
+    }
+    if (node_process_1.default.arch !== recorderRelease_1.MAC_WORKER_RECORDER_RELEASE.architecture) {
+        failures.push('worker_preflight_recorder_architecture_unsupported');
+        return failures;
+    }
+    if (!workerCommandExists('ffmpeg')) {
+        failures.push('worker_preflight_ffmpeg_missing');
+    }
+    if (!workerCommandExists('ffprobe')) {
+        failures.push('worker_preflight_ffprobe_missing');
+    }
+    const guiSession = (0, shellProbe_1.runShell)('/bin/launchctl print "gui/$(/usr/bin/id -u)"');
+    if (guiSession.exitCode !== 0) {
+        failures.push('worker_preflight_gui_session_missing');
+    }
+    if (probeMacChromeAutomationPermission() === 'denied') {
+        failures.push('worker_preflight_chrome_automation_permission_missing');
+    }
+    const recorderPath = (0, recorderRelease_1.resolveMacWorkerRecorderPath)();
+    if (!(0, node_fs_1.existsSync)(recorderPath)) {
+        failures.push('worker_preflight_recorder_missing');
+        return failures;
+    }
+    const recorderStat = (0, node_fs_1.statSync)(recorderPath);
+    if (!recorderStat.isFile() || (recorderStat.mode & 0o111) === 0) {
+        failures.push('worker_preflight_recorder_not_executable');
+        return failures;
+    }
+    const installedSha256 = (0, recorderRelease_1.recorderSha256)((0, node_fs_1.readFileSync)(recorderPath));
+    if (installedSha256 !== recorderRelease_1.MAC_WORKER_RECORDER_RELEASE.sha256) {
+        failures.push('worker_preflight_recorder_hash_mismatch');
+        return failures;
+    }
+    const permission = (0, node_child_process_1.spawnSync)(recorderPath, ['--check-permission'], {
+        encoding: 'utf8',
+        timeout: 10000,
+    });
+    if (permission.status !== 0) {
+        failures.push('worker_preflight_screen_recording_permission_missing');
+    }
+    return failures;
+}
+function describeWorkerPreflightReason(reason) {
+    if (reason.startsWith('worker_preflight_recorder_download_failed:')) {
+        return `The PlayDrop macOS recorder could not be downloaded: ${reason.slice('worker_preflight_recorder_download_failed:'.length).trim()}`;
+    }
+    const descriptions = {
+        worker_preflight_google_chrome_missing: 'Google Chrome is missing from its standard installation path.',
+        worker_preflight_playwright_missing: 'The PlayDrop CLI cannot load Playwright.',
+        worker_preflight_chromium_missing: 'The Chromium executable required by Playwright is missing.',
+        worker_preflight_playwright_mcp_missing: 'The pinned Playwright MCP package is missing from the PlayDrop CLI installation.',
+        worker_preflight_playwright_mcp_version: 'The installed Playwright MCP package does not match the PlayDrop CLI release.',
+        worker_preflight_ffmpeg_missing: 'ffmpeg is missing from PATH.',
+        worker_preflight_ffprobe_missing: 'ffprobe is missing from PATH.',
+        worker_preflight_gui_session_missing: 'No active macOS GUI session is available.',
+        worker_preflight_chrome_automation_permission_missing: 'Google Chrome Automation permission is missing. In System Settings > Privacy & Security > Automation, allow the PlayDrop worker process to control Google Chrome, then restart the worker.',
+        worker_preflight_recorder_architecture_unsupported: 'The native recorder is currently available only for Apple silicon Macs.',
+        worker_preflight_recorder_missing: 'The PlayDrop macOS recorder is missing.',
+        worker_preflight_recorder_not_executable: 'The PlayDrop macOS recorder is not executable.',
+        worker_preflight_recorder_hash_mismatch: 'The PlayDrop macOS recorder does not match this CLI release.',
+        worker_preflight_screen_recording_permission_missing: 'Screen Recording permission is not granted to the PlayDrop recorder.',
+        codex_not_authenticated: 'Codex is installed but not authenticated.',
+        codex_models_unavailable: 'Codex is authenticated but reported no usable models.',
+        claude_not_authenticated: 'Claude Code is installed but not authenticated.',
+        claude_models_unavailable: 'Claude Code is authenticated but reported no usable models.',
+        agent_cli_not_found: 'No supported authenticated agent CLI is installed.',
+    };
+    return descriptions[reason] ?? reason;
+}
+function formatWorkerPreflightFailure(reasons) {
+    const uniqueReasons = Array.from(new Set(reasons));
+    return new Error(`worker_preflight_failed:\n${uniqueReasons.map((reason) => `- ${describeWorkerPreflightReason(reason)}`).join('\n')}`);
+}
 function readWorkerTargetUpdateFailure() {
     const failureFile = node_process_1.default.env.PLAYDROP_WORKER_TARGET_UPDATE_FAILURE_FILE?.trim() ?? '';
     if (!failureFile || !(0, node_fs_1.existsSync)(failureFile)) {
@@ -2858,7 +2994,7 @@ function collectWorkerLocalStatus() {
     let claudeVersion = null;
     let claudeModels = [];
     let cursorVersion = null;
-    let npmVersion = null;
+    const npmVersion = null;
     let playwright = null;
     let targetUpdateFailure = null;
     try {
@@ -2881,12 +3017,6 @@ function collectWorkerLocalStatus() {
     catch (error) {
         degradedReasons.push(errorCode(error));
     }
-    try {
-        npmVersion = probeNpmVersion();
-    }
-    catch (error) {
-        degradedReasons.push(errorCode(error));
-    }
     try {
         playwright = probePlaywrightChromium();
         if (!playwright.chromiumInstalled) {
@@ -2896,6 +3026,7 @@ function collectWorkerLocalStatus() {
     catch (error) {
         degradedReasons.push(errorCode(error));
     }
+    degradedReasons.push(...collectWorkerInfrastructureFailures());
     try {
         targetUpdateFailure = readWorkerTargetUpdateFailure();
     }
@@ -2929,7 +3060,8 @@ function collectWorkerLocalStatus() {
         degradedReasons.push(errorCode(error));
     }
     const uniqueReasons = Array.from(new Set(degradedReasons));
-    const infrastructureReady = Boolean(npmVersion && playwright?.chromiumInstalled);
+    const infrastructureFailures = degradedReasons.filter((reason) => reason.startsWith('worker_preflight_'));
+    const infrastructureReady = Boolean(playwright?.chromiumInstalled) && infrastructureFailures.length === 0;
     const ready = Boolean(capabilities?.ready) && infrastructureReady;
     return {
         ready,
@@ -2949,6 +3081,11 @@ function collectWorkerLocalStatus() {
 function buildWorkerSetupActions(input) {
     const reasons = new Set(input.degradedReasons);
     const actions = [];
+    const addManualAction = (reason, label) => {
+        if (reasons.has(reason)) {
+            actions.push({ reason, label, message: describeWorkerPreflightReason(reason) });
+        }
+    };
     if (reasons.has('worker_preflight_chromium_missing')) {
         const version = input.playwright?.version && input.playwright.version !== 'unknown'
             ? `@${input.playwright.version}`
@@ -2977,6 +3114,18 @@ function buildWorkerSetupActions(input) {
             message: 'Install and authenticate Codex or Claude Code, then rerun playdrop agents status --json.',
         });
     }
+    addManualAction('worker_preflight_google_chrome_missing', 'Install Google Chrome');
+    addManualAction('worker_preflight_playwright_mcp_missing', 'Repair the PlayDrop CLI installation');
+    addManualAction('worker_preflight_playwright_mcp_version', 'Repair the PlayDrop CLI installation');
+    addManualAction('worker_preflight_ffmpeg_missing', 'Install ffmpeg');
+    addManualAction('worker_preflight_ffprobe_missing', 'Install ffprobe');
+    addManualAction('worker_preflight_gui_session_missing', 'Sign in to the Mac desktop');
+    addManualAction('worker_preflight_chrome_automation_permission_missing', 'Grant Google Chrome Automation permission');
+    addManualAction('worker_preflight_recorder_architecture_unsupported', 'Use an Apple silicon Mac');
+    addManualAction('worker_preflight_recorder_missing', 'Restart the worker to download the recorder');
+    addManualAction('worker_preflight_recorder_not_executable', 'Restart the worker to repair the recorder');
+    addManualAction('worker_preflight_recorder_hash_mismatch', 'Restart the worker to repair the recorder');
+    addManualAction('worker_preflight_screen_recording_permission_missing', 'Grant Screen Recording permission');
     return actions;
 }
 function resolveWorkerStateDir() {
@@ -3595,13 +3744,30 @@ TARGET_CLI_VERSION="$(read_policy_value targetCliVersion)"
 MINIMUM_CLI_VERSION="$(read_policy_value minimumCliVersion)"
 
 if [ -n "$TARGET_CLI_VERSION" ]; then
-  if npm install -g --no-audit --no-fund "@playdrop/playdrop-cli@$TARGET_CLI_VERSION"; then
-    CURRENT_CLI_VERSION="$(current_cli_version)" || CURRENT_CLI_VERSION=""
-    if [ "$CURRENT_CLI_VERSION" != "$TARGET_CLI_VERSION" ]; then
-      record_target_failure "worker_update_cli_version_mismatch"
+  CURRENT_CLI_VERSION="$(current_cli_version)" || CURRENT_CLI_VERSION=""
+  if [ "$CURRENT_CLI_VERSION" != "$TARGET_CLI_VERSION" ]; then
+    GLOBAL_NPM_ROOT="$(npm root -g)" || GLOBAL_NPM_ROOT=""
+    BROKEN_FSEVENTS_PATH="$GLOBAL_NPM_ROOT/@playdrop/playdrop-cli/node_modules/fsevents"
+    if [ -n "$GLOBAL_NPM_ROOT" ] && [ -f "$BROKEN_FSEVENTS_PATH/package.json" ]; then
+      node - "$BROKEN_FSEVENTS_PATH" <<'NODE' || record_target_failure "worker_update_fsevents_cleanup_failed"
+const fs = require("fs");
+const path = process.argv[2];
+const packageJson = JSON.parse(fs.readFileSync(path + "/package.json", "utf8"));
+if (packageJson.version === "2.3.2") {
+  fs.rmSync(path, { recursive: true, force: true });
+}
+NODE
+    fi
+    if [ "$TARGET_UPDATE_FAILED" -eq 0 ]; then
+      if npm install -g --no-audit --no-fund "@playdrop/playdrop-cli@$TARGET_CLI_VERSION"; then
+        CURRENT_CLI_VERSION="$(current_cli_version)" || CURRENT_CLI_VERSION=""
+        if [ "$CURRENT_CLI_VERSION" != "$TARGET_CLI_VERSION" ]; then
+          record_target_failure "worker_update_cli_version_mismatch"
+        fi
+      else
+        record_target_failure "worker_update_cli_install_failed"
+      fi
     fi
-  else
-    record_target_failure "worker_update_cli_install_failed"
   fi
 fi
 
@@ -3799,7 +3965,7 @@ async function setupWorker(options = {}) {
         const workerName = explicitWorkerName || `${username} - ${node_os_1.default.hostname()}`;
         const local = collectWorkerLocalStatus();
         const agentReady = local.agents.some((agent) => agent.ready === true);
-        const baseRuntimeReady = Boolean(agentReady && local.npmVersion && local.playwright?.chromiumInstalled);
+        const baseRuntimeReady = Boolean(agentReady && local.playwright?.chromiumInstalled);
         if (!baseRuntimeReady) {
             throw new Error(`worker_setup_preflight_failed: ${local.degradedReasons.join(', ') || 'local worker runtime is not ready'}`);
         }
@@ -4037,6 +4203,15 @@ async function enforceInstrumentBrowserHygiene(assignment, options = {}) {
     instrumentBrowserHygieneTail = result.then(() => undefined, () => undefined);
     return result;
 }
+async function finalizeInstrumentBrowserHygiene(assignment, options = {}) {
+    try {
+        const result = await enforceInstrumentBrowserHygiene(assignment, options);
+        return { ok: true, ...result };
+    }
+    catch (error) {
+        return { ok: false, error: errorMessage(error) };
+    }
+}
 function assignmentRequiresRegisteredBundle(assignment) {
     const playdropMetadata = assignment.task.metadata.playdrop;
     return Boolean(playdropMetadata
@@ -4082,15 +4257,35 @@ async function startWorker(options = {}) {
         const supervisorLock = acquireWorkerSupervisorLock({ supervisorType, workerName });
         try {
             await removeStaleAgentRunCredentials();
-            const npmVersion = probeNpmVersion();
-            const playwright = probePlaywrightChromium();
+            const startupFailures = [];
+            if (node_process_1.default.platform === 'darwin') {
+                try {
+                    const recorder = await (0, recorderRelease_1.ensureMacWorkerRecorderInstalled)();
+                    if (recorder.downloaded) {
+                        console.log(`Installed PlayDrop macOS recorder ${recorderRelease_1.MAC_WORKER_RECORDER_RELEASE.version} at ${recorder.path}.`);
+                    }
+                }
+                catch (error) {
+                    startupFailures.push(`worker_preflight_recorder_download_failed:${errorMessage(error)}`);
+                }
+            }
+            else if (node_process_1.default.platform === 'win32') {
+                console.warn('Native listing recording is not available on Windows yet.');
+            }
+            const local = collectWorkerLocalStatus();
+            startupFailures.push(...local.degradedReasons);
+            if (startupFailures.length > 0 || !local.ready || !local.capabilities || !local.playwright?.chromiumInstalled) {
+                throw formatWorkerPreflightFailure(startupFailures);
+            }
+            const npmVersion = local.npmVersion;
+            const playwright = {
+                version: local.playwright.version ?? 'unknown',
+                chromiumInstalled: true,
+                ...(local.playwright.executablePath ? { executablePath: local.playwright.executablePath } : {}),
+            };
             const workerKey = (0, config_1.getOrCreateWorkerKey)();
             const maxParallelTasks = (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_MAX_PARALLEL_TASKS', DEFAULT_WORKER_MAX_PARALLEL_TASKS);
-            let capabilities = probeReadyWorkerCapabilities({
-                npmVersion,
-                playwright,
-                maxParallelTasks,
-            });
+            let capabilities = local.capabilities;
             let lastCapabilityRefreshAt = Date.now();
             writeWorkerRuntimeState({
                 env,
@@ -4962,15 +5157,13 @@ async function startWorker(options = {}) {
                     }
                     if (agentStartedAt
                         && assignment.agent.browser !== 'NONE') {
-                        try {
-                            const hygiene = await enforceInstrumentBrowserHygiene(assignment);
+                        const hygiene = await finalizeInstrumentBrowserHygiene(assignment);
+                        if (hygiene.ok) {
                             console.log(`Agent task ${task.id} browser hygiene passed: ${hygiene.remainingTaskTabs} task tabs, ${hygiene.blankWindows} blank window(s).`);
                         }
-                        catch (hygieneError) {
-                            const error = hygieneError instanceof Error ? hygieneError : new Error(String(hygieneError));
-                            console.error(`Agent task ${task.id} browser hygiene failed: ${error.message}`);
+                        else {
+                            console.error(`Agent task ${task.id} browser hygiene failed; worker continuing: ${hygiene.error}`);
                             retainWorkspace = true;
-                            recordFatalTaskError(error);
                         }
                     }
                     activeTerminators.delete(task.id);

package/dist/recorderRelease.d.ts

@@ -0,0 +1,18 @@
+export declare const MAC_WORKER_RECORDER_RELEASE: {
+    readonly version: 1;
+    readonly architecture: "arm64";
+    readonly url: "https://assets.playdrop.ai/cli/recorder/1/darwin-arm64/playdrop-listing-recorder";
+    readonly sha256: "0a19f0613b8b69945b532d9bc75a52803cd84c5977c78da76a446ecd2d29f715";
+};
+export declare function resolveWorkerHomeDirectory(): string;
+export declare function resolveMacWorkerRecorderPath(workerHome?: string): string;
+export declare function recorderSha256(bytes: Uint8Array): string;
+export declare function ensureMacWorkerRecorderInstalled(input?: {
+    workerHome?: string;
+    download?: (url: string) => Promise<Buffer>;
+    platform?: NodeJS.Platform;
+    architecture?: string;
+}): Promise<{
+    path: string;
+    downloaded: boolean;
+}>;

package/dist/recorderRelease.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAC_WORKER_RECORDER_RELEASE = void 0;
+exports.resolveWorkerHomeDirectory = resolveWorkerHomeDirectory;
+exports.resolveMacWorkerRecorderPath = resolveMacWorkerRecorderPath;
+exports.recorderSha256 = recorderSha256;
+exports.ensureMacWorkerRecorderInstalled = ensureMacWorkerRecorderInstalled;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.MAC_WORKER_RECORDER_RELEASE = {
+    version: 1,
+    architecture: 'arm64',
+    url: 'https://assets.playdrop.ai/cli/recorder/1/darwin-arm64/playdrop-listing-recorder',
+    sha256: '0a19f0613b8b69945b532d9bc75a52803cd84c5977c78da76a446ecd2d29f715',
+};
+const MAX_RECORDER_DOWNLOAD_BYTES = 10 * 1024 * 1024;
+const RECORDER_DOWNLOAD_TIMEOUT_MS = 30000;
+function resolveWorkerHomeDirectory() {
+    const configured = process.env.PLAYDROP_WORKER_HOME?.trim();
+    return configured ? node_path_1.default.resolve(configured) : node_path_1.default.join(node_os_1.default.homedir(), 'PlayDropWorker');
+}
+function resolveMacWorkerRecorderPath(workerHome = resolveWorkerHomeDirectory()) {
+    return node_path_1.default.join(node_path_1.default.resolve(workerHome), 'tools', 'playdrop-listing-recorder');
+}
+function recorderSha256(bytes) {
+    return (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex');
+}
+async function downloadRecorder(url) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), RECORDER_DOWNLOAD_TIMEOUT_MS);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`worker_recorder_download_http_${response.status}`);
+        }
+        const bytes = Buffer.from(await response.arrayBuffer());
+        if (bytes.length === 0 || bytes.length > MAX_RECORDER_DOWNLOAD_BYTES) {
+            throw new Error(`worker_recorder_download_size_invalid:${bytes.length}`);
+        }
+        return bytes;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function ensureMacWorkerRecorderInstalled(input = {}) {
+    const platform = input.platform ?? process.platform;
+    const architecture = input.architecture ?? process.arch;
+    if (platform !== 'darwin') {
+        throw new Error(`worker_recorder_platform_unsupported:${platform}`);
+    }
+    if (architecture !== exports.MAC_WORKER_RECORDER_RELEASE.architecture) {
+        throw new Error(`worker_recorder_architecture_unsupported:${architecture}`);
+    }
+    const recorderPath = resolveMacWorkerRecorderPath(input.workerHome);
+    let installedBytes = null;
+    try {
+        installedBytes = await (0, promises_1.readFile)(recorderPath);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            throw error;
+        }
+    }
+    if (installedBytes && recorderSha256(installedBytes) === exports.MAC_WORKER_RECORDER_RELEASE.sha256) {
+        await (0, promises_1.chmod)(recorderPath, 0o755);
+        return { path: recorderPath, downloaded: false };
+    }
+    const bytes = await (input.download ?? downloadRecorder)(exports.MAC_WORKER_RECORDER_RELEASE.url);
+    const actualSha256 = recorderSha256(bytes);
+    if (actualSha256 !== exports.MAC_WORKER_RECORDER_RELEASE.sha256) {
+        throw new Error(`worker_recorder_hash_mismatch:expected=${exports.MAC_WORKER_RECORDER_RELEASE.sha256}:actual=${actualSha256}`);
+    }
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(recorderPath), { recursive: true });
+    const temporaryPath = `${recorderPath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        await (0, promises_1.writeFile)(temporaryPath, bytes, { mode: 0o755 });
+        await (0, promises_1.chmod)(temporaryPath, 0o755);
+        await (0, promises_1.rename)(temporaryPath, recorderPath);
+    }
+    finally {
+        await (0, promises_1.rm)(temporaryPath, { force: true });
+    }
+    return { path: recorderPath, downloaded: true };
+}

package/node_modules/@playdrop/config/client-meta.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.13.0",
+  "version": "0.13.2",
   "build": 1,
-  "runtimeSdkVersion": "0.13.0",
+  "runtimeSdkVersion": "0.13.2",
   "runtimeSdkBuild": 1,
   "clients": {
     "all": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playdrop/playdrop-cli",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Official Playdrop CLI for publishing browser games, creator apps, and AI-generated game assets on playdrop.ai",
   "homepage": "https://www.playdrop.ai",
   "repository": {
@@ -78,6 +78,7 @@
     "@playdrop/config": "file:../config",
     "@playdrop/types": "file:../types",
     "@playdrop/vox-three": "file:../vox-three",
+    "@playwright/mcp": "0.0.78",
     "ajv": "^8.17.1",
     "commander": "^11.1.0",
     "entities": "^6.0.0",