@playdrop/playdrop-cli 0.10.2 → 0.10.4

package/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.2",
+  "version": "0.10.4",
   "build": 1,
   "runtimeSdkVersion": "0.10.0",
   "clients": {

package/dist/commands/capture.d.ts

@@ -3,7 +3,6 @@ type CaptureOptions = {
     appName?: string;
     logLevel?: string;
     screenshotPath?: string;
-    port?: string | number;
     surfaceTarget?: string;
     devAuth?: string;
     player?: string | number;

package/dist/commands/capture.js

@@ -121,7 +121,7 @@ function resolveCaptureDevOptions(options) {
 async function capture(targetArg, options = {}) {
     const timeoutSeconds = (0, captureRuntime_1.validateCaptureTimeout)(options.timeoutSeconds);
     const timeoutMs = Math.round(timeoutSeconds * 1000);
-    const devRouterPort = (0, dev_2.resolveDevRouterPort)(options.port ?? process.env.PLAYDROP_DEV_ROUTER_PORT);
+    const devRouterPort = (0, dev_2.resolveCliDevRouterPort)();
     let minimumLogLevel;
     let loginOverride;
     let devOptions;

package/dist/commands/dev.d.ts

@@ -2,8 +2,9 @@ export declare function formatDevRuntimeAssetManifestFailure(error: unknown): {
     message: string;
     suggestions: string[];
 };
-export declare function dev(targetArg: string | undefined, port?: number | string, appOption?: string, devOptions?: {
+export declare function dev(targetArg: string | undefined, appOption?: string, devOptions?: {
     devAuth?: string;
     player?: string | number;
 }): Promise<void>;
 export declare function resolveDevRouterPort(value: number | string | null | undefined): number;
+export declare function resolveCliDevRouterPort(env?: NodeJS.ProcessEnv): number;

package/dist/commands/dev.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatDevRuntimeAssetManifestFailure = formatDevRuntimeAssetManifestFailure;
 exports.dev = dev;
 exports.resolveDevRouterPort = resolveDevRouterPort;
+exports.resolveCliDevRouterPort = resolveCliDevRouterPort;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const types_1 = require("@playdrop/types");
@@ -134,8 +135,8 @@ function formatDevRuntimeAssetManifestFailure(error) {
         ],
     };
 }
-async function dev(targetArg, port, appOption, devOptions = {}) {
-    const devRouterPort = resolveDevRouterPort(port ?? process.env.PLAYDROP_DEV_ROUTER_PORT);
+async function dev(targetArg, appOption, devOptions = {}) {
+    const devRouterPort = resolveCliDevRouterPort();
     let resolvedTarget;
     try {
         resolvedTarget = (0, devShared_1.resolveDevTarget)(targetArg, appOption);
@@ -453,3 +454,35 @@ function resolveDevRouterPort(value) {
     }
     return parsed;
 }
+function resolveRequiredWorkerDevRouterPort(env) {
+    const raw = env.PLAYDROP_WORKER_TASK_DEV_PORT;
+    if (!raw?.trim()) {
+        throw new Error('worker_task_dev_port_missing');
+    }
+    try {
+        return resolveDevRouterPort(raw);
+    }
+    catch {
+        throw new Error(`worker_task_dev_port_invalid:${raw}`);
+    }
+}
+function resolveCliDevRouterPort(env = process.env) {
+    if (env.PLAYDROP_WORKER_CONTEXT !== '1') {
+        return devServer_1.DEV_ROUTER_PORT;
+    }
+    const workerPort = resolveRequiredWorkerDevRouterPort(env);
+    const envPortRaw = env.PLAYDROP_DEV_ROUTER_PORT;
+    if (envPortRaw?.trim()) {
+        let envPort;
+        try {
+            envPort = resolveDevRouterPort(envPortRaw);
+        }
+        catch {
+            throw new Error(`worker_task_dev_port_env_invalid:${envPortRaw}`);
+        }
+        if (envPort !== workerPort) {
+            throw new Error(`worker_task_dev_port_mismatch:env=${envPort}:worker=${workerPort}`);
+        }
+    }
+    return workerPort;
+}

package/dist/commands/validate.js

@@ -57,9 +57,37 @@ function readTaskScopedDevRouterPort(workspacePath) {
     }
     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.resolveDevRouterPort)(process.env.PLAYDROP_DEV_ROUTER_PORT);
+        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;

package/dist/commands/worker.d.ts

@@ -144,6 +144,12 @@ export declare function assertWorkerProjectVersionBumped(input: {
 }): void;
 export declare function buildAgentFailureCode(agent: AgentRuntime, result: LoggedProcessResult): string;
 export declare function describeAgentFailureForEvent(errorCode: string): string;
+export declare function createLocalPlaydropShim(input: {
+    workspaceDir: string;
+    taskId: number;
+    attempt: number;
+    devPort: number;
+}): Promise<string>;
 export declare function startWorker(options?: WorkerStartOptions): Promise<void>;
 export declare function reportTask(options: TaskReportOptions): Promise<void>;
 export declare function reportCatalogueTask(options: TaskCatalogueReportOptions): Promise<void>;

package/dist/commands/worker.js

@@ -34,6 +34,7 @@ exports.buildCataloguePreviewPayload = buildCataloguePreviewPayload;
 exports.assertWorkerProjectVersionBumped = assertWorkerProjectVersionBumped;
 exports.buildAgentFailureCode = buildAgentFailureCode;
 exports.describeAgentFailureForEvent = describeAgentFailureForEvent;
+exports.createLocalPlaydropShim = createLocalPlaydropShim;
 exports.startWorker = startWorker;
 exports.reportTask = reportTask;
 exports.reportCatalogueTask = reportCatalogueTask;
@@ -1598,12 +1599,30 @@ function normalizeWorkerFailureErrorCode(message) {
     const match = /^([a-z0-9_]+)(?::|\b)/.exec(trimmed);
     return match?.[1] ?? trimmed;
 }
-async function createLocalPlaydropShim(workspaceDir) {
-    const binDir = node_path_1.default.join(workspaceDir, 'bin');
+async function createLocalPlaydropShim(input) {
+    if (!Number.isInteger(input.taskId) || input.taskId <= 0) {
+        throw new Error('invalid_worker_task_id');
+    }
+    if (!Number.isInteger(input.attempt) || input.attempt <= 0) {
+        throw new Error('invalid_worker_task_attempt');
+    }
+    if (!Number.isInteger(input.devPort) || input.devPort <= 0 || input.devPort > 65535) {
+        throw new Error('invalid_worker_task_dev_port');
+    }
+    const binDir = node_path_1.default.join(input.workspaceDir, 'bin');
     await (0, promises_1.mkdir)(binDir, { recursive: true });
     const cliEntrypoint = node_path_1.default.resolve(node_process_1.default.argv[1] ?? node_path_1.default.join(__dirname, '..', 'index.js'));
     const shimPath = node_path_1.default.join(binDir, 'playdrop');
-    await (0, promises_1.writeFile)(shimPath, `#!/bin/sh\nexec ${JSON.stringify(node_process_1.default.execPath)} ${JSON.stringify(cliEntrypoint)} "$@"\n`, 'utf8');
+    await (0, promises_1.writeFile)(shimPath, [
+        '#!/bin/sh',
+        'export PLAYDROP_WORKER_CONTEXT=1',
+        `export PLAYDROP_WORKER_TASK_ID=${JSON.stringify(String(input.taskId))}`,
+        `export PLAYDROP_WORKER_TASK_ATTEMPT=${JSON.stringify(String(input.attempt))}`,
+        `export PLAYDROP_WORKER_TASK_DEV_PORT=${JSON.stringify(String(input.devPort))}`,
+        `export PLAYDROP_DEV_ROUTER_PORT=${JSON.stringify(String(input.devPort))}`,
+        `exec ${JSON.stringify(node_process_1.default.execPath)} ${JSON.stringify(cliEntrypoint)} "$@"`,
+        '',
+    ].join('\n'), 'utf8');
     await (0, promises_1.chmod)(shimPath, 0o755);
     return binDir;
 }
@@ -1854,13 +1873,18 @@ async function startWorker(options = {}) {
                 await (0, promises_1.mkdir)(workspaceDir, { recursive: true });
                 const eventDir = node_path_1.default.join(workspaceDir, '.playdrop-task-events');
                 await (0, promises_1.mkdir)(eventDir, { recursive: true });
-                const binDir = await createLocalPlaydropShim(workspaceDir);
                 await stageWorkerTaskContext({
                     workspaceDir,
                     env,
                     devPort,
                     taskContext,
                 });
+                const binDir = await createLocalPlaydropShim({
+                    workspaceDir,
+                    taskId: taskContext.taskId,
+                    attempt: taskContext.attempt,
+                    devPort,
+                });
                 const handleEventDrainFailure = (error) => {
                     const classification = classifyWorkerEventDrainError(error);
                     if (classification === 'session_expired') {

package/dist/index.js

@@ -911,11 +911,10 @@ project
     .command('dev [target]')
     .description('Run an app locally')
     .option('--app <name>', 'App name when the target is a workspace')
-    .option('--port <number>', 'Local dev router port')
     .option('--dev-auth <mode>', 'prompt, anonymous, viewer, or player')
     .option('--player <slot>', '1, 2, 3, or 4 when --dev-auth player is selected')
     .action(async (target, opts = {}) => {
-    await (0, dev_1.dev)(target, opts.port, opts.app, {
+    await (0, dev_1.dev)(target, opts.app, {
         devAuth: opts.devAuth,
         player: opts.player,
     });
@@ -937,7 +936,6 @@ const projectCapture = project.command('capture').description('Run a Playwright
 projectCapture
     .argument('[target]')
     .option('--app <name>', 'App name when the target is a workspace')
-    .option('--port <number>', 'Local dev router port')
     .option('--timeout <seconds>', 'Capture timeout in seconds')
     .option('--log-level <level>', 'debug, info, warn, or error')
     .option('--screenshot <path>', 'Screenshot output path')
@@ -952,7 +950,6 @@ projectCapture
     await (0, capture_1.capture)(target, {
         timeoutSeconds,
         appName: opts.app,
-        port: opts.port,
         logLevel: opts.logLevel,
         screenshotPath: opts.screenshot,
         surfaceTarget: opts.surface,

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

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.2",
+  "version": "0.10.4",
   "build": 1,
   "runtimeSdkVersion": "0.10.0",
   "clients": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playdrop/playdrop-cli",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Official Playdrop CLI for publishing browser games, creator apps, and AI-generated game assets on playdrop.ai",
   "homepage": "https://www.playdrop.ai",
   "repository": {