@playdrop/playdrop-cli 0.10.6 → 0.10.7

package/dist/commands/worker.js

@@ -35,6 +35,11 @@ exports.assertWorkerProjectVersionBumped = assertWorkerProjectVersionBumped;
 exports.buildAgentFailureCode = buildAgentFailureCode;
 exports.describeAgentFailureForEvent = describeAgentFailureForEvent;
 exports.createLocalPlaydropShim = createLocalPlaydropShim;
+exports.readActivePersonalWorkerRuntimeState = readActivePersonalWorkerRuntimeState;
+exports.parseLaunchAgentProgramArguments = parseLaunchAgentProgramArguments;
+exports.assertLaunchAgentPlistCompatible = assertLaunchAgentPlistCompatible;
+exports.showWorkerStatus = showWorkerStatus;
+exports.setupWorker = setupWorker;
 exports.startWorker = startWorker;
 exports.reportTask = reportTask;
 exports.reportCatalogueTask = reportCatalogueTask;
@@ -59,6 +64,7 @@ const output_1 = require("../output");
 const shellProbe_1 = require("../shellProbe");
 const upload_1 = require("./upload");
 const review_1 = require("./review");
+const agents_1 = require("./agents");
 const runtime_1 = require("./worker/runtime");
 var runtime_2 = require("./worker/runtime");
 Object.defineProperty(exports, "DEFAULT_CODEX_TIMEOUT_MS", { enumerable: true, get: function () { return runtime_2.DEFAULT_CODEX_TIMEOUT_MS; } });
@@ -83,6 +89,7 @@ const CLAIM_BACKOFF_JITTER_MS = 500;
 const FAIL_REPORT_RETRY_DELAY_MS = 2000;
 const WORKER_TRANSCRIPT_CHUNK_BATCH_SIZE = 100;
 const SLACK_API_BASE_URL = 'https://slack.com/api';
+const WORKER_WRAPPER_CONTRACT_VERSION = 1;
 const WORKER_SUPPORTED_KINDS = ['NEW_GAME', 'GAME_UPDATE', 'GAME_REVIEW'];
 const requireFromWorker = (0, node_module_1.createRequire)(__filename);
 const PLAYDROP_PLUGIN_DAEMON_GAME_CREATION_SKILL_PATH = 'skills/daemon-game-creation/SKILL.md';
@@ -209,7 +216,7 @@ function normalizeAssignmentWorkspaceFolder(value) {
     return folderName;
 }
 function normalizeAssignmentAgent(value) {
-    if (value !== 'CODEX' && value !== 'CLAUDE_CODE') {
+    if (value !== 'CODEX' && value !== 'CLAUDE_CODE' && value !== 'CURSOR_COMPOSER') {
         throw new Error('agent_task_assignment_agent_missing');
     }
     return value;
@@ -999,6 +1006,8 @@ function buildWorkerCapabilities(input) {
     const codexAuthenticated = typeof input === 'string' ? true : input.codexAuthenticated === true;
     const claudeVersion = typeof input === 'string' ? null : input.claudeVersion?.trim() || null;
     const claudeAuthenticated = typeof input === 'string' ? false : input.claudeAuthenticated === true;
+    const cursorVersion = typeof input === 'string' ? null : input.cursorVersion?.trim() || null;
+    const cursorAuthenticated = typeof input === 'string' ? false : input.cursorAuthenticated === true;
     const npmVersion = typeof input === 'string' ? null : input.npmVersion?.trim() || null;
     const playwright = typeof input === 'string' ? null : input.playwright ?? null;
     const maxParallelTasks = typeof input === 'string'
@@ -1031,8 +1040,21 @@ function buildWorkerCapabilities(input) {
             ready: claudeAuthenticated,
         });
     }
+    if (cursorVersion) {
+        degradedReasons.push('cursor_runner_not_configured');
+        if (!cursorAuthenticated) {
+            degradedReasons.push('cursor_not_authenticated');
+        }
+        agents.push({
+            agent: 'CURSOR_COMPOSER',
+            cliVersion: cursorVersion,
+            authenticated: cursorAuthenticated,
+            models: [],
+            ready: false,
+        });
+    }
     if (agents.length === 0) {
-        throw new Error('agent_cli_not_found: install and authenticate Codex or Claude Code before starting a PlayDrop worker.');
+        throw new Error('agent_cli_not_found: install and authenticate Codex, Claude Code, or Cursor before starting a PlayDrop worker.');
     }
     return {
         agent: agents[0].agent,
@@ -1044,6 +1066,7 @@ function buildWorkerCapabilities(input) {
         agents,
         ready: agents.some((agent) => agent.ready === true),
         degradedReasons,
+        wrapperContractVersion: (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_WRAPPER_CONTRACT_VERSION', WORKER_WRAPPER_CONTRACT_VERSION),
         ...(npmVersion ? { npmVersion } : {}),
         ...(playwright ? { playwright } : {}),
         os: node_process_1.default.platform,
@@ -1655,10 +1678,762 @@ function probeClaudeInstallation() {
     }
     return { claudeVersion: match[1] };
 }
+function probeCursorInstallation() {
+    if (!(0, runtime_1.readEnvBoolean)('PLAYDROP_WORKER_ENABLE_CURSOR', false)) {
+        return null;
+    }
+    const command = node_process_1.default.env.PLAYDROP_WORKER_CURSOR_COMMAND?.trim() || 'cursor';
+    const probe = (0, shellProbe_1.runShell)((0, shellProbe_1.buildCommandPathProbe)(command));
+    if (probe.exitCode !== 0 || !probe.output.trim()) {
+        throw new Error(`worker_preflight_cursor_missing: ${command} was not found. Disable PLAYDROP_WORKER_ENABLE_CURSOR or install the configured Cursor command.`);
+    }
+    const versionResult = (0, shellProbe_1.runShell)(`${command} --version`);
+    const version = versionResult.output.trim().split(/\r?\n/)[0]?.trim() || '';
+    if (!version || versionResult.exitCode !== 0) {
+        throw new Error(`cursor_version_check_failed: "${command} --version" exited with code ${versionResult.exitCode} and reported no version. Output: ${versionResult.output.slice(0, 200)}`);
+    }
+    return { cursorVersion: version };
+}
 function readClaudeAuthenticated() {
     const status = (0, shellProbe_1.runShell)('claude auth status --text');
     return status.exitCode === 0;
 }
+function readCursorAuthenticated() {
+    return (0, runtime_1.readEnvBoolean)('PLAYDROP_WORKER_CURSOR_AUTHENTICATED', false);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function errorCode(error) {
+    return errorMessage(error).split(':')[0]?.trim() || 'unknown_error';
+}
+function readPlaydropPluginVersion(pluginRoot) {
+    for (const relativePath of ['.codex-plugin/plugin.json', 'plugin.json', 'package.json']) {
+        try {
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(pluginRoot, relativePath), 'utf8'));
+            const version = typeof parsed.version === 'string' ? parsed.version.trim() : '';
+            if (version) {
+                return version;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function collectWorkerLocalStatus() {
+    const degradedReasons = [];
+    let codexVersion = null;
+    let claudeVersion = null;
+    let cursorVersion = null;
+    let npmVersion = null;
+    let playwright = null;
+    let pluginRoot = null;
+    let pluginVersion = null;
+    let pluginError = null;
+    try {
+        codexVersion = probeCodexInstallation()?.codexVersion ?? null;
+    }
+    catch (error) {
+        degradedReasons.push(errorCode(error));
+    }
+    try {
+        claudeVersion = probeClaudeInstallation()?.claudeVersion ?? null;
+    }
+    catch (error) {
+        degradedReasons.push(errorCode(error));
+    }
+    try {
+        cursorVersion = probeCursorInstallation()?.cursorVersion ?? null;
+    }
+    catch (error) {
+        degradedReasons.push(errorCode(error));
+    }
+    try {
+        npmVersion = probeNpmVersion();
+    }
+    catch (error) {
+        degradedReasons.push(errorCode(error));
+    }
+    try {
+        playwright = probePlaywrightChromium();
+    }
+    catch (error) {
+        degradedReasons.push(errorCode(error));
+    }
+    try {
+        pluginRoot = resolvePlaydropPluginRoot();
+        pluginVersion = readPlaydropPluginVersion(pluginRoot);
+    }
+    catch (error) {
+        pluginError = errorMessage(error);
+        degradedReasons.push(errorCode(error));
+    }
+    let capabilities = null;
+    try {
+        capabilities = buildWorkerCapabilities({
+            codexVersion,
+            codexAuthenticated: codexVersion ? readCodexAuthenticated() : false,
+            claudeVersion,
+            claudeAuthenticated: claudeVersion ? readClaudeAuthenticated() : false,
+            cursorVersion,
+            cursorAuthenticated: cursorVersion ? readCursorAuthenticated() : false,
+            npmVersion,
+            playwright,
+            runningTaskCount: 0,
+            maxParallelTasks: (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_MAX_PARALLEL_TASKS', DEFAULT_WORKER_MAX_PARALLEL_TASKS),
+        });
+        if (pluginVersion) {
+            capabilities.pluginVersion = pluginVersion;
+            for (const agent of capabilities.agents) {
+                agent.pluginVersion = pluginVersion;
+            }
+        }
+        for (const reason of capabilities.degradedReasons ?? []) {
+            degradedReasons.push(reason);
+        }
+    }
+    catch (error) {
+        degradedReasons.push(errorCode(error));
+    }
+    const uniqueReasons = Array.from(new Set(degradedReasons));
+    const pluginReady = Boolean(pluginRoot && !pluginError);
+    const infrastructureReady = Boolean(npmVersion && playwright?.chromiumInstalled && pluginReady);
+    const ready = Boolean(capabilities?.ready) && infrastructureReady;
+    return {
+        ready,
+        degradedReasons: ready ? [] : uniqueReasons,
+        cliVersion: (0, clientInfo_1.getCliVersion)(),
+        nodeVersion: node_process_1.default.versions.node,
+        npmVersion,
+        playwright,
+        plugin: {
+            ready: pluginReady,
+            root: pluginRoot,
+            version: pluginVersion,
+            error: pluginError,
+        },
+        agents: capabilities?.agents ?? [],
+        capabilities,
+    };
+}
+function getWorkerStateDir() {
+    return node_path_1.default.join(node_os_1.default.homedir(), '.playdrop', 'worker');
+}
+function workerRuntimeStateFilePath(target) {
+    const normalizedTarget = target === 'FIRST_PARTY' ? 'first-party' : 'personal';
+    return node_path_1.default.join(getWorkerStateDir(), `${normalizedTarget}-runtime.json`);
+}
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        node_process_1.default.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        return code === 'EPERM';
+    }
+}
+function writeWorkerRuntimeState(state) {
+    const file = workerRuntimeStateFilePath(state.target);
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(file), { recursive: true });
+    (0, node_fs_1.writeFileSync)(file, JSON.stringify({
+        schemaVersion: 1,
+        pid: node_process_1.default.pid,
+        startedAt: new Date().toISOString(),
+        ...state,
+    }, null, 2));
+}
+function clearWorkerRuntimeState(target) {
+    (0, node_fs_1.rmSync)(workerRuntimeStateFilePath(target), { force: true });
+}
+function readActivePersonalWorkerRuntimeState() {
+    const file = workerRuntimeStateFilePath('PERSONAL');
+    let parsed;
+    try {
+        parsed = JSON.parse((0, node_fs_1.readFileSync)(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || parsed.target !== 'PERSONAL' || !isProcessAlive(parsed.pid)) {
+        return null;
+    }
+    return parsed;
+}
+function getManagedWorkerPolicyFilePath(env, workerKey) {
+    return node_path_1.default.join(getWorkerStateDir(), `update-policy-${env}-${workerKey}.json`);
+}
+function writeManagedWorkerUpdatePolicyFile(input) {
+    if (!input.updatePolicy) {
+        return;
+    }
+    const policyFile = getManagedWorkerPolicyFilePath(input.env, input.workerKey);
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(policyFile), { recursive: true });
+    (0, node_fs_1.writeFileSync)(policyFile, JSON.stringify({
+        schemaVersion: 1,
+        writtenAt: new Date().toISOString(),
+        targetCliVersion: input.updatePolicy.targetCliVersion,
+        minimumCliVersion: input.updatePolicy.minimumCliVersion,
+        targetPluginVersion: input.updatePolicy.targetPluginVersion,
+        minimumPluginVersion: input.updatePolicy.minimumPluginVersion,
+        managedAgentCliVersions: input.updatePolicy.managedAgentCliVersions ?? {},
+        requiredWrapperContractVersion: input.updatePolicy.requiredWrapperContractVersion,
+    }, null, 2));
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function validatePackageVersion(value, label) {
+    const version = typeof value === 'string' ? value.trim() : '';
+    if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+        throw new Error(`${label}_invalid:${version || 'missing'}`);
+    }
+    return version;
+}
+function verifyNpmGlobalInstallPreconditions() {
+    const prefixProbe = (0, shellProbe_1.runShell)('npm prefix -g');
+    const prefix = prefixProbe.output.trim().split(/\r?\n/)[0]?.trim() ?? '';
+    if (prefixProbe.exitCode !== 0 || !prefix) {
+        throw new Error(`worker_update_npm_prefix_unavailable: npm prefix -g exited with code ${prefixProbe.exitCode}.`);
+    }
+    const writeProbe = (0, shellProbe_1.runShell)(`[ -w ${shellQuote(prefix)} ]`);
+    if (writeProbe.exitCode !== 0) {
+        throw new Error(`worker_update_npm_prefix_not_writable: ${prefix} is not writable by ${node_os_1.default.userInfo().username}. Install Node with a user-writable global prefix before enabling managed worker updates.`);
+    }
+    return { prefix };
+}
+function managedWorkerWrapperPath(env) {
+    return node_path_1.default.join(getWorkerStateDir(), `playdrop-worker-${env}.sh`);
+}
+function managedWorkerLaunchAgentLabel(env) {
+    return `ai.playdrop.worker.${env}`;
+}
+function managedWorkerLaunchAgentPath(env) {
+    return node_path_1.default.join(node_os_1.default.homedir(), 'Library', 'LaunchAgents', `${managedWorkerLaunchAgentLabel(env)}.plist`);
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function unescapeXml(value) {
+    return value
+        .replace(/&apos;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&gt;/g, '>')
+        .replace(/&lt;/g, '<')
+        .replace(/&amp;/g, '&');
+}
+function parseLaunchAgentProgramArguments(plist) {
+    const arrayMatch = /<key>\s*ProgramArguments\s*<\/key>\s*<array>([\s\S]*?)<\/array>/i.exec(plist);
+    if (!arrayMatch?.[1]) {
+        return [];
+    }
+    return Array.from(arrayMatch[1].matchAll(/<string>([\s\S]*?)<\/string>/gi))
+        .map((match) => unescapeXml(match[1].trim()))
+        .filter(Boolean);
+}
+function readLaunchAgentArguments(plistPath) {
+    return parseLaunchAgentProgramArguments((0, node_fs_1.readFileSync)(plistPath, 'utf8'));
+}
+function readArgumentValue(args, flag) {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === flag) {
+            return args[index + 1] ?? null;
+        }
+        if (arg.startsWith(`${flag}=`)) {
+            return arg.slice(flag.length + 1);
+        }
+    }
+    return null;
+}
+function isPlaydropWorkerStartCommand(args) {
+    const joined = args.join(' ');
+    return /\bplaydrop\b/.test(joined) && args.includes('worker') && args.includes('start');
+}
+function isCompatibleLegacyWorkerLaunchAgent(input) {
+    if (!isPlaydropWorkerStartCommand(input.args)) {
+        return false;
+    }
+    return readArgumentValue(input.args, '--env') === input.env
+        && readArgumentValue(input.args, '--name') === input.workerName;
+}
+function assertLaunchAgentArgumentsCompatible(input) {
+    const normalizedPlistPath = node_path_1.default.resolve(input.plistPath);
+    const normalizedCanonicalPath = node_path_1.default.resolve(input.canonicalPlistPath);
+    if (normalizedPlistPath === normalizedCanonicalPath) {
+        if (input.args.length === 1 && input.args[0] === input.wrapperPath) {
+            return;
+        }
+        throw new Error(`worker_supervisor_conflict: ${input.plistPath} already exists but does not point at the managed PlayDrop worker wrapper ${input.wrapperPath}. Refusing to overwrite it.`);
+    }
+    if (!isPlaydropWorkerStartCommand(input.args) && input.args[0] !== input.wrapperPath) {
+        return;
+    }
+    if (input.args[0] === input.wrapperPath
+        || isCompatibleLegacyWorkerLaunchAgent({
+            args: input.args,
+            env: input.env,
+            workerName: input.workerName,
+        })) {
+        return;
+    }
+    throw new Error(`worker_supervisor_conflict: ${input.plistPath} appears to manage a different PlayDrop worker. Refusing to install a second supervisor.`);
+}
+function assertLaunchAgentPlistCompatible(input) {
+    assertLaunchAgentArgumentsCompatible({
+        plistPath: input.plistPath,
+        args: parseLaunchAgentProgramArguments(input.plist),
+        env: input.env,
+        workerName: input.workerName,
+        wrapperPath: input.wrapperPath,
+        canonicalPlistPath: input.canonicalPlistPath,
+    });
+}
+function assertNoSupervisorConflicts(input) {
+    const launchAgentsDir = node_path_1.default.dirname(input.canonicalPlistPath);
+    if ((0, node_fs_1.existsSync)(input.canonicalPlistPath)) {
+        assertLaunchAgentArgumentsCompatible({
+            ...input,
+            plistPath: input.canonicalPlistPath,
+            args: readLaunchAgentArguments(input.canonicalPlistPath),
+        });
+    }
+    if (!(0, node_fs_1.existsSync)(launchAgentsDir)) {
+        return;
+    }
+    for (const entry of (0, node_fs_1.readdirSync)(launchAgentsDir)) {
+        if (!entry.endsWith('.plist')) {
+            continue;
+        }
+        const plistPath = node_path_1.default.join(launchAgentsDir, entry);
+        if (node_path_1.default.resolve(plistPath) === node_path_1.default.resolve(input.canonicalPlistPath)) {
+            continue;
+        }
+        let args;
+        try {
+            args = readLaunchAgentArguments(plistPath);
+        }
+        catch {
+            continue;
+        }
+        assertLaunchAgentArgumentsCompatible({
+            ...input,
+            plistPath,
+            args,
+        });
+    }
+}
+async function writeManagedWorkerWrapper(input) {
+    const wrapperPath = managedWorkerWrapperPath(input.env);
+    const policyFile = getManagedWorkerPolicyFilePath(input.env, input.workerKey);
+    const failureFile = node_path_1.default.join(getWorkerStateDir(), `update-failure-${input.env}-${input.workerKey}.json`);
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(wrapperPath), { recursive: true });
+    const script = `#!/bin/sh
+set -eu
+
+export PLAYDROP_WORKER_WRAPPER_CONTRACT_VERSION="${WORKER_WRAPPER_CONTRACT_VERSION}"
+POLICY_FILE="${policyFile}"
+FAILURE_FILE="${failureFile}"
+BACKOFF_SECONDS="\${PLAYDROP_WORKER_UPDATE_FAILURE_BACKOFF_SECONDS:-30}"
+
+record_failure() {
+  node - "$FAILURE_FILE" "$1" <<'NODE'
+const fs = require("fs");
+const path = require("path");
+const file = process.argv[2];
+const error = process.argv[3] || "worker_update_install_failed";
+fs.mkdirSync(path.dirname(file), { recursive: true });
+fs.writeFileSync(file, JSON.stringify({
+  schemaVersion: 1,
+  writtenAt: new Date().toISOString(),
+  error,
+}, null, 2));
+NODE
+}
+
+fail_converge() {
+  code="$1"
+  reason="$2"
+  record_failure "$reason"
+  sleep "$BACKOFF_SECONDS"
+  exit "$code"
+}
+
+run_or_fail() {
+  reason="$1"
+  shift
+  "$@" || fail_converge "$?" "$reason"
+}
+
+validate_policy_file() {
+  if [ ! -f "$POLICY_FILE" ]; then
+    return 0
+  fi
+  node - "$POLICY_FILE" <<'NODE' || fail_converge "$?" "worker_update_policy_unavailable"
+const fs = require("fs");
+const file = process.argv[2];
+try {
+  const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    process.exit(1);
+  }
+} catch {
+  process.exit(1);
+}
+NODE
+}
+
+read_policy_value() {
+  node -e 'const fs = require("fs"); const file = process.argv[1]; const key = process.argv[2]; if (!fs.existsSync(file)) process.exit(0); const policy = JSON.parse(fs.readFileSync(file, "utf8")); const value = policy && policy[key]; if (typeof value === "string") process.stdout.write(value);' "$POLICY_FILE" "$1"
+}
+
+validate_policy_file
+TARGET_CLI_VERSION="$(read_policy_value targetCliVersion)"
+TARGET_PLUGIN_VERSION="$(read_policy_value targetPluginVersion)"
+
+if [ -n "$TARGET_CLI_VERSION" ]; then
+  run_or_fail "worker_update_cli_install_failed" npm install -g --no-audit --no-fund "@playdrop/playdrop-cli@$TARGET_CLI_VERSION"
+fi
+
+if [ -n "$TARGET_PLUGIN_VERSION" ]; then
+  if command -v codex >/dev/null 2>&1; then
+    run_or_fail "worker_update_plugin_install_failed:codex" playdrop agents update-plugin codex
+  fi
+  if command -v claude >/dev/null 2>&1; then
+    run_or_fail "worker_update_plugin_install_failed:claude" playdrop agents update-plugin claude
+  fi
+  node - "$TARGET_PLUGIN_VERSION" <<'NODE' || fail_converge "$?" "worker_update_plugin_version_mismatch"
+const childProcess = require("child_process");
+const targetVersion = process.argv[2];
+const result = childProcess.spawnSync("playdrop", ["agents", "status", "--json"], { encoding: "utf8" });
+if (result.status !== 0) {
+  process.exit(1);
+}
+let parsed;
+try {
+  parsed = JSON.parse(result.stdout);
+} catch {
+  process.exit(1);
+}
+const agents = Array.isArray(parsed && parsed.agents) ? parsed.agents : [];
+const checked = agents.filter((agent) => agent && agent.id !== "cursor" && agent.cli && agent.cli.installed);
+for (const agent of checked) {
+  const version = agent && agent.plugin && typeof agent.plugin.version === "string" ? agent.plugin.version.trim() : "";
+  if (version !== targetVersion) {
+    process.exit(1);
+  }
+}
+NODE
+fi
+
+node - "$POLICY_FILE" <<'NODE' || fail_converge "$?" "worker_update_agent_cli_install_failed"
+const childProcess = require("child_process");
+const fs = require("fs");
+
+const policyFile = process.argv[2];
+if (!policyFile || !fs.existsSync(policyFile)) {
+  process.exit(0);
+}
+const policy = JSON.parse(fs.readFileSync(policyFile, "utf8"));
+const versions = policy && policy.managedAgentCliVersions && typeof policy.managedAgentCliVersions === "object"
+  ? policy.managedAgentCliVersions
+  : {};
+const packages = {
+  CODEX: "@openai/codex",
+  CLAUDE_CODE: "@anthropic-ai/claude-code",
+};
+const aliases = {
+  CODEX: "CODEX",
+  OPENAI_CODEX: "CODEX",
+  CLAUDE: "CLAUDE_CODE",
+  CLAUDE_CODE: "CLAUDE_CODE",
+  CURSOR: "CURSOR_COMPOSER",
+  CURSOR_COMPOSER: "CURSOR_COMPOSER",
+};
+for (const [rawKey, rawVersion] of Object.entries(versions)) {
+  const version = typeof rawVersion === "string" ? rawVersion.trim() : "";
+  if (!/^\\d+\\.\\d+\\.\\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+    throw new Error(\`worker_update_agent_cli_version_invalid:\${rawKey}\`);
+  }
+  const normalizedKey = aliases[String(rawKey).trim().toUpperCase().replace(/[-\\s]+/g, "_")];
+  if (normalizedKey === "CURSOR_COMPOSER") {
+    throw new Error("worker_update_cursor_cli_auto_update_unsupported");
+  }
+  const packageName = normalizedKey ? packages[normalizedKey] : null;
+  if (!packageName) {
+    throw new Error(\`worker_update_agent_cli_unknown:\${rawKey}\`);
+  }
+  const result = childProcess.spawnSync(
+    "npm",
+    ["install", "-g", "--no-audit", "--no-fund", \`\${packageName}@\${version}\`],
+    { stdio: "inherit" },
+  );
+  if (result.status !== 0) {
+    throw new Error(\`worker_update_agent_cli_install_failed:\${normalizedKey}\`);
+  }
+}
+NODE
+
+exec playdrop worker start --env ${shellQuote(input.env)} --name ${shellQuote(input.workerName)}
+`;
+    await (0, promises_1.writeFile)(wrapperPath, script, 'utf8');
+    await (0, promises_1.chmod)(wrapperPath, 0o755);
+    return { wrapperPath, policyFile };
+}
+async function writeManagedWorkerLaunchAgent(input) {
+    if (node_process_1.default.platform !== 'darwin') {
+        throw new Error('worker_setup_launchagent_unsupported: managed worker setup currently supports macOS LaunchAgent only.');
+    }
+    const label = managedWorkerLaunchAgentLabel(input.env);
+    const plistPath = managedWorkerLaunchAgentPath(input.env);
+    const logDir = node_path_1.default.join(getWorkerStateDir(), 'logs');
+    assertNoSupervisorConflicts({
+        env: input.env,
+        workerName: input.workerName,
+        wrapperPath: input.wrapperPath,
+        canonicalPlistPath: plistPath,
+    });
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(plistPath), { recursive: true });
+    await (0, promises_1.mkdir)(logDir, { recursive: true });
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(input.wrapperPath)}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PLAYDROP_WORKER_WRAPPER_CONTRACT_VERSION</key>
+    <string>${WORKER_WRAPPER_CONTRACT_VERSION}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(node_path_1.default.join(logDir, `${label}.out.log`))}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(node_path_1.default.join(logDir, `${label}.err.log`))}</string>
+</dict>
+</plist>
+`;
+    await (0, promises_1.writeFile)(plistPath, plist, 'utf8');
+    return { label, plistPath };
+}
+function launchManagedWorker(label, plistPath) {
+    const uid = typeof node_process_1.default.getuid === 'function' ? node_process_1.default.getuid() : null;
+    if (uid === null) {
+        throw new Error('worker_setup_launchagent_uid_unavailable');
+    }
+    const domain = `gui/${uid}`;
+    const bootstrap = (0, shellProbe_1.runShell)(`launchctl bootstrap ${shellQuote(domain)} ${shellQuote(plistPath)}`);
+    if (bootstrap.exitCode !== 0 && !/already|exists|service name is already registered/i.test(bootstrap.output)) {
+        throw new Error(`worker_setup_launchagent_start_failed: launchctl bootstrap exited with code ${bootstrap.exitCode}. ${bootstrap.output.slice(0, 300)}`);
+    }
+    const kickstart = (0, shellProbe_1.runShell)(`launchctl kickstart -k ${shellQuote(`${domain}/${label}`)}`);
+    if (kickstart.exitCode !== 0) {
+        throw new Error(`worker_setup_launchagent_start_failed: launchctl kickstart exited with code ${kickstart.exitCode}. ${kickstart.output.slice(0, 300)}`);
+    }
+}
+async function runPluginSetupAction(action, agent) {
+    const previousExitCode = node_process_1.default.exitCode;
+    node_process_1.default.exitCode = undefined;
+    try {
+        if (action === 'install') {
+            await (0, agents_1.installPlugin)(agent);
+        }
+        else {
+            await (0, agents_1.updatePlugin)(agent);
+        }
+        if (node_process_1.default.exitCode && node_process_1.default.exitCode !== 0) {
+            throw new Error(`worker_setup_plugin_${action}_failed:${agent}`);
+        }
+    }
+    finally {
+        node_process_1.default.exitCode = previousExitCode;
+    }
+}
+async function ensurePlaydropPluginsForSetup(local) {
+    for (const agent of local.agents) {
+        if (agent.agent === 'CODEX') {
+            await runPluginSetupAction(local.plugin.ready ? 'update' : 'install', 'codex');
+        }
+        else if (agent.agent === 'CLAUDE_CODE') {
+            await runPluginSetupAction(local.plugin.ready ? 'update' : 'install', 'claude');
+        }
+    }
+}
+async function resolveWorkerStatusPayload(options = {}) {
+    loadWorkerEnvFile(options.env);
+    const local = collectWorkerLocalStatus();
+    const server = {
+        reachable: false,
+        authenticated: false,
+        worker: null,
+    };
+    let ctx;
+    try {
+        ctx = await (0, commandContext_1.resolveOptionalEnvironmentContext)('worker status', { env: options.env });
+    }
+    catch (error) {
+        return {
+            schemaVersion: 1,
+            generatedAt: new Date().toISOString(),
+            local,
+            server: {
+                ...server,
+                error: errorCode(error),
+            },
+        };
+    }
+    if (!ctx?.token) {
+        return {
+            schemaVersion: 1,
+            generatedAt: new Date().toISOString(),
+            local,
+            server: {
+                ...server,
+                error: 'not_authenticated',
+            },
+        };
+    }
+    server.authenticated = true;
+    const workerKey = (0, config_1.loadConfig)().workerKey?.trim() ?? '';
+    try {
+        const workers = await ctx.client.listMyAgentWorkers();
+        server.reachable = true;
+        server.worker = workerKey
+            ? workers.workers.find((worker) => worker.workerKey === workerKey) ?? null
+            : null;
+    }
+    catch (error) {
+        server.error = errorCode(error);
+    }
+    return {
+        schemaVersion: 1,
+        generatedAt: new Date().toISOString(),
+        local,
+        server,
+    };
+}
+function printWorkerStatus(payload) {
+    console.log(`Local worker: ${payload.local.ready ? 'ready' : 'degraded'}`);
+    console.log(`  CLI: ${payload.local.cliVersion}`);
+    console.log(`  Node: ${payload.local.nodeVersion}`);
+    console.log(`  npm: ${payload.local.npmVersion ?? 'missing'}`);
+    console.log(`  PlayDrop plugin: ${payload.local.plugin.ready ? payload.local.plugin.version ?? payload.local.plugin.root ?? 'installed' : 'missing'}`);
+    if (payload.local.agents.length > 0) {
+        for (const agent of payload.local.agents) {
+            console.log(`  ${agent.agent}: ${agent.ready ? 'ready' : 'degraded'} ${agent.cliVersion ?? ''}`.trimEnd());
+        }
+    }
+    else {
+        console.log('  Agents: none detected');
+    }
+    if (payload.local.degradedReasons.length > 0) {
+        console.log(`  Reasons: ${payload.local.degradedReasons.join(', ')}`);
+    }
+    if (!payload.server.authenticated) {
+        console.log('Server worker: not authenticated');
+    }
+    else if (!payload.server.reachable) {
+        console.log(`Server worker: unreachable${payload.server.error ? ` (${payload.server.error})` : ''}`);
+    }
+    else if (!payload.server.worker) {
+        console.log('Server worker: none registered');
+    }
+    else {
+        console.log(`Server worker: ${payload.server.worker.name} (${payload.server.worker.lifecycleState ?? 'unknown'}, ${payload.server.worker.updateState ?? 'unknown'})`);
+    }
+}
+async function showWorkerStatus(options = {}) {
+    const payload = await resolveWorkerStatusPayload(options);
+    if (options.json) {
+        (0, output_1.printJson)(payload);
+    }
+    else {
+        printWorkerStatus(payload);
+    }
+    return payload;
+}
+async function setupWorker(options = {}) {
+    loadWorkerEnvFile(options.env);
+    await (0, commandContext_1.withEnvironment)('worker setup', 'Setting up the PlayDrop worker', async ({ client, env }) => {
+        const me = await client.me();
+        const username = me.user?.username?.trim();
+        if (!username) {
+            throw new Error('worker_session_invalid: the stored session did not resolve to a user. Run "playdrop auth login" and retry.');
+        }
+        const target = resolveWorkerExecutionTargetFromRole(me.user.role);
+        const workerKey = (0, config_1.getOrCreateWorkerKey)();
+        const explicitWorkerName = options.name?.trim() || '';
+        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);
+        if (!baseRuntimeReady) {
+            throw new Error(`worker_setup_preflight_failed: ${local.degradedReasons.join(', ') || 'local worker runtime is not ready'}`);
+        }
+        await ensurePlaydropPluginsForSetup(local);
+        const postPluginLocal = collectWorkerLocalStatus();
+        if (!postPluginLocal.plugin.ready) {
+            throw new Error(`worker_setup_plugin_unavailable: ${postPluginLocal.plugin.error ?? 'PlayDrop plugin could not be verified after setup'}`);
+        }
+        if (target !== 'FIRST_PARTY') {
+            (0, output_1.printSuccess)('Personal worker setup complete.', [
+                'Run: playdrop worker start --supervise-stdin',
+            ]);
+            return;
+        }
+        if (!options.env?.trim()) {
+            throw new Error('worker_setup_requires_env: admin worker setup must pass --env <env> so the LaunchAgent cannot be installed for the wrong environment.');
+        }
+        if (!explicitWorkerName) {
+            throw new Error('worker_setup_requires_name: admin worker setup must pass --name <worker name> so the LaunchAgent identity is deterministic.');
+        }
+        verifyNpmGlobalInstallPreconditions();
+        const { wrapperPath, policyFile } = await writeManagedWorkerWrapper({ env, workerName, workerKey });
+        const { label, plistPath } = await writeManagedWorkerLaunchAgent({ env, workerName, wrapperPath });
+        const status = await resolveWorkerStatusPayload({ env });
+        const activeTaskCount = status.server.worker?.activeTaskCount ?? 0;
+        const shouldStart = options.start !== false;
+        if (activeTaskCount > 0 && shouldStart) {
+            await client.workerCreateUpdateIntent({
+                workerKey,
+                environment: env,
+                reason: 'setup_apply',
+            });
+            (0, output_1.printSuccess)('Managed worker setup updated and queued for quiesced restart.', [
+                `Wrapper: ${wrapperPath}`,
+                `LaunchAgent: ${plistPath}`,
+                `Policy file: ${policyFile}`,
+            ]);
+            return;
+        }
+        if (shouldStart || options.restart) {
+            launchManagedWorker(label, plistPath);
+        }
+        (0, output_1.printSuccess)('Managed worker setup complete.', [
+            `Wrapper: ${wrapperPath}`,
+            `LaunchAgent: ${plistPath}`,
+            `Policy file: ${policyFile}`,
+        ]);
+    }, { env: options.env });
+}
 async function failTaskWithRetry(client, taskId, body) {
     try {
         await client.workerFailAgentTask(taskId, body);
@@ -1708,11 +2483,14 @@ async function startWorker(options = {}) {
         const target = resolveWorkerExecutionTargetFromRole(me.user.role);
         const codexVersion = probeCodexInstallation()?.codexVersion ?? null;
         const claudeVersion = probeClaudeInstallation()?.claudeVersion ?? null;
+        const cursorVersion = probeCursorInstallation()?.cursorVersion ?? null;
         const codexAuthenticated = codexVersion ? readCodexAuthenticated() : false;
         const claudeAuthenticated = claudeVersion ? readClaudeAuthenticated() : false;
+        const cursorAuthenticated = cursorVersion ? readCursorAuthenticated() : false;
         const npmVersion = probeNpmVersion();
         const playwright = probePlaywrightChromium();
         const playdropPluginRoot = resolvePlaydropPluginRoot();
+        const playdropPluginVersion = readPlaydropPluginVersion(playdropPluginRoot);
         const workerKey = (0, config_1.getOrCreateWorkerKey)();
         const workerName = options.name?.trim() || `${username} - ${node_os_1.default.hostname()}`;
         const maxParallelTasks = (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_MAX_PARALLEL_TASKS', DEFAULT_WORKER_MAX_PARALLEL_TASKS);
@@ -1721,17 +2499,31 @@ async function startWorker(options = {}) {
             codexAuthenticated,
             claudeVersion,
             claudeAuthenticated,
+            cursorVersion,
+            cursorAuthenticated,
             npmVersion,
             playwright,
             maxParallelTasks,
             runningTaskCount: 0,
         });
+        if (playdropPluginVersion) {
+            capabilities.pluginVersion = playdropPluginVersion;
+            for (const agent of capabilities.agents) {
+                agent.pluginVersion = playdropPluginVersion;
+            }
+        }
         if (!capabilities.ready) {
             const reasons = Array.isArray(capabilities.degradedReasons) && capabilities.degradedReasons.length > 0
                 ? capabilities.degradedReasons.join(', ')
                 : 'no ready agent';
             throw new Error(`worker_preflight_failed: ${reasons}`);
         }
+        writeWorkerRuntimeState({
+            env,
+            workerKey,
+            workerName,
+            target,
+        });
         const activeTaskIds = new Set();
         const activeTaskRuns = new Map();
         const activeTerminators = new Map();
@@ -1739,6 +2531,7 @@ async function startWorker(options = {}) {
         const workerDevPortBase = (0, runtime_1.readPositiveEnvInt)('PLAYDROP_WORKER_DEV_PORT_BASE', DEFAULT_WORKER_DEV_PORT_BASE);
         let sessionExpired = false;
         let shuttingDown = false;
+        let quiescingForUpdate = false;
         let shutdownSignal = null;
         let crashed = false;
         let fatalTaskError = null;
@@ -1758,6 +2551,12 @@ async function startWorker(options = {}) {
             name: workerName,
             environment: env,
             capabilities: currentCapabilities(),
+            lifecycleState: quiescingForUpdate ? 'QUIESCING' : 'READY',
+            updateState: quiescingForUpdate ? 'UPDATE_REQUIRED' : 'CURRENT',
+            ready: capabilities.ready,
+            activeTaskCount: activeTaskRuns.size,
+            cliVersion: (0, clientInfo_1.getCliVersion)(),
+            pluginVersion: capabilities.pluginVersion,
         });
         const recordFatalTaskError = (error) => {
             if (!fatalTaskError) {
@@ -1766,6 +2565,24 @@ async function startWorker(options = {}) {
             shuttingDown = true;
             terminateActiveTasks();
         };
+        const handleWorkerAction = (response) => {
+            const requiredWrapperVersion = response?.updatePolicy?.requiredWrapperContractVersion;
+            if (typeof requiredWrapperVersion === 'number'
+                && requiredWrapperVersion > WORKER_WRAPPER_CONTRACT_VERSION) {
+                recordFatalTaskError(new Error(`worker_wrapper_update_required: run "playdrop worker setup --env ${env}" to install wrapper contract ${requiredWrapperVersion}.`));
+                return;
+            }
+            if (response?.action !== 'quiesce_for_update' || quiescingForUpdate) {
+                return;
+            }
+            writeManagedWorkerUpdatePolicyFile({
+                env,
+                workerKey,
+                updatePolicy: response.updatePolicy,
+            });
+            quiescingForUpdate = true;
+            console.log('Worker entering QUIESCING for managed update. No new tasks will be claimed.');
+        };
         const signalHandler = (signal) => {
             shutdownSignal = signal;
             if (shuttingDown) {
@@ -1775,8 +2592,21 @@ async function startWorker(options = {}) {
             // Task runs finish their own lifecycle (flush, fail, clean) before exit.
             terminateActiveTasks();
         };
+        const stdinShutdownHandler = () => {
+            shutdownSignal = 'SIGTERM';
+            if (shuttingDown) {
+                return;
+            }
+            shuttingDown = true;
+            terminateActiveTasks();
+        };
         node_process_1.default.once('SIGINT', signalHandler);
         node_process_1.default.once('SIGTERM', signalHandler);
+        if (options.superviseStdin) {
+            node_process_1.default.stdin.once('end', stdinShutdownHandler);
+            node_process_1.default.stdin.once('close', stdinShutdownHandler);
+            node_process_1.default.stdin.resume();
+        }
         console.log(`PlayDrop Worker started as "${workerName}" (${target}).`);
         await sendWorkerHealthAlertSafely({ state: 'started', env, workerName });
         // Marks the session expired, kills any in-flight agent child, and lets the
@@ -1790,7 +2620,7 @@ async function startWorker(options = {}) {
             terminateActiveTasks();
         };
         try {
-            await client.workerPresence(presenceBody());
+            handleWorkerAction(await client.workerPresence(presenceBody()));
         }
         catch (error) {
             if (isWorkerAuthFailureError(error)) {
@@ -1799,7 +2629,7 @@ async function startWorker(options = {}) {
             throw error;
         }
         presenceTimer = setInterval(() => {
-            client.workerPresence(presenceBody()).catch((error) => {
+            client.workerPresence(presenceBody()).then(handleWorkerAction).catch((error) => {
                 if (isWorkerAuthFailureError(error)) {
                     handleSessionExpiry();
                     return;
@@ -2009,8 +2839,8 @@ async function startWorker(options = {}) {
                     throw new Error('worker_shutdown');
                 }
                 agentStartedAt = new Date();
-                agentResult = assignment.agent === 'CODEX'
-                    ? await runCodex({
+                if (assignment.agent === 'CODEX') {
+                    agentResult = await runCodex({
                         workspaceDir,
                         binDir,
                         eventDir,
@@ -2026,8 +2856,10 @@ async function startWorker(options = {}) {
                         onChild: (controls) => {
                             activeTerminators.set(task.id, controls.terminate);
                         },
-                    })
-                    : await runClaude({
+                    });
+                }
+                else if (assignment.agent === 'CLAUDE_CODE') {
+                    agentResult = await runClaude({
                         workspaceDir,
                         binDir,
                         eventDir,
@@ -2045,6 +2877,27 @@ async function startWorker(options = {}) {
                             activeTerminators.set(task.id, controls.terminate);
                         },
                     });
+                }
+                else if (assignment.agent === 'CURSOR_COMPOSER') {
+                    const assignmentAgent = assignment.agent;
+                    const assignmentModel = assignment.model;
+                    const plannedAttemptIndex = assignment.attemptPlan?.options.findIndex((option) => option.agent === assignmentAgent && option.model === assignmentModel);
+                    const attemptIndex = typeof plannedAttemptIndex === 'number' && plannedAttemptIndex >= 0
+                        ? plannedAttemptIndex
+                        : 0;
+                    await client.workerRecordAgentTaskAttemptUnavailable(task.id, {
+                        workerKey,
+                        leaseToken,
+                        attemptIndex,
+                        reason: 'unavailable_runtime',
+                        message: 'Cursor Composer noninteractive worker execution is not configured on this worker.',
+                    });
+                    fenced = true;
+                    throw new Error('worker_cursor_composer_runner_not_configured');
+                }
+                else {
+                    throw new Error(`unsupported_worker_agent:${assignment.agent}`);
+                }
                 agentCompletedAt = new Date();
                 await queueEventDrain().catch((error) => {
                     handleEventDrainFailure(error);
@@ -2238,7 +3091,7 @@ async function startWorker(options = {}) {
         };
         try {
             let claimBackoffMs = CLAIM_BACKOFF_BASE_MS;
-            while (!shuttingDown) {
+            while (!shuttingDown && !quiescingForUpdate) {
                 if (fatalTaskError) {
                     throw fatalTaskError;
                 }
@@ -2261,6 +3114,7 @@ async function startWorker(options = {}) {
                         capabilities,
                         runningTaskCount: activeTaskRuns.size,
                     }));
+                    handleWorkerAction(claim);
                     claimBackoffMs = CLAIM_BACKOFF_BASE_MS;
                 }
                 catch (error) {
@@ -2274,7 +3128,7 @@ async function startWorker(options = {}) {
                 }
                 const task = claim.task;
                 if (!task) {
-                    if (shuttingDown) {
+                    if (shuttingDown || quiescingForUpdate) {
                         break;
                     }
                     if (options.once) {
@@ -2312,6 +3166,10 @@ async function startWorker(options = {}) {
             if (sessionExpired) {
                 throw new Error(exports.WORKER_SESSION_EXPIRED_MESSAGE);
             }
+            if (quiescingForUpdate) {
+                console.log('Worker quiesced for managed update. Exiting for supervisor restart.');
+                return;
+            }
             if (shuttingDown) {
                 await sendWorkerHealthAlertSafely({
                     state: 'stopped',
@@ -2340,6 +3198,10 @@ async function startWorker(options = {}) {
             }
             node_process_1.default.off('SIGINT', signalHandler);
             node_process_1.default.off('SIGTERM', signalHandler);
+            if (options.superviseStdin) {
+                node_process_1.default.stdin.off('end', stdinShutdownHandler);
+                node_process_1.default.stdin.off('close', stdinShutdownHandler);
+            }
             if (!crashed) {
                 await sendWorkerHealthAlertSafely({
                     state: 'stopped',
@@ -2348,6 +3210,7 @@ async function startWorker(options = {}) {
                     taskId: firstActiveTaskId(),
                 });
             }
+            clearWorkerRuntimeState(target);
         }
     }, { env: options.env });
 }