@playdrop/playdrop-cli 0.8.6 → 0.9.0

package/README.md

@@ -51,6 +51,10 @@ playdrop project publish --env dev .
 ## Main Commands
 
 ```bash
+playdrop doctor
+playdrop clients status
+playdrop agents status
+playdrop workspaces list
 playdrop auth login
 playdrop auth whoami --env dev
 playdrop browse
@@ -72,6 +76,22 @@ playdrop feedback send --title "Bug report" --comment "Details here."
 playdrop getting-started
 ```
 
+## Machine Setup
+
+```bash
+playdrop doctor
+playdrop clients install
+playdrop agents install-plugin codex
+playdrop agents install-plugin claude
+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`.
+
+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.
+
 ## Ref Format
 
 Public content refs are always:

package/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.8.6",
+  "version": "0.9.0",
   "runtimeSdkVersion": "0.7.21",
   "build": 1,
   "clients": {

package/dist/captureRuntime.d.ts

@@ -41,6 +41,8 @@ export type CaptureHostedLaunchState = {
 };
 export type CaptureRunResult = {
     errorCount: number;
+    warningCount: number;
+    warnings: string[];
     finalUrl: string;
     hostedLaunchState: CaptureHostedLaunchState | null;
 };

package/dist/captureRuntime.js

@@ -11,6 +11,93 @@ const sessionCookie_1 = require("./sessionCookie");
 const FRAME_SELECTOR = 'iframe[title="Game"]';
 exports.CAPTURE_LOG_LEVEL_VALUES = ['debug', 'info', 'warn', 'error'];
 exports.MAX_CAPTURE_TIMEOUT_SECONDS = 600;
+const GOOGLE_TELEMETRY_HOSTS = [
+    'googletagmanager.com',
+    'google-analytics.com',
+    'googleadservices.com',
+    'doubleclick.net',
+];
+const GOOGLE_COUNTRY_SECOND_LEVEL_DOMAINS = new Set(['ac', 'co', 'com', 'edu', 'gov', 'net', 'org']);
+function isHostOrSubdomain(hostname, domain) {
+    return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+function isGoogleSearchAdCollectionUrl(parsed) {
+    const hostname = parsed.hostname.toLowerCase();
+    if (hostname !== 'www.google.com') {
+        const suffix = hostname.startsWith('www.google.') ? hostname.slice('www.google.'.length) : '';
+        const labels = suffix.split('.');
+        const isCountryDomain = labels.length === 1
+            ? /^[a-z]{2}$/.test(labels[0])
+            : labels.length === 2
+                && GOOGLE_COUNTRY_SECOND_LEVEL_DOMAINS.has(labels[0])
+                && /^[a-z]{2}$/.test(labels[1]);
+        if (!isCountryDomain) {
+            return false;
+        }
+    }
+    const pathname = parsed.pathname.toLowerCase();
+    return pathname.startsWith('/ccm/collect')
+        || pathname.startsWith('/rmkt/collect')
+        || pathname.startsWith('/pagead/');
+}
+function isLoopbackOrLocalUrl(rawUrl) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        return false;
+    }
+    const hostname = parsed.hostname.toLowerCase();
+    return hostname === 'localhost'
+        || hostname === '127.0.0.1'
+        || hostname === '::1'
+        || hostname.endsWith('.localhost');
+}
+function isKnownGoogleTelemetryUrl(rawUrl) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        return false;
+    }
+    const hostname = parsed.hostname.toLowerCase();
+    if (hostname === 'accounts.google.com' || hostname.endsWith('.accounts.google.com')) {
+        return false;
+    }
+    return GOOGLE_TELEMETRY_HOSTS.some(domain => isHostOrSubdomain(hostname, domain))
+        || isGoogleSearchAdCollectionUrl(parsed);
+}
+function extractHttpUrls(text) {
+    const matches = text.match(/https?:\/\/[^\s"'<>]+/gi);
+    if (!matches) {
+        return [];
+    }
+    return matches.map(match => match.replace(/[\])}.,;]+$/g, ''));
+}
+function extractRefusedResourceUrls(text) {
+    const urls = [];
+    const refusedPattern = /Refused to [^']*'(https?:\/\/[^']+)'/gi;
+    let match = refusedPattern.exec(text);
+    while (match) {
+        urls.push(match[1]);
+        match = refusedPattern.exec(text);
+    }
+    return urls;
+}
+function isKnownGoogleTelemetryConsoleIssue(text, locationUrl) {
+    if (/Content Security Policy/i.test(text)) {
+        return extractRefusedResourceUrls(text).some(isKnownGoogleTelemetryUrl);
+    }
+    if (!/ERR_BLOCKED_BY_CLIENT/i.test(text)) {
+        return false;
+    }
+    const messageUrls = extractHttpUrls(text);
+    return (locationUrl !== null && isKnownGoogleTelemetryUrl(locationUrl))
+        || (messageUrls.some(isKnownGoogleTelemetryUrl)
+            && !messageUrls.some(isLoopbackOrLocalUrl));
+}
 function formatConsoleValue(value) {
     if (typeof value === 'string')
         return value;
@@ -176,6 +263,7 @@ function validateCaptureTimeout(value) {
 }
 async function runCapture(options) {
     const errors = [];
+    const warnings = [];
     const outputLines = [];
     const expectedUrl = options.expectedUrl ? normalizeComparableUrl(options.expectedUrl) : null;
     const expectedHostedLaunchState = options.requireHostedLaunchReady
@@ -208,6 +296,15 @@ async function runCapture(options) {
         errors.push(message);
         record('error', message);
     };
+    const recordWarning = (line, lineAlreadyRecorded = false) => {
+        warnings.push(line);
+        if (!lineAlreadyRecorded) {
+            outputLines.push(line);
+        }
+        if (shouldEmit('warn', options.minimumLogLevel)) {
+            console.warn(line);
+        }
+    };
     try {
         await (0, playwright_1.withChromiumPage)(async ({ context, page }) => {
             const targetOrigin = new URL(options.targetUrl).origin;
@@ -343,6 +440,14 @@ async function runCapture(options) {
                     effectiveLevel = 'debug';
                 }
                 if (type === 'error' || type === 'assert' || type === 'trace') {
+                    const location = typeof message.location === 'function' ? message.location() : null;
+                    const locationUrl = typeof location?.url === 'string' && location.url.trim().length > 0
+                        ? location.url
+                        : null;
+                    if (isKnownGoogleTelemetryConsoleIssue(rendered, locationUrl)) {
+                        recordWarning(line, true);
+                        return;
+                    }
                     errors.push(line);
                     if (shouldEmit(effectiveLevel, options.minimumLogLevel)) {
                         console.error(line);
@@ -383,6 +488,10 @@ async function runCapture(options) {
                 const failure = request.failure();
                 const errorText = failure?.errorText ?? '';
                 const text = `${request.method()} ${request.url()} - ${errorText || 'failed'}`;
+                if (isKnownGoogleTelemetryUrl(request.url())) {
+                    recordWarning(`[capture][requestfailed] ${text}`);
+                    return;
+                }
                 if (/ERR_ABORTED/i.test(errorText) || /ERR_HTTP2_PROTOCOL_ERROR/i.test(errorText)) {
                     const line = `[capture][requestcancelled] ${text}`;
                     outputLines.push(line);
@@ -411,6 +520,10 @@ async function runCapture(options) {
                     }
                     return;
                 }
+                if (isKnownGoogleTelemetryUrl(response.url())) {
+                    recordWarning(`[capture][response] ${text}`);
+                    return;
+                }
                 errors.push(text);
                 outputLines.push(`[capture][response] ${text}`);
                 if (shouldEmit('warn', options.minimumLogLevel)) {
@@ -528,6 +641,8 @@ async function runCapture(options) {
     }
     return {
         errorCount: errors.length,
+        warningCount: warnings.length,
+        warnings,
         finalUrl,
         hostedLaunchState,
     };

package/dist/commands/agents.d.ts

@@ -0,0 +1,62 @@
+type AgentID = 'codex' | 'claude' | 'cursor';
+interface ShellResult {
+    exitCode: number;
+    output: string;
+}
+interface ToolStatus {
+    installed: boolean;
+    path?: string;
+    version?: string;
+}
+interface PluginStatus {
+    installed: boolean;
+    status?: 'installed' | 'missing' | 'activation-required' | 'manual-verification-required' | 'unknown';
+    id?: string;
+    path?: string;
+    version?: string;
+    latestVersion?: string;
+    updateAvailable?: boolean;
+    enabled?: boolean;
+    scope?: string;
+    installableFromCli?: boolean;
+    message?: string;
+}
+export interface AgentStatus {
+    id: AgentID;
+    name: string;
+    app: ToolStatus;
+    cli: ToolStatus;
+    account?: {
+        identity?: string;
+        subscription?: string;
+        signedIn: boolean | null;
+    };
+    plugin: PluginStatus;
+    nextAction: {
+        command: string;
+        reason: string;
+    } | null;
+}
+export interface AgentsStatus {
+    agents: AgentStatus[];
+}
+interface AgentsStatusOptions {
+    homeDir?: string;
+    latestPluginVersion?: string;
+    runShell?: (command: string) => Promise<ShellResult>;
+    appExists?: (path: string) => boolean;
+    json?: boolean;
+}
+interface AgentActionOptions {
+    runCommand?: (command: string, args: string[]) => {
+        status: number | null;
+        stdout?: string;
+        stderr?: string;
+    };
+    homeDir?: string;
+}
+export declare function showAgentsStatus(options?: AgentsStatusOptions): Promise<AgentsStatus>;
+export declare function getAgentsStatus(options?: AgentsStatusOptions): Promise<AgentsStatus>;
+export declare function installPlugin(agentID: string, options?: AgentActionOptions): Promise<void>;
+export declare function updatePlugin(agentID: string, options?: AgentActionOptions): Promise<void>;
+export {};