@playdrop/playdrop-cli 0.5.3 → 0.5.5

package/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.5.3",
+  "version": "0.5.5",
   "build": 1,
   "platforms": {
     "ios": {
@@ -26,11 +26,11 @@
   },
   "clients": {
     "web": {
-      "minimumVersion": "0.5.3",
+      "minimumVersion": "0.5.5",
       "minimumBuild": 1
     },
     "admin": {
-      "minimumVersion": "0.5.3",
+      "minimumVersion": "0.5.5",
       "minimumBuild": 1
     },
     "apple": {
@@ -38,7 +38,7 @@
       "minimumBuild": 1
     },
     "cli": {
-      "minimumVersion": "0.5.3"
+      "minimumVersion": "0.5.5"
     }
   }
 }

package/dist/commandContext.d.ts

@@ -1,6 +1,6 @@
 import type { ApiClient } from '@playdrop/api-client';
 import type { AiClient } from '@playdrop/ai-client';
-import { type CliConfig } from './config';
+import { type CliAccountSession, type CliConfig } from './config';
 import { type EnvironmentConfig } from './environment';
 export type EnvironmentContext = {
     client: ApiClient;
@@ -9,8 +9,12 @@ export type EnvironmentContext = {
     envConfig: EnvironmentConfig;
     token: string;
     config: CliConfig;
+    account: CliAccountSession | null;
 };
 type EnvironmentCallback = (ctx: EnvironmentContext) => Promise<void> | void;
-export declare function withEnvironment(command: string, actionLabel: string, callback: EnvironmentCallback): Promise<void>;
+type ResolveAuthenticatedEnvironmentOptions = {
+    workspacePath?: string;
+};
+export declare function withEnvironment(command: string, actionLabel: string, callback: EnvironmentCallback, options?: ResolveAuthenticatedEnvironmentOptions): Promise<void>;
 export declare function withPublicEnvironment(command: string, callback: EnvironmentCallback): Promise<void>;
 export {};

package/dist/commandContext.js

@@ -6,21 +6,19 @@ const config_1 = require("./config");
 const apiClient_1 = require("./apiClient");
 const environment_1 = require("./environment");
 const messages_1 = require("./messages");
+const workspaceAuth_1 = require("./workspaceAuth");
 const DEFAULT_PUBLIC_ENV = 'prod';
-function resolveConfiguredEnvironment(cfg, command, options) {
-    const configuredEnv = typeof cfg.env === 'string' && cfg.env.trim().length > 0
-        ? cfg.env.trim()
-        : undefined;
-    if (!configuredEnv && options.requireAuth) {
+function resolveConfiguredEnvironment(envName, command, options) {
+    if (!envName && options.requireAuth) {
         (0, messages_1.printConfigEnvironmentMissing)(command);
         process.exitCode = 1;
         return null;
     }
-    const envName = configuredEnv ?? (options.allowDefaultPublicEnv ? DEFAULT_PUBLIC_ENV : undefined);
-    const envConfig = (0, environment_1.resolveEnvironmentConfig)(envName);
+    const resolvedEnvName = envName ?? (options.allowDefaultPublicEnv ? DEFAULT_PUBLIC_ENV : undefined);
+    const envConfig = (0, environment_1.resolveEnvironmentConfig)(resolvedEnvName);
     if (!envConfig) {
         const choices = (0, environment_1.formatEnvironmentList)();
-        (0, messages_1.printUnknownEnvironment)(envName || '', choices, command);
+        (0, messages_1.printUnknownEnvironment)(resolvedEnvName || '', choices, command);
         process.exitCode = 1;
         return null;
     }
@@ -29,42 +27,168 @@ function resolveConfiguredEnvironment(cfg, command, options) {
     }
     return envConfig;
 }
-function buildContext(cfg, envConfig) {
-    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token: cfg.token });
-    const aiClient = (0, apiClient_1.createCliAiClient)({ baseUrl: envConfig.aiBase, token: cfg.token });
+function buildContext(cfg, envConfig, account) {
+    const token = account?.token ?? cfg.token ?? '';
+    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token });
+    const aiClient = (0, apiClient_1.createCliAiClient)({ baseUrl: envConfig.aiBase, token });
     return {
         client,
         aiClient,
         env: envConfig.name,
         envConfig,
-        token: cfg.token || '',
+        token,
         config: cfg,
+        account,
     };
 }
-async function withEnvironment(command, actionLabel, callback) {
-    const cfg = (0, config_1.loadConfig)();
-    if (!cfg.token) {
+function buildLegacyAccountSession(cfg) {
+    if (!cfg.token || !cfg.env) {
+        return null;
+    }
+    return {
+        username: cfg.currentUsername ?? '',
+        env: cfg.env,
+        token: cfg.token,
+        updatedAt: '',
+    };
+}
+async function migrateLegacyConfigIfNeeded(cfg, envConfig, command) {
+    if ((0, config_1.getCurrentAccountSession)(cfg) || !cfg.token || !cfg.env) {
+        return cfg;
+    }
+    const client = (0, apiClient_1.createCliApiClient)({ baseUrl: envConfig.apiBase, token: cfg.token });
+    try {
+        const data = await client.me();
+        const username = typeof data.user?.username === 'string' ? data.user.username.trim() : '';
+        if (!username) {
+            (0, messages_1.printErrorWithHelp)('Could not migrate your existing Playdrop CLI session.', ['Run "playdrop auth login" to reauthenticate and rebuild your local account store.'], { command });
+            process.exitCode = 1;
+            return null;
+        }
+        return (0, config_1.migrateLegacySession)({
+            username,
+            env: envConfig.name,
+            token: cfg.token,
+        });
+    }
+    catch {
+        (0, messages_1.printErrorWithHelp)('Could not migrate your existing Playdrop CLI session.', ['Run "playdrop auth login" to reauthenticate and rebuild your local account store.'], { command });
+        process.exitCode = 1;
+        return null;
+    }
+}
+function resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth) {
+    const matchingSessions = (0, config_1.listAccountSessionsForUsername)(workspaceAuth.config.ownerUsername, cfg);
+    if (workspaceAuth.config.env) {
+        return {
+            account: (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, workspaceAuth.config.env, cfg),
+            matchingSessions,
+        };
+    }
+    if (matchingSessions.length === 1) {
+        return {
+            account: matchingSessions[0],
+            matchingSessions,
+        };
+    }
+    if (currentAccount && currentAccount.username === workspaceAuth.config.ownerUsername) {
+        return {
+            account: (0, config_1.findAccountSession)(workspaceAuth.config.ownerUsername, currentAccount.env, cfg),
+            matchingSessions,
+        };
+    }
+    return {
+        account: null,
+        matchingSessions,
+    };
+}
+async function resolveAuthenticatedEnvironment(command, actionLabel, options = {}) {
+    let cfg = (0, config_1.loadConfig)();
+    let workspaceAuth = null;
+    try {
+        workspaceAuth = options.workspacePath ? (0, workspaceAuth_1.findWorkspaceAuthConfig)(options.workspacePath) : null;
+    }
+    catch (error) {
+        if (error instanceof workspaceAuth_1.WorkspaceAuthConfigError) {
+            (0, messages_1.printErrorWithHelp)(`Invalid .playdrop.json at ${error.filePath}.`, [
+                'The file must be valid JSON.',
+                'It must include a non-empty "ownerUsername" string.',
+            ], { command });
+            process.exitCode = 1;
+            return null;
+        }
+        throw error;
+    }
+    if (workspaceAuth && !(0, config_1.getCurrentAccountSession)(cfg) && cfg.token && cfg.env) {
+        const provisionalEnvConfig = resolveConfiguredEnvironment(cfg.env, command, {
+            requireAuth: true,
+            allowDefaultPublicEnv: false,
+        });
+        if (!provisionalEnvConfig) {
+            return null;
+        }
+        const migrated = await migrateLegacyConfigIfNeeded(cfg, provisionalEnvConfig, command);
+        if (!migrated) {
+            return null;
+        }
+        cfg = migrated;
+    }
+    const currentAccount = (0, config_1.getCurrentAccountSession)(cfg) ?? buildLegacyAccountSession(cfg);
+    const selectedAccount = workspaceAuth
+        ? resolveWorkspaceSelectedAccount(cfg, currentAccount, workspaceAuth).account
+        : currentAccount;
+    if (!selectedAccount) {
+        if (workspaceAuth) {
+            const matchingSessions = (0, config_1.listAccountSessionsForUsername)(workspaceAuth.config.ownerUsername, cfg);
+            if (!workspaceAuth.config.env && matchingSessions.length > 1) {
+                (0, messages_1.printErrorWithHelp)(`This workspace is pinned to ${workspaceAuth.config.ownerUsername}, but that account is logged in on multiple environments.`, [
+                    `Run "playdrop auth use ${workspaceAuth.config.ownerUsername} --env <env>" to select the matching environment.`,
+                    'Or add an "env" field to .playdrop.json.',
+                ], { command });
+                process.exitCode = 1;
+                return null;
+            }
+            const envSuffix = workspaceAuth.config.env ? ` on ${workspaceAuth.config.env}` : '';
+            (0, messages_1.printErrorWithHelp)(`This workspace is pinned to ${workspaceAuth.config.ownerUsername}${envSuffix}, but that account is not logged in.`, [
+                `Run "playdrop auth login${workspaceAuth.config.env ? ` --env ${workspaceAuth.config.env}` : ''}" while authenticated as ${workspaceAuth.config.ownerUsername}.`,
+                'Or remove .playdrop.json if this workspace should use your current default account.',
+            ], { command });
+            process.exitCode = 1;
+            return null;
+        }
         (0, messages_1.printLoginRequired)(actionLabel, command);
         process.exitCode = 1;
-        return;
+        return null;
     }
-    const envConfig = resolveConfiguredEnvironment(cfg, command, {
+    const envConfig = resolveConfiguredEnvironment(selectedAccount.env, command, {
         requireAuth: true,
         allowDefaultPublicEnv: false,
     });
     if (!envConfig) {
+        return null;
+    }
+    return {
+        cfg: (0, config_1.loadConfig)(),
+        account: selectedAccount,
+        envConfig,
+    };
+}
+async function withEnvironment(command, actionLabel, callback, options = {}) {
+    const resolved = await resolveAuthenticatedEnvironment(command, actionLabel, options);
+    if (!resolved) {
         return;
     }
-    await callback(buildContext(cfg, envConfig));
+    await callback(buildContext(resolved.cfg, resolved.envConfig, resolved.account));
 }
 async function withPublicEnvironment(command, callback) {
     const cfg = (0, config_1.loadConfig)();
-    const envConfig = resolveConfiguredEnvironment(cfg, command, {
+    const account = (0, config_1.getCurrentAccountSession)(cfg);
+    const envConfig = resolveConfiguredEnvironment(account?.env ?? cfg.env, command, {
         requireAuth: false,
         allowDefaultPublicEnv: true,
     });
     if (!envConfig) {
         return;
     }
-    await callback(buildContext(cfg, envConfig));
+    await callback(buildContext(cfg, envConfig, account));
 }

package/dist/commands/accounts.d.ts

@@ -0,0 +1,2 @@
+export declare function listAccounts(): void;
+export declare function useAccount(username: string, env?: string): void;

package/dist/commands/accounts.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listAccounts = listAccounts;
+exports.useAccount = useAccount;
+const config_1 = require("../config");
+const messages_1 = require("../messages");
+function listAccounts() {
+    const accounts = (0, config_1.listAccountSessions)();
+    if (accounts.length === 0) {
+        const cfg = (0, config_1.loadConfig)();
+        if (cfg.token && cfg.env) {
+            console.log('Your current Playdrop session is using the legacy single-account format.');
+            console.log('Next: run "playdrop auth whoami" to migrate it into the multi-account store.');
+            return;
+        }
+        console.log('No Playdrop accounts are stored.');
+        console.log('Next: run "playdrop auth login" to add an account.');
+        return;
+    }
+    const current = (0, config_1.getCurrentAccountSession)();
+    for (const account of accounts) {
+        const marker = current && current.username === account.username && current.env === account.env ? '*' : ' ';
+        console.log(`${marker} ${account.username} (${account.env})`);
+    }
+    console.log('Next: run "playdrop auth use <username>" to switch the default account.');
+}
+function useAccount(username, env) {
+    const normalizedUsername = username.trim();
+    if (!normalizedUsername) {
+        (0, messages_1.printErrorWithHelp)('Provide the username of the account you want to use.', ['Run "playdrop auth accounts" to list stored accounts.'], { command: 'auth use' });
+        process.exitCode = 1;
+        return;
+    }
+    const existing = (0, config_1.findAccountSession)(normalizedUsername, env);
+    if (!existing) {
+        (0, messages_1.printErrorWithHelp)(env
+            ? `No stored Playdrop session was found for ${normalizedUsername} on ${env}.`
+            : `No stored Playdrop session was found for ${normalizedUsername}.`, [
+            'Run "playdrop auth accounts" to list stored accounts.',
+            `Run "playdrop auth login${env ? ` --env ${env}` : ''}" to add the missing session.`,
+        ], { command: 'auth use' });
+        process.exitCode = 1;
+        return;
+    }
+    (0, config_1.setCurrentAccount)({ username: normalizedUsername, env: env?.trim() || undefined });
+    console.log(`Current Playdrop account is now ${existing.username} (${existing.env}).`);
+    console.log('Next: run "playdrop auth whoami" to confirm your session.');
+}

package/dist/commands/capture.js

@@ -117,7 +117,6 @@ async function capture(targetArg, options = {}) {
         return;
     }
     const screenshotPath = options.screenshotPath ? (0, node_path_1.resolve)(process.cwd(), options.screenshotPath) : null;
-    const portToUse = 8888;
     let resolvedTarget;
     try {
         resolvedTarget = (0, devShared_1.resolveDevTarget)(targetArg, options.appName);
@@ -280,7 +279,12 @@ async function capture(targetArg, options = {}) {
         }
         const entryLabel = (0, node_path_1.relative)(process.cwd(), filePath) || filePath;
         console.log(`[capture] Preparing ${entryLabel} for ${env} (${appTypeSlug}).`);
-        const serverAlreadyRunning = await (0, devServer_1.isDevServerAvailable)(appName, portToUse, 750);
+        const serverAlreadyRunning = await (0, devServer_1.isDevServerAvailable)({
+            creatorUsername: currentUsername,
+            appType: appTypeSlug,
+            appName,
+            port: devServer_1.DEV_ROUTER_PORT,
+        }, 750);
         const devServerStartedByCapture = !serverAlreadyRunning;
         let serverHandle = null;
         let signalHandler = null;
@@ -299,14 +303,21 @@ async function capture(targetArg, options = {}) {
             }
         };
         if (serverAlreadyRunning) {
-            console.log(`[capture] Reusing dev server at http://localhost:${portToUse}/apps/${appName}.html`);
+            console.log(`[capture] Reusing dev server at ${(0, devServer_1.buildLocalDevAppUrl)({
+                creatorUsername: currentUsername,
+                appType: appTypeSlug,
+                appName,
+                port: devServer_1.DEV_ROUTER_PORT,
+            })}`);
         }
         else {
             try {
                 serverHandle = await (0, devServer_1.startDevServer)({
                     appName,
+                    appType: appTypeSlug,
+                    creatorUsername: currentUsername,
                     htmlPath: filePath,
-                    port: portToUse,
+                    port: devServer_1.DEV_ROUTER_PORT,
                     projectInfo,
                 });
                 signalHandler = () => {
@@ -316,10 +327,20 @@ async function capture(targetArg, options = {}) {
                 process.on('SIGTERM', signalHandler);
             }
             catch (error) {
-                (0, messages_1.printErrorWithHelp)(error?.message || `Failed to start dev server on port ${portToUse}.`, [
-                    'Check if another process is already using the port.',
-                    'Ensure the HTML file exists and is readable.',
-                ], { command: 'project capture' });
+                const mountConflict = (0, devServer_1.parseMountConflictError)(typeof error?.message === 'string' ? error.message : '');
+                if (mountConflict) {
+                    (0, messages_1.printErrorWithHelp)(`A different dev session already owns ${mountConflict.ref}.`, [
+                        `Active owner pid: ${mountConflict.ownerPid}.`,
+                        `Mounted repo root: ${mountConflict.repoRoot}.`,
+                        `Mounted HTML path: ${mountConflict.htmlPath}.`,
+                    ], { command: 'project capture' });
+                }
+                else {
+                    (0, messages_1.printErrorWithHelp)(error?.message || `Failed to start the shared dev router on port ${devServer_1.DEV_ROUTER_PORT}.`, [
+                        'Close the conflicting process or wait for the stale mount to exit.',
+                        'Ensure the HTML file exists and is readable.',
+                    ], { command: 'project capture' });
+                }
                 process.exitCode = 1;
                 return;
             }
@@ -381,5 +402,5 @@ async function capture(targetArg, options = {}) {
             }
             await cleanup();
         }
-    });
+    }, { workspacePath: resolvedTarget.cataloguePath ?? (0, node_path_1.dirname)(filePath) });
 }

package/dist/commands/captureListing.js

@@ -63,7 +63,6 @@ const MIN_DIMENSION = 16;
 const MAX_DIMENSION = 8192;
 const MAX_FPS = 120;
 const SUPPORTED_MACOS_PREFIX = '26.4';
-const DEV_SERVER_PORT = 8888;
 function parsePositiveNumber(raw, fallback, fieldName, { minimum = 0, maximum = Number.POSITIVE_INFINITY, integer = false, } = {}) {
     if (raw === undefined) {
         return fallback;
@@ -667,7 +666,12 @@ async function captureListing(targetArg, options = {}) {
         }
         const entryLabel = (0, node_path_1.relative)(process.cwd(), resolvedTarget.htmlPath) || resolvedTarget.htmlPath;
         console.log(`[listing] Preparing ${entryLabel} for ${env} (${appTypeSlug}).`);
-        const serverAlreadyRunning = await (0, devServer_1.isDevServerAvailable)(appName, DEV_SERVER_PORT, 750);
+        const serverAlreadyRunning = await (0, devServer_1.isDevServerAvailable)({
+            creatorUsername: currentUsername,
+            appType: appTypeSlug,
+            appName,
+            port: devServer_1.DEV_ROUTER_PORT,
+        }, 750);
         const devServerStartedByCapture = !serverAlreadyRunning;
         let serverHandle = null;
         let browserHandle = null;
@@ -686,13 +690,20 @@ async function captureListing(targetArg, options = {}) {
         };
         try {
             if (serverAlreadyRunning) {
-                console.log(`[listing] Reusing dev server at http://localhost:${DEV_SERVER_PORT}/apps/${appName}.html`);
+                console.log(`[listing] Reusing dev server at ${(0, devServer_1.buildLocalDevAppUrl)({
+                    creatorUsername: currentUsername,
+                    appType: appTypeSlug,
+                    appName,
+                    port: devServer_1.DEV_ROUTER_PORT,
+                })}`);
             }
             else {
                 serverHandle = await (0, devServer_1.startDevServer)({
                     appName,
+                    appType: appTypeSlug,
+                    creatorUsername: currentUsername,
                     htmlPath: resolvedTarget.htmlPath,
-                    port: DEV_SERVER_PORT,
+                    port: devServer_1.DEV_ROUTER_PORT,
                     projectInfo,
                 });
             }
@@ -800,5 +811,5 @@ async function captureListing(targetArg, options = {}) {
         finally {
             await cleanup();
         }
-    });
+    }, { workspacePath: resolvedTarget.cataloguePath ?? (0, node_path_1.dirname)(resolvedTarget.htmlPath) });
 }