@playdrop/playdrop-cli 0.10.20 → 0.11.0

package/config/client-meta.json

@@ -1,10 +1,14 @@
 {
-  "version": "0.10.20",
+  "version": "0.11.0",
   "build": 1,
   "runtimeSdkVersion": "0.10.0",
   "clients": {
     "all": {
       "minimumVersion": "0.7.4"
+    },
+    "windows-playdrop": {
+      "minimumVersion": "0.9.6",
+      "minimumBuild": 1
     }
   }
 }

package/dist/appUrls.d.ts

@@ -7,6 +7,9 @@ export type AppUrlInput = {
 export declare function normalizePlaydropWebBase(webBase?: string | null): string;
 export declare function getAppTypeSlug(type: AppType | string | null | undefined): string;
 export declare function buildPlatformPlayUrl(webBase: string | null | undefined, input: AppUrlInput): string;
+export declare function buildPlatformPrivateDraftPlayUrl(webBase: string | null | undefined, input: AppUrlInput & {
+    version: string;
+}): string;
 export declare function buildPlatformDevUrl(webBase: string | null | undefined, input: AppUrlInput & {
     devAuth?: 'prompt' | 'anonymous' | 'viewer' | 'player';
     player?: string | null;

package/dist/appUrls.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizePlaydropWebBase = normalizePlaydropWebBase;
 exports.getAppTypeSlug = getAppTypeSlug;
 exports.buildPlatformPlayUrl = buildPlatformPlayUrl;
+exports.buildPlatformPrivateDraftPlayUrl = buildPlatformPrivateDraftPlayUrl;
 exports.buildPlatformDevUrl = buildPlatformDevUrl;
 exports.buildUploadLaunchCheckUrl = buildUploadLaunchCheckUrl;
 const DEFAULT_WEB_BASE = 'https://www.playdrop.ai';
@@ -33,6 +34,17 @@ function buildPlatformPlayUrl(webBase, input) {
     const appName = encodeURIComponent(input.appName);
     return `${base}/creators/${creator}/apps/${typeSlug}/${appName}/play`;
 }
+function buildPlatformPrivateDraftPlayUrl(webBase, input) {
+    const base = normalizePlaydropWebBase(webBase);
+    const creator = encodeURIComponent(input.creatorUsername);
+    const typeSlug = getAppTypeSlug(input.appType);
+    const appName = encodeURIComponent(input.appName);
+    const version = encodeURIComponent(input.version.trim());
+    if (!version) {
+        throw new Error('invalid_private_draft_play_version');
+    }
+    return `${base}/_auth/creators/${creator}/apps/${typeSlug}/${appName}/play?v=${version}`;
+}
 function buildPlatformDevUrl(webBase, input) {
     const base = normalizePlaydropWebBase(webBase);
     const creator = encodeURIComponent(input.creatorUsername);

package/dist/apps/build.js

@@ -33,9 +33,10 @@ const projectBuildCache = new Map();
 const typescriptSourceCache = new Map();
 async function runNpmScript(projectDir, script) {
     await (0, promises_1.mkdir)(projectDir, { recursive: true });
-    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const npmCommand = process.platform === 'win32' ? process.env.ComSpec || 'cmd.exe' : 'npm';
+    const npmArgs = process.platform === 'win32' ? ['/d', '/s', '/c', `npm run ${script}`] : ['run', script];
     await new Promise((resolveRun, rejectRun) => {
-        const child = (0, node_child_process_1.spawn)(npmCommand, ['run', script], {
+        const child = (0, node_child_process_1.spawn)(npmCommand, npmArgs, {
             cwd: projectDir,
             stdio: 'inherit',
             env: { ...process.env },

package/dist/apps/launchCheck.d.ts

@@ -8,7 +8,7 @@ export type HostedLaunchCheckResult = {
     checkedAt: string;
     artifactFingerprint: string | null;
 };
-export declare function formatHostedLaunchCheckFailure(taskName: string, result: HostedLaunchCheckResult, scope?: 'local' | 'staged'): string;
+export declare function formatHostedLaunchCheckFailure(taskName: string, result: HostedLaunchCheckResult, scope?: 'local' | 'staged' | 'final'): string;
 export declare function runLocalHostedLaunchCheck(input: {
     client: ApiClient;
     apiBase: string;
@@ -30,3 +30,10 @@ export declare function runUploadedHostedLaunchCheck(input: {
     token?: string | null;
     currentUser?: UserResponse | null;
 }): Promise<HostedLaunchCheckResult>;
+export declare function runPublishedHostedPlayCheck(input: {
+    targetUrl: string;
+    surfaceTargets?: unknown;
+    timeoutMs?: number;
+    token?: string | null;
+    currentUser?: UserResponse | null;
+}): Promise<HostedLaunchCheckResult>;

package/dist/apps/launchCheck.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatHostedLaunchCheckFailure = formatHostedLaunchCheckFailure;
 exports.runLocalHostedLaunchCheck = runLocalHostedLaunchCheck;
 exports.runUploadedHostedLaunchCheck = runUploadedHostedLaunchCheck;
+exports.runPublishedHostedPlayCheck = runPublishedHostedPlayCheck;
 const appUrls_1 = require("../appUrls");
 const captureRuntime_1 = require("../captureRuntime");
 const devShared_1 = require("../commands/devShared");
@@ -13,13 +14,67 @@ const devRuntimeAssets_1 = require("../commands/devRuntimeAssets");
 const registration_1 = require("./registration");
 const DEFAULT_HOSTED_LAUNCH_TIMEOUT_MS = 15000;
 const POST_READY_SETTLE_MS = 750;
-const CAPTURE_SURFACE = 'DESKTOP';
+const MOBILE_USER_AGENT = 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1';
+const LAUNCH_CHECK_SURFACE_ORDER = ['DESKTOP', 'MOBILE_LANDSCAPE', 'MOBILE_PORTRAIT'];
+const LAUNCH_CHECK_SURFACE_CONTEXT_OPTIONS = {
+    DESKTOP: {
+        viewport: { width: 1280, height: 720 },
+        deviceScaleFactor: 1,
+        isMobile: false,
+        hasTouch: false,
+    },
+    MOBILE_LANDSCAPE: {
+        viewport: { width: 896, height: 414 },
+        deviceScaleFactor: 2,
+        isMobile: true,
+        hasTouch: true,
+        userAgent: MOBILE_USER_AGENT,
+    },
+    MOBILE_PORTRAIT: {
+        viewport: { width: 414, height: 896 },
+        deviceScaleFactor: 2,
+        isMobile: true,
+        hasTouch: true,
+        userAgent: MOBILE_USER_AGENT,
+    },
+};
+function normalizeLaunchCheckSurface(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value.trim().toUpperCase();
+    return LAUNCH_CHECK_SURFACE_ORDER.includes(normalized)
+        ? normalized
+        : null;
+}
+function normalizeLaunchCheckSurfaceTargets(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return Array.from(new Set(value.map(normalizeLaunchCheckSurface).filter((entry) => Boolean(entry))));
+}
+function resolveLaunchCheckSurface(surfaceTargets) {
+    const targets = normalizeLaunchCheckSurfaceTargets(surfaceTargets);
+    for (const surface of LAUNCH_CHECK_SURFACE_ORDER) {
+        if (targets.includes(surface)) {
+            return surface;
+        }
+    }
+    return 'DESKTOP';
+}
+function cloneLaunchCheckContextOptions(surface) {
+    const source = LAUNCH_CHECK_SURFACE_CONTEXT_OPTIONS[surface];
+    return {
+        ...source,
+        viewport: source.viewport ? { ...source.viewport } : source.viewport,
+    };
+}
 function resolvePostAuthHostedLaunchState(controllerMode) {
     return controllerMode === 'REQUIRED' ? 'controller_required' : 'ready';
 }
 function resolveAnonymousHostedLaunchState(input) {
-    const surfaceTargets = Array.isArray(input.surfaceTargets) ? input.surfaceTargets : [];
-    if (!surfaceTargets.includes(CAPTURE_SURFACE)) {
+    const surfaceTargets = normalizeLaunchCheckSurfaceTargets(input.surfaceTargets);
+    if (!surfaceTargets.includes(input.captureSurface)) {
         return 'surface_unsupported';
     }
     if (input.authMode === 'REQUIRED') {
@@ -64,7 +119,11 @@ function formatCaptureErrors(errors) {
     return ` First error${normalized.length === 1 ? '' : 's'}: ${normalized.join(' | ')}`;
 }
 function formatHostedLaunchCheckFailure(taskName, result, scope = 'local') {
-    const scopeLabel = scope === 'staged' ? 'staged upload preview' : 'local hosted preview';
+    const scopeLabel = scope === 'final'
+        ? 'final owner play route'
+        : scope === 'staged'
+            ? 'staged upload preview'
+            : 'local hosted preview';
     const errorCode = result.errorCode?.trim() || 'startup_failure';
     const message = normalizeLaunchCheckMessage(result.message);
     return `hosted_launch_check_failed: ${taskName} failed the ${scopeLabel} launch-check (${errorCode}). ${message}`;
@@ -102,13 +161,10 @@ function buildRegistrationRequiredLaunchCheckFailure(taskName) {
     return buildFailedLaunchCheckResult('app_registration_required_for_auth_validation', `Auth-required hosted app "${taskName}" must be registered on PlayDrop before viewer launch validation can run. Run "playdrop project create app ${taskName}" and try again.`, null);
 }
 function appendLaunchCheckParams(targetUrl, devAuth) {
-    const withAuth = (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(targetUrl, {
+    return (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(targetUrl, {
         devAuth,
         player: null,
     });
-    const nextUrl = new URL(withAuth);
-    nextUrl.searchParams.set('launchCheck', '1');
-    return nextUrl.toString();
 }
 async function runHostedLaunchCheckWithCapture(options) {
     const expectedHostedLaunchState = options.expectedHostedLaunchState ?? 'ready';
@@ -125,6 +181,7 @@ async function runHostedLaunchCheckWithCapture(options) {
             token: options.token ?? null,
             user: options.user ?? null,
             savedSessionBootstrap: options.savedSessionBootstrap ?? false,
+            contextOptions: options.contextOptions,
         });
         if (result.errorCount > 0) {
             return buildFailedLaunchCheckResult('startup_failure', `Hosted app emitted ${result.errorCount} console, page, or network error(s) during startup.${formatCaptureErrors(result.errors)}`, options.artifactFingerprint ?? null);
@@ -210,7 +267,12 @@ async function runLocalHostedLaunchCheck(input) {
             ? null
             : input.devRouterPort;
         const localAppMetadata = mountedRuntime.runtimeAssetManifest.response.localAppMetadata;
-        const anonymousExpectedState = resolveAnonymousHostedLaunchState(localAppMetadata);
+        const captureSurface = resolveLaunchCheckSurface(localAppMetadata.surfaceTargets);
+        const contextOptions = cloneLaunchCheckContextOptions(captureSurface);
+        const anonymousExpectedState = resolveAnonymousHostedLaunchState({
+            ...localAppMetadata,
+            captureSurface,
+        });
         if (anonymousExpectedState === 'login_required') {
             const registeredApp = await (0, registration_1.fetchRegisteredAppShell)(input.client, input.creatorUsername, input.task.name);
             const canLaunchUnregisteredViewer = input.allowUnregisteredViewerLaunch === true
@@ -230,6 +292,7 @@ async function runLocalHostedLaunchCheck(input) {
                 }),
                 timeoutMs: input.timeoutMs,
                 expectedHostedLaunchState: anonymousExpectedState,
+                contextOptions,
             });
             if (anonymousGateResult.status !== 'PASSED') {
                 return anonymousGateResult;
@@ -248,6 +311,7 @@ async function runLocalHostedLaunchCheck(input) {
                 token: input.token ?? null,
                 user: input.currentUser ?? null,
                 savedSessionBootstrap: true,
+                contextOptions,
             });
         }
         return await runHostedLaunchCheckWithCapture({
@@ -261,6 +325,7 @@ async function runLocalHostedLaunchCheck(input) {
             }),
             timeoutMs: input.timeoutMs,
             expectedHostedLaunchState: anonymousExpectedState,
+            contextOptions,
         });
     }
     finally {
@@ -271,7 +336,12 @@ async function runLocalHostedLaunchCheck(input) {
 }
 async function runUploadedHostedLaunchCheck(input) {
     const preview = await input.client.fetchAppUploadLaunchCheckPreview(input.creatorUsername, input.task.name, input.sessionId);
-    const anonymousExpectedState = resolveAnonymousHostedLaunchState(preview.localAppMetadata);
+    const captureSurface = resolveLaunchCheckSurface(preview.localAppMetadata.surfaceTargets);
+    const contextOptions = cloneLaunchCheckContextOptions(captureSurface);
+    const anonymousExpectedState = resolveAnonymousHostedLaunchState({
+        ...preview.localAppMetadata,
+        captureSurface,
+    });
     let result;
     if (anonymousExpectedState === 'login_required') {
         if (!preview.app?.id) {
@@ -283,6 +353,7 @@ async function runUploadedHostedLaunchCheck(input) {
                 artifactFingerprint: preview.session.manifestHash,
                 timeoutMs: input.timeoutMs,
                 expectedHostedLaunchState: anonymousExpectedState,
+                contextOptions,
             });
             if (anonymousGateResult.status !== 'PASSED') {
                 result = anonymousGateResult;
@@ -296,6 +367,7 @@ async function runUploadedHostedLaunchCheck(input) {
                     token: input.token ?? null,
                     user: input.currentUser ?? null,
                     savedSessionBootstrap: true,
+                    contextOptions,
                 });
             }
         }
@@ -306,6 +378,7 @@ async function runUploadedHostedLaunchCheck(input) {
             artifactFingerprint: preview.session.manifestHash,
             timeoutMs: input.timeoutMs,
             expectedHostedLaunchState: anonymousExpectedState,
+            contextOptions,
         });
     }
     const recorded = await input.client.recordAppUploadLaunchCheck(input.creatorUsername, input.task.name, input.sessionId, {
@@ -326,3 +399,16 @@ async function runUploadedHostedLaunchCheck(input) {
         artifactFingerprint: recordedLaunchCheck.artifactFingerprint,
     };
 }
+async function runPublishedHostedPlayCheck(input) {
+    const captureSurface = resolveLaunchCheckSurface(input.surfaceTargets);
+    return runHostedLaunchCheckWithCapture({
+        targetUrl: input.targetUrl,
+        artifactFingerprint: null,
+        timeoutMs: input.timeoutMs,
+        expectedHostedLaunchState: 'ready',
+        token: input.token ?? null,
+        user: input.currentUser ?? null,
+        savedSessionBootstrap: true,
+        contextOptions: cloneLaunchCheckContextOptions(captureSurface),
+    });
+}

package/dist/apps/upload.js

@@ -253,6 +253,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
         })),
         usesPacks: task.uses.packs,
         tags: task.tags,
+        design: task.design,
         clearTags: options?.clearTags,
         surfaceTargets: task.surfaceTargets,
         assetSpecSupport: (task.assetSpecSupport ?? []).map((row) => ({
@@ -409,6 +410,10 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     + `Delete one old version: playdrop creations apps versions delete ${task.name} <version>`);
             }
             if (unknownError.status === 409 && unknownError.code === 'version_exists') {
+                if (options?.agentTaskId !== undefined) {
+                    throw new Error(`Version ${task.version} already exists for app "${task.name}".\n` +
+                        'This task has a fixed outputVersion; do not bump catalogue.json. The required task version has already been consumed by an upload attempt, so fail the task with the operational reason.');
+                }
                 throw new Error(`Version ${task.version} already exists for app "${task.name}".\n` +
                     `Hint: Update "version" in catalogue.json to a new version (e.g., bump to the next patch).`);
             }

package/dist/catalogue.d.ts

@@ -1,4 +1,4 @@
-import { type AppSurface, type AppType, type AppHostingMode, type AppAuthMode, type AppControllerMode, type AppVersionVisibility, type AppAchievementCatalogueDefinition, type AppLeaderboardCatalogueDefinition, type PlayerMetaDefinitionStatus, type CatalogueTagGroupDefinition, type AppMetadataAssetSpecSupport, type AssetSpecContract, type AssetSpecStatus, type AssetSpecValidationKind, type ContentLicense } from '@playdrop/types';
+import { type AppSurface, type AppType, type AppHostingMode, type AppAuthMode, type AppControllerMode, type AppVersionVisibility, type AppVersionDesign, type AppAchievementCatalogueDefinition, type AppLeaderboardCatalogueDefinition, type PlayerMetaDefinitionStatus, type CatalogueTagGroupDefinition, type AppMetadataAssetSpecSupport, type AssetSpecContract, type AssetSpecStatus, type AssetSpecValidationKind, type ContentLicense } from '@playdrop/types';
 import { type AssetSpecSupportDeclaration } from './assetSpecs';
 export type CatalogueJson = {
     apps?: Array<Record<string, unknown>>;
@@ -41,6 +41,7 @@ export type AppCatalogueEntry = {
     remixSource?: string | null;
     remix?: string;
     surfaceTargets?: Record<string, unknown> | AppSurface[] | null;
+    design?: unknown;
     version?: string;
     releaseNotes?: string;
     visibility?: string;
@@ -177,6 +178,7 @@ export type AppTask = {
     emoji?: string | null;
     color?: string | null;
     surfaceTargets: AppSurface[];
+    design?: AppVersionDesign;
     missingMetadata: string[];
     ecsPath?: string;
     serverPath?: string;

package/dist/catalogue.js

@@ -1300,6 +1300,17 @@ function buildAppTasks(rootDir, catalogues, options) {
             if (errors.length > errorCountBeforeDependencies) {
                 continue;
             }
+            let design;
+            if (Object.prototype.hasOwnProperty.call(entry, 'design')) {
+                const parsedDesign = (0, types_1.normalizeAppVersionDesign)(entry.design, {
+                    allowedPackRefs: usesPacks,
+                });
+                if (!parsedDesign.ok) {
+                    errors.push(`[${label}] App "${rawName}" ${parsedDesign.error}`);
+                    continue;
+                }
+                design = parsedDesign.value;
+            }
             const errorCountBeforeTagMetadata = errors.length;
             const remix = normalizeCatalogueRemixRef(entry.remix, 'app', errors, `[${label}] App "${rawName}"`);
             const tags = normalizeCatalogueTags(entry.tags, errors, `[${label}] App "${rawName}"`);
@@ -1500,6 +1511,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                 emoji: metadata.emoji === undefined ? undefined : metadata.emoji,
                 color: metadata.color === undefined ? undefined : metadata.color,
                 surfaceTargets: metadata.surfaceTargets,
+                design,
                 missingMetadata: metadata.missingFields,
                 ecsPath,
                 serverPath,

package/dist/commands/agents.js

@@ -88,11 +88,16 @@ async function detectCli(command, runShell) {
     if (pathProbe.exitCode !== 0 || pathProbe.output.trim().length === 0) {
         return { installed: false };
     }
+    const path = pathProbe.output.split('\n')[0]?.trim();
     const versionProbe = await runShell(`${command} --version`);
+    const version = versionProbe.output.split('\n')[0]?.trim() || undefined;
+    if (versionProbe.exitCode !== 0 && !/\d+\.\d+\.\d+/.test(versionProbe.output)) {
+        return { installed: false, path };
+    }
     return {
         installed: true,
-        path: pathProbe.output.split('\n')[0]?.trim(),
-        version: versionProbe.exitCode === 0 ? versionProbe.output.split('\n')[0]?.trim() : undefined,
+        path,
+        version,
     };
 }
 function detectApp(appNames, homeDir, appExists) {
@@ -285,6 +290,9 @@ function printAgentsStatus(status) {
     }
 }
 function runCodexPluginAction(action, runCommand) {
+    if (!ensureAgentCliUsable('codex', runCommand)) {
+        return;
+    }
     const marketplaceCommand = action === 'install-plugin'
         ? ['plugin', 'marketplace', 'add', PLAYDROP_PLUGIN_MARKETPLACE]
         : ['plugin', 'marketplace', 'upgrade', 'playdrop'];
@@ -340,6 +348,9 @@ function runCodexPluginAction(action, runCommand) {
     console.log('Open Codex and run /plugins, then install or enable PlayDrop.');
 }
 function runClaudePluginAction(action, runCommand) {
+    if (!ensureAgentCliUsable('claude', runCommand)) {
+        return;
+    }
     if (action === 'install-plugin') {
         const marketplace = runCommand('claude', ['plugin', 'marketplace', 'add', PLAYDROP_PLUGIN_MARKETPLACE]);
         if (marketplace.status !== 0) {
@@ -379,6 +390,21 @@ function runClaudePluginAction(action, runCommand) {
     console.log('Updated the PlayDrop plugin for Claude.');
     console.log('Run /reload-plugins in Claude Code or restart Claude Code to apply it.');
 }
+function ensureAgentCliUsable(command, runCommand) {
+    const result = runCommand(command, ['--version']);
+    const output = commandOutput(result).trim();
+    if (result.status === 0 || /\d+\.\d+\.\d+/.test(output)) {
+        return true;
+    }
+    const label = command === 'codex' ? 'Codex' : 'Claude';
+    console.error(`${label} CLI is missing or not runnable.`);
+    console.error(`${command} --version failed with code ${result.status ?? 'unknown'}.`);
+    if (output) {
+        console.error(`Output: ${output}`);
+    }
+    process.exitCode = 1;
+    return false;
+}
 function readInstalledPlayDropPlugin(command, runCommand) {
     const list = runCommand(command, ['plugin', 'list', '--json']);
     if (list.status !== 0) {
@@ -477,9 +503,10 @@ async function runLoginShell(command) {
 }
 function runCommandSync(command, args) {
     const result = (0, node_child_process_1.spawnSync)(command, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    const spawnError = result.error instanceof Error ? result.error.message : '';
     return {
         status: result.status,
         stdout: result.stdout ?? '',
-        stderr: result.stderr ?? '',
+        stderr: [result.stderr ?? '', spawnError].filter(Boolean).join('\n'),
     };
 }

package/dist/commands/clients.js

@@ -17,6 +17,9 @@ const output_1 = require("../output");
 const versionCompare_1 = require("../versionCompare");
 const MAC_APP_PATH = '/Applications/PlayDrop.app';
 const MAC_CLIENT_LATEST_URL = 'https://www.playdrop.ai/api/mac-client/latest';
+const WINDOWS_CLIENT_EXECUTABLE = 'PlayDrop.exe';
+const WINDOWS_CLIENT_INSTALL_HINT = 'Install or update PlayDrop for Windows with the Windows installer or the in-app updater.';
+const WINDOWS_CLIENT_PATH_ENV = 'PLAYDROP_WINDOWS_CLIENT_PATH';
 async function showClientStatus(options = {}) {
     const status = await getClientStatus(options);
     if (options.json) {
@@ -29,6 +32,9 @@ async function showClientStatus(options = {}) {
 }
 async function getClientStatus(options = {}) {
     const platform = options.platform ?? process.platform;
+    if (platform === 'win32') {
+        return getWindowsClientStatus(options);
+    }
     if (platform !== 'darwin') {
         return {
             platform,
@@ -65,6 +71,24 @@ async function updateClient(options = {}) {
 }
 async function launchClient(options = {}) {
     const platform = options.platform ?? process.platform;
+    if (platform === 'win32') {
+        const status = await getWindowsClientStatus(options);
+        if (!status.installed || !status.appPath) {
+            console.error('PlayDrop for Windows is not installed.');
+            console.error(WINDOWS_CLIENT_INSTALL_HINT);
+            process.exitCode = 1;
+            return;
+        }
+        const runCommand = options.runCommand ?? runCommandSync;
+        const result = runCommand(status.appPath, []);
+        if (result.status !== 0) {
+            console.error(`Failed to launch PlayDrop from ${status.appPath}.`);
+            process.exitCode = 1;
+            return;
+        }
+        console.log('Launched PlayDrop.');
+        return;
+    }
     if (platform !== 'darwin') {
         printUnsupportedPlatform(platform);
         return;
@@ -87,6 +111,12 @@ async function launchClient(options = {}) {
 }
 async function installOrUpdateClient(action, options) {
     const platform = options.platform ?? process.platform;
+    if (platform === 'win32') {
+        console.error(`PlayDrop for Windows ${action} is not available through the CLI yet.`);
+        console.error(WINDOWS_CLIENT_INSTALL_HINT);
+        process.exitCode = 1;
+        return;
+    }
     if (platform !== 'darwin') {
         printUnsupportedPlatform(platform);
         return;
@@ -129,7 +159,12 @@ function printClientStatus(status) {
     }
     if (!status.installed) {
         console.log('PlayDrop client: missing');
-        console.log('Run: playdrop clients install');
+        if (status.nextAction) {
+            console.log(`Run: ${status.nextAction}`);
+        }
+        else if (status.reason) {
+            console.log(status.reason);
+        }
         return;
     }
     const version = status.version ? ` ${status.version}` : '';
@@ -141,6 +176,68 @@ function printClientStatus(status) {
         console.log('Run: playdrop clients update');
     }
 }
+async function getWindowsClientStatus(options) {
+    const appPath = resolveWindowsClientPath(options.appPath);
+    if (!appPath) {
+        return {
+            platform: 'win32',
+            supported: true,
+            status: 'missing',
+            installed: false,
+            reason: WINDOWS_CLIENT_INSTALL_HINT,
+        };
+    }
+    const bundle = readWindowsClientInfo(appPath);
+    return {
+        platform: 'win32',
+        supported: true,
+        status: 'installed',
+        installed: true,
+        appPath,
+        version: bundle.version,
+        build: bundle.build,
+        updateAvailable: false,
+    };
+}
+function resolveWindowsClientPath(explicitPath) {
+    const candidates = windowsClientPathCandidates(explicitPath);
+    return candidates.find((candidate) => (0, node_fs_1.existsSync)(candidate));
+}
+function windowsClientPathCandidates(explicitPath) {
+    const candidates = [];
+    const add = (value) => {
+        if (value && value.trim().length > 0) {
+            candidates.push(value.trim());
+        }
+    };
+    add(explicitPath);
+    add(process.env[WINDOWS_CLIENT_PATH_ENV]);
+    const localAppData = process.env.LOCALAPPDATA;
+    if (localAppData) {
+        add((0, node_path_1.join)(localAppData, 'PlayDrop.Windows', 'current', WINDOWS_CLIENT_EXECUTABLE));
+        add((0, node_path_1.join)(localAppData, 'PlayDrop', 'current', WINDOWS_CLIENT_EXECUTABLE));
+    }
+    add(process.env.ProgramFiles ? (0, node_path_1.join)(process.env.ProgramFiles, 'PlayDrop', WINDOWS_CLIENT_EXECUTABLE) : undefined);
+    add(process.env['ProgramFiles(x86)'] ? (0, node_path_1.join)(process.env['ProgramFiles(x86)'], 'PlayDrop', WINDOWS_CLIENT_EXECUTABLE) : undefined);
+    return [...new Set(candidates)];
+}
+function readWindowsClientInfo(appPath) {
+    for (const versionPath of [
+        (0, node_path_1.join)((0, node_path_1.dirname)(appPath), 'sq.version'),
+        (0, node_path_1.join)((0, node_path_1.dirname)((0, node_path_1.dirname)(appPath)), 'sq.version'),
+    ]) {
+        try {
+            const version = (0, node_fs_1.readFileSync)(versionPath, 'utf8').trim();
+            if (version.length > 0) {
+                return { version };
+            }
+        }
+        catch {
+            // Development and portable builds may not have a Velopack version file.
+        }
+    }
+    return {};
+}
 async function fetchLatestMacClientManifest() {
     try {
         const response = await fetch(MAC_CLIENT_LATEST_URL, { headers: { Accept: 'application/json' } });

package/dist/commands/doctor.d.ts

@@ -22,6 +22,14 @@ interface CliHealth {
     updateStatus: 'current' | 'update-available' | 'unknown';
     updateAvailable?: boolean;
     nextAction?: string;
+    command?: CliCommandHealth;
+}
+interface CliCommandHealth {
+    available: boolean;
+    path?: string;
+    npmGlobalBin?: string;
+    npmShimPath?: string;
+    issue?: 'not-on-path' | 'shim-missing';
 }
 export interface DoctorReport {
     cli: CliHealth;