@playdrop/playdrop-cli 0.10.5 → 0.10.7

package/README.md

@@ -88,7 +88,7 @@ playdrop workspaces init
 
 `playdrop agents install-plugin claude` adds the PlayDrop marketplace, installs the PlayDrop plugin through the Claude Code CLI, and tells you to reload plugins.
 
-`playdrop agents install-plugin codex` configures the PlayDrop plugin marketplace and uses Codex's plugin install command when the local Codex CLI exposes one. If the installed Codex CLI only supports marketplace management, finish activation from Codex with `/plugins`.
+`playdrop agents install-plugin codex` configures the PlayDrop plugin marketplace and uses Codex's `plugin add` command when the local Codex CLI exposes it. If the installed Codex CLI only supports marketplace management, finish activation from Codex with `/plugins`.
 
 Cursor does not currently expose documented plugin installation through its CLI. `playdrop agents install-plugin cursor` prints the manual steps instead: open Cursor and use `/add-plugin` or the Cursor Marketplace for PlayDrop.
 

package/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.5",
+  "version": "0.10.7",
   "build": 1,
   "runtimeSdkVersion": "0.10.0",
   "clients": {

package/dist/commands/agents.js

@@ -296,6 +296,21 @@ function runCodexPluginAction(action, runCommand) {
     }
     const help = runCommand('codex', ['plugin', '--help']);
     const helpText = commandOutput(help);
+    if (commandHelpIncludes(helpText, 'add')) {
+        const add = runCommand('codex', ['plugin', 'add', PLAYDROP_PLUGIN_SPEC]);
+        if (add.status !== 0) {
+            console.error(`Codex PlayDrop plugin ${action === 'install-plugin' ? 'install' : 'update'} failed.`);
+            process.exitCode = 1;
+            return;
+        }
+        if (commandHelpIncludes(helpText, 'list') && !readInstalledPlayDropPlugin('codex', runCommand)) {
+            console.error(`Codex PlayDrop plugin ${action === 'install-plugin' ? 'install' : 'update'} could not be verified from codex plugin list --json.`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log(`${action === 'install-plugin' ? 'Installed' : 'Updated'} the PlayDrop plugin for Codex.`);
+        return;
+    }
     if (action === 'install-plugin' && commandHelpIncludes(helpText, 'install')) {
         const install = runCommand('codex', ['plugin', 'install', PLAYDROP_PLUGIN_SPEC]);
         if (install.status !== 0) {

package/dist/commands/upgrade.d.ts

@@ -1 +1,10 @@
-export declare function upgrade(dryRun?: boolean): Promise<void>;
+type UpgradeOptions = {
+    dryRun?: boolean;
+    targetVersion?: string;
+    worker?: boolean;
+    env?: string;
+    workerKey?: string;
+    updatePlugins?: boolean;
+};
+export declare function upgrade(options?: UpgradeOptions): Promise<void>;
+export {};

package/dist/commands/upgrade.js

@@ -2,16 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upgrade = upgrade;
 const node_child_process_1 = require("node:child_process");
-const UPGRADE_COMMAND = ['install', '-g', '@playdrop/playdrop-cli@latest'];
-async function upgrade(dryRun = false) {
-    const commandString = `npm ${UPGRADE_COMMAND.join(' ')}`;
-    if (dryRun) {
-        console.log(commandString);
-        return;
+const commandContext_1 = require("../commandContext");
+const config_1 = require("../config");
+const worker_1 = require("./worker");
+const WORKER_UPDATE_POLL_DEFAULT_MS = 3000;
+const WORKER_UPDATE_TIMEOUT_DEFAULT_MS = 15 * 60000;
+function readPositiveIntegerEnv(name, fallback) {
+    const raw = process.env[name]?.trim() || '';
+    const value = Number(raw);
+    return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function validateTargetVersion(value) {
+    const version = value?.trim() || process.env.PLAYDROP_CLI_TARGET_VERSION?.trim() || '';
+    if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+        throw new Error('playdrop_update_target_version_required: pass --target-version <version> or set PLAYDROP_CLI_TARGET_VERSION. Managed workers should use playdrop update --worker.');
     }
+    return version;
+}
+function runCommand(command, args) {
+    const commandString = `${command} ${args.join(' ')}`;
     console.log('Running:', commandString);
-    await new Promise((resolve, reject) => {
-        const child = (0, node_child_process_1.spawn)('npm', UPGRADE_COMMAND, {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
             stdio: 'inherit',
             shell: process.platform === 'win32'
         });
@@ -20,9 +37,82 @@ async function upgrade(dryRun = false) {
                 resolve();
             }
             else {
-                reject(new Error(`npm exited with code ${code}`));
+                reject(new Error(`${command} exited with code ${code}`));
             }
         });
         child.on('error', (error) => reject(error));
     });
 }
+function formatWorkerUpdateState(worker) {
+    return [
+        `lifecycle=${worker.lifecycleState ?? 'unknown'}`,
+        `update=${worker.updateState ?? 'unknown'}`,
+        `ready=${worker.ready === true ? 'true' : worker.ready === false ? 'false' : 'unknown'}`,
+        `cli=${worker.cliVersion ?? 'unknown'}`,
+        `plugin=${worker.pluginVersion ?? 'unknown'}`,
+    ].join(' ');
+}
+async function observeManagedWorkerUpdate(input) {
+    const pollMs = readPositiveIntegerEnv('PLAYDROP_WORKER_UPDATE_POLL_MS', WORKER_UPDATE_POLL_DEFAULT_MS);
+    const timeoutMs = readPositiveIntegerEnv('PLAYDROP_WORKER_UPDATE_TIMEOUT_MS', WORKER_UPDATE_TIMEOUT_DEFAULT_MS);
+    const deadline = Date.now() + timeoutMs;
+    let lastState = '';
+    while (Date.now() <= deadline) {
+        const workers = await input.client.listMyAgentWorkers();
+        const worker = workers.workers.find((candidate) => candidate.workerKey === input.workerKey);
+        if (!worker) {
+            throw new Error(`playdrop_update_worker_missing: worker ${input.workerKey} is no longer registered. Run "playdrop worker status --json" on the worker host.`);
+        }
+        const state = formatWorkerUpdateState(worker);
+        if (state !== lastState) {
+            console.log(`Worker update progress: ${state}`);
+            lastState = state;
+        }
+        if (worker.updateState === 'UPDATE_BLOCKED' || worker.lifecycleState === 'DEGRADED' || worker.ready === false) {
+            throw new Error(`playdrop_update_worker_failed: ${state}. Next action: run "playdrop worker status --json" on the worker host and inspect the wrapper failure marker under ~/.playdrop/worker.`);
+        }
+        if (worker.activeUpdateIntentId !== input.intentId
+            && worker.lifecycleState === 'READY'
+            && worker.updateState === 'CURRENT'
+            && worker.ready === true) {
+            console.log('Managed worker update completed.');
+            return;
+        }
+        await sleep(pollMs);
+    }
+    throw new Error(`playdrop_update_worker_timeout: worker ${input.workerKey} did not complete update intent ${input.intentId} within ${timeoutMs}ms. Next action: check Slack worker alerts, launchctl status, and the wrapper failure marker on the worker host.`);
+}
+async function upgrade(options = {}) {
+    if (options.worker) {
+        const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)('update', 'Requesting a managed worker update', { env: options.env });
+        if (!ctx) {
+            return;
+        }
+        const workerKey = options.workerKey?.trim() || (0, config_1.getOrCreateWorkerKey)();
+        const intent = await ctx.client.workerCreateUpdateIntent({
+            workerKey,
+            environment: ctx.env,
+            reason: 'manual_update',
+        });
+        console.log(`Managed worker update intent ${intent.intent.id} created for worker ${workerKey}.`);
+        console.log(`Worker state: ${intent.worker.lifecycleState ?? 'unknown'} / ${intent.worker.updateState ?? 'unknown'}`);
+        await observeManagedWorkerUpdate({
+            client: ctx.client,
+            workerKey,
+            intentId: intent.intent.id,
+        });
+        return;
+    }
+    const activePersonalWorker = (0, worker_1.readActivePersonalWorkerRuntimeState)();
+    if (activePersonalWorker) {
+        throw new Error(`playdrop_update_active_personal_worker: stop the My Agent worker first, then rerun playdrop update. pid=${activePersonalWorker.pid} worker=${activePersonalWorker.workerName}`);
+    }
+    const targetVersion = validateTargetVersion(options.targetVersion);
+    const upgradeCommand = ['install', '-g', '--no-audit', '--no-fund', `@playdrop/playdrop-cli@${targetVersion}`];
+    const commandString = `npm ${upgradeCommand.join(' ')}`;
+    if (options.dryRun) {
+        console.log(commandString);
+        return;
+    }
+    await runCommand('npm', upgradeCommand);
+}

package/dist/commands/worker.d.ts

@@ -10,6 +10,47 @@ type WorkerStartOptions = {
     env?: string;
     once?: boolean;
     name?: string;
+    superviseStdin?: boolean;
+};
+type WorkerStatusOptions = {
+    env?: string;
+    json?: boolean;
+};
+type WorkerSetupOptions = {
+    env?: string;
+    name?: string;
+    start?: boolean;
+    restart?: boolean;
+};
+type WorkerLocalStatus = {
+    ready: boolean;
+    degradedReasons: string[];
+    cliVersion: string;
+    nodeVersion: string;
+    npmVersion: string | null;
+    playwright: {
+        version?: string;
+        chromiumInstalled?: boolean;
+    } | null;
+    plugin: {
+        ready: boolean;
+        root: string | null;
+        version: string | null;
+        error: string | null;
+    };
+    agents: AgentWorkerCapabilities['agents'];
+    capabilities: AgentWorkerCapabilities | null;
+};
+type WorkerStatusPayload = {
+    schemaVersion: 1;
+    generatedAt: string;
+    local: WorkerLocalStatus;
+    server: {
+        reachable: boolean;
+        authenticated: boolean;
+        worker: import('@playdrop/types').AgentWorkerResponse | null;
+        error?: string;
+    };
 };
 type TaskReportOptions = {
     env?: string;
@@ -111,6 +152,8 @@ export declare function buildWorkerCapabilities(input: string | {
     codexAuthenticated?: boolean | null;
     claudeVersion?: string | null;
     claudeAuthenticated?: boolean | null;
+    cursorVersion?: string | null;
+    cursorAuthenticated?: boolean | null;
     npmVersion?: string | null;
     playwright?: {
         version?: string;
@@ -150,6 +193,27 @@ export declare function createLocalPlaydropShim(input: {
     attempt: number;
     devPort: number;
 }): Promise<string>;
+type WorkerRuntimeState = {
+    schemaVersion: 1;
+    pid: number;
+    env: string;
+    workerKey: string;
+    workerName: string;
+    target: AgentExecutionTarget;
+    startedAt: string;
+};
+export declare function readActivePersonalWorkerRuntimeState(): WorkerRuntimeState | null;
+export declare function parseLaunchAgentProgramArguments(plist: string): string[];
+export declare function assertLaunchAgentPlistCompatible(input: {
+    plistPath: string;
+    plist: string;
+    env: string;
+    workerName: string;
+    wrapperPath: string;
+    canonicalPlistPath: string;
+}): void;
+export declare function showWorkerStatus(options?: WorkerStatusOptions): Promise<WorkerStatusPayload>;
+export declare function setupWorker(options?: WorkerSetupOptions): Promise<void>;
 export declare function startWorker(options?: WorkerStartOptions): Promise<void>;
 export declare function reportTask(options: TaskReportOptions): Promise<void>;
 export declare function reportCatalogueTask(options: TaskCatalogueReportOptions): Promise<void>;