@playdrop/playdrop-cli 0.10.1 → 0.10.3

package/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.1",
+  "version": "0.10.3",
   "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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = validate;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const types_1 = require("@playdrop/types");
 const types_2 = require("@playdrop/types");
 const commandContext_1 = require("../commandContext");
@@ -12,6 +14,94 @@ const assetSpecs_1 = require("../assetSpecs");
 const externalAssetPackValidation_1 = require("../externalAssetPackValidation");
 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();
@@ -115,7 +205,7 @@ async function loadHostedLaunchValidationContext(workspacePath, envOverride) {
         apiBase: ctx.envConfig.apiBase,
         webBase: ctx.envConfig.webBase ?? null,
         token: ctx.token,
-        devRouterPort: (0, dev_1.resolveDevRouterPort)(process.env.PLAYDROP_DEV_ROUTER_PORT),
+        devRouterPort: resolveValidationDevRouterPort(workspacePath, Boolean(ctx.workspaceAuth?.config.taskToken)),
         taskScoped: Boolean(ctx.workspaceAuth?.config.taskToken),
     };
 }

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.1",
+  "version": "0.10.3",
   "build": 1,
   "runtimeSdkVersion": "0.10.0",
   "clients": {

package/package.json

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