@playdrop/playdrop-cli 0.5.5 → 0.6.0

package/dist/commands/upload-content.js

@@ -13,6 +13,7 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const types_1 = require("@playdrop/types");
 const model_artifacts_1 = require("../assets/model-artifacts");
+const assetSpecs_1 = require("../assetSpecs");
 const EXTENSION_TO_FORMAT = {
     '.png': 'PNG',
     '.jpg': 'JPEG',
@@ -174,21 +175,6 @@ function parseUnversionedAssetTaskRef(rawRef, fallbackCreator) {
     };
 }
 function buildAssetPackUploadPlans(tasks, defaultCreator, currentUserRole) {
-    const localAssetTasksByKey = new Map();
-    for (const task of tasks) {
-        if (task.kind !== 'asset') {
-            continue;
-        }
-        const creator = getTaskCreatorResult(task, defaultCreator, currentUserRole);
-        if (creator.creatorTargetError) {
-            return {
-                ok: false,
-                task,
-                message: creator.creatorTargetError,
-            };
-        }
-        localAssetTasksByKey.set(buildAssetKey(creator.taskCreator, task.name), task);
-    }
     const packPlansByKey = new Map();
     const ownedPackByAssetKey = new Map();
     for (const task of tasks) {
@@ -211,25 +197,18 @@ function buildAssetPackUploadPlans(tasks, defaultCreator, currentUserRole) {
             ownedAssetKeys: [],
             uploadKeyByAssetKey: new Map(),
         };
-        for (const assetRef of task.assets) {
-            const candidate = parseUnversionedAssetTaskRef(assetRef, creator.taskCreator);
-            if (!candidate || candidate.creatorUsername !== creator.taskCreator) {
-                continue;
-            }
-            const assetKey = buildAssetKey(candidate.creatorUsername, candidate.name);
-            if (!localAssetTasksByKey.has(assetKey)) {
-                continue;
-            }
+        for (const ownedAsset of task.ownedAssets) {
+            const assetKey = buildAssetKey(creator.taskCreator, ownedAsset.name);
             const existingOwner = ownedPackByAssetKey.get(assetKey);
             if (existingOwner && existingOwner.packKey !== packKey) {
                 return {
                     ok: false,
                     task,
-                    message: `Local asset "${candidate.name}" is referenced by multiple local asset packs in this upload run.`,
+                    message: `Pack owned asset "${ownedAsset.name}" is declared by multiple local asset packs in this upload run.`,
                 };
             }
             if (!plan.uploadKeyByAssetKey.has(assetKey)) {
-                plan.uploadKeyByAssetKey.set(assetKey, candidate.name);
+                plan.uploadKeyByAssetKey.set(assetKey, ownedAsset.name);
                 plan.ownedAssetKeys.push(assetKey);
             }
             ownedPackByAssetKey.set(assetKey, plan);
@@ -320,7 +299,10 @@ async function prepareAssetTaskUploadData(task) {
     if ('assetSpec' in task && typeof task.assetSpec === 'string' && task.assetSpec.trim().length > 0) {
         const uploadFiles = Object.entries(task.filePaths)
             .sort(([leftRole], [rightRole]) => leftRole.localeCompare(rightRole))
-            .map(([role, filePath]) => prepareUploadFile(filePath, role));
+            .map(([role, filePath]) => {
+            const roleContract = task.assetSpecContract?.roles.find((candidate) => candidate.name.trim().toLowerCase() === role.trim().toLowerCase());
+            return prepareUploadFile(filePath, role, (0, assetSpecs_1.resolveCustomAssetRoleContentType)(filePath, roleContract));
+        });
         return {
             assetSpec: task.assetSpec.trim(),
             uploadFiles,
@@ -372,6 +354,7 @@ async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername
             visibility: visibility,
             sourceKind: sourceAppVersionId ? 'APP_EMBEDDED' : 'UPLOAD',
             sourceAppVersionId,
+            runtimeKey: task.kind === 'owned-asset' ? task.runtimeKey : undefined,
             tags: task.kind === 'asset' ? task.tags : undefined,
             clearTags: task.kind === 'asset' ? options?.clearTags : undefined,
             shopListed: task.shopListed,
@@ -387,6 +370,7 @@ async function uploadAssetTask(client, task, sourceAppVersionId, creatorUsername
             visibility: visibility,
             sourceKind: sourceAppVersionId ? 'APP_EMBEDDED' : 'UPLOAD',
             sourceAppVersionId,
+            runtimeKey: task.kind === 'owned-asset' ? task.runtimeKey : undefined,
             tags: task.kind === 'asset' ? task.tags : undefined,
             clearTags: task.kind === 'asset' ? options?.clearTags : undefined,
             shopListed: task.shopListed,
@@ -520,14 +504,10 @@ function buildLocalAssetManifestEntries(preparedLocalAssets) {
         localAssets.push({
             uploadKey,
             name: localAsset.task.name,
-            displayName: localAsset.task.displayName,
-            category: (localAsset.task.assetSpec ? 'CUSTOM' : localAsset.task.category),
+            category: localAsset.task.category,
             subcategory: localAsset.prepared.subcategory ?? null,
-            format: (localAsset.prepared.format ?? 'CUSTOM'),
-            ...(localAsset.task.assetSpec ? { assetSpec: localAsset.task.assetSpec } : {}),
+            format: localAsset.prepared.format,
             visibility: localAsset.task.visibility,
-            remixRef: localAsset.task.remix,
-            tags: localAsset.task.tags,
             shopListed: localAsset.task.shopListed,
             shopPriceCredits: localAsset.task.shopPriceCredits,
             files: localAsset.prepared.manifestFiles,
@@ -538,9 +518,10 @@ function buildLocalAssetManifestEntries(preparedLocalAssets) {
 async function buildPackMembersAndExistingAssets(client, task, mutationCreatorUsername, uploadedAssets, uploadKeyByAssetKey) {
     const existingAssetsByRef = new Map();
     const members = [];
+    const ownedAssetNames = new Set(task.ownedAssets.map((asset) => asset.name));
     for (const rawRef of task.assets) {
         const localCandidate = parseUnversionedAssetTaskRef(rawRef, mutationCreatorUsername);
-        if (localCandidate && localCandidate.creatorUsername === mutationCreatorUsername) {
+        if (localCandidate && localCandidate.creatorUsername === mutationCreatorUsername && ownedAssetNames.has(localCandidate.name)) {
             const localAssetKey = buildAssetKey(localCandidate.creatorUsername, localCandidate.name);
             const localUploadKey = uploadKeyByAssetKey.get(localAssetKey);
             if (localUploadKey) {
@@ -598,7 +579,7 @@ function buildPackListingPayload(listingUploads) {
         videosLandscape: listingUploads.filter((entry) => entry.mediaKey.startsWith('videosLandscape:')).map((entry) => entry.entry),
     };
 }
-function buildPackInitializeRequest(task, localAssets, existingAssets, members, listingUploads, options) {
+function buildPackInitializeRequest(task, ownedAssets, existingAssets, members, listingUploads, options) {
     return {
         version: task.version,
         displayName: task.displayName,
@@ -610,7 +591,7 @@ function buildPackInitializeRequest(task, localAssets, existingAssets, members,
         externalUrl: task.externalUrl,
         downloadUrl: task.downloadUrl,
         releaseNotes: task.releaseNotes,
-        localAssets,
+        ownedAssets,
         existingAssets,
         members,
         listing: buildPackListingPayload(listingUploads),
@@ -655,10 +636,10 @@ function buildUploadedPackInfo(creatorUsername, task, versionNodeId, versionAsse
 async function uploadAssetPackTask(client, task, creatorUsername, uploadedAssets, localAssetTasks, uploadKeyByAssetKey, targetCreatorUsername, options) {
     const mutationCreatorUsername = resolveMutationCreatorUsername(task, creatorUsername, targetCreatorUsername);
     const preparedLocalAssets = await prepareLocalPackAssets(task, mutationCreatorUsername, localAssetTasks, uploadKeyByAssetKey);
-    const localAssets = buildLocalAssetManifestEntries(preparedLocalAssets);
+    const ownedAssets = buildLocalAssetManifestEntries(preparedLocalAssets);
     const { existingAssets, members } = await buildPackMembersAndExistingAssets(client, task, mutationCreatorUsername, uploadedAssets, uploadKeyByAssetKey);
     const listingUploads = buildPackListingUploads(task);
-    const initializeBody = buildPackInitializeRequest(task, localAssets, existingAssets, members, listingUploads, options);
+    const initializeBody = buildPackInitializeRequest(task, ownedAssets, existingAssets, members, listingUploads, options);
     const initializeResponse = await client.initializeAssetPackUpload(mutationCreatorUsername, task.name, initializeBody);
     if (initializeResponse.status === 'finalized') {
         if (!initializeResponse.versionNodeId || !initializeResponse.version) {

package/dist/commands/upload.js

@@ -208,7 +208,7 @@ function appendOverviewLink(entry, task, portalBase, creator) {
     else if (task.kind === 'asset-spec') {
         url = null;
     }
-    else if (task.kind === 'asset' || task.kind === 'embedded-asset') {
+    else if (task.kind === 'asset' || task.kind === 'owned-asset') {
         url = buildAssetOverviewUrl(portalBase, creator, task.name);
     }
     else if (task.kind === 'asset-pack') {
@@ -220,7 +220,7 @@ function appendOverviewLink(entry, task, portalBase, creator) {
     entry.detail = entry.detail ? `${entry.detail} | view: ${url}` : `view: ${url}`;
 }
 function buildTaskEntityId(task, creatorUsername) {
-    return task.kind === 'embedded-asset'
+    return task.kind === 'owned-asset'
         ? `${creatorUsername}/${task.appName}:${task.name}`
         : `${creatorUsername}/${task.name}`;
 }
@@ -304,12 +304,6 @@ async function uploadAppTask(state, task, taskCreator, options) {
     state.uploadedAppsByName.set(task.name, uploadedApp);
     (0, upload_graph_1.registerCanonicalNode)(state.graphState, appRef, uploadedApp.versionNodeId);
     (0, upload_graph_1.registerLocalRef)(state.graphState.localAppNodeByName, state.graphState.ambiguousAppNames, task.name, uploadedApp.versionNodeId);
-    task.uses.assets.forEach((toRef, index) => {
-        (0, upload_graph_1.appendPendingRelation)(state.graphState, uploadedApp.versionNodeId, 'USES', toRef, `[${task.cataloguePath}] app "${task.name}" uses.assets[${index}]`);
-    });
-    task.uses.packs.forEach((toRef, index) => {
-        (0, upload_graph_1.appendPendingRelation)(state.graphState, uploadedApp.versionNodeId, 'USES', toRef, `[${task.cataloguePath}] app "${task.name}" uses.packs[${index}]`);
-    });
     appendTaskRelations(state.graphState, uploadedApp.versionNodeId, task.graph.relations, `[${task.cataloguePath}] app "${task.name}"`);
     const entry = {
         action: 'upload',
@@ -368,10 +362,10 @@ async function uploadStandaloneAssetTask(state, task, taskCreator, options) {
     appendOverviewLink(entry, task, state.portalBase, uploaded.creatorUsername);
     return entry;
 }
-async function uploadEmbeddedAssetTask(state, task, taskCreator) {
+async function uploadOwnedAssetTask(state, task, taskCreator) {
     const sourceApp = state.uploadedAppsByName.get(task.appName);
     if (!sourceApp) {
-        throw new Error(`Embedded asset "${task.name}" references app "${task.appName}" that was not uploaded in this run.`);
+        throw new Error(`Owned asset "${task.name}" references app "${task.appName}" that was not uploaded in this run.`);
     }
     const uploaded = await (0, upload_content_1.uploadAssetTask)(state.client, task, sourceApp.versionId, sourceApp.creatorUsername);
     state.uploadedAssetsByKey.set(`${uploaded.creatorUsername}/${uploaded.name}`, uploaded);
@@ -380,7 +374,7 @@ async function uploadEmbeddedAssetTask(state, task, taskCreator) {
     const entry = {
         action: 'upload',
         status: 'success',
-        entityType: 'embedded-asset',
+        entityType: 'owned-asset',
         entityId: buildTaskEntityId(task, taskCreator),
         catalogue: task.cataloguePath,
         detail: `${uploaded.ref} (source app version ${sourceApp.versionId})`,
@@ -394,13 +388,7 @@ function collectPackLocalAssetTasks(state, task, taskCreator) {
     if (!packPlan) {
         throw new Error(`Asset pack "${task.name}@${task.version}" is missing an upload plan.`);
     }
-    const localAssetTasks = packPlan.ownedAssetKeys.map((assetKey) => {
-        const ownedTask = state.sortedTasks.find((candidate) => candidate.kind === 'asset' && (0, upload_content_1.buildAssetKey)(taskCreator, candidate.name) === assetKey);
-        if (!ownedTask || ownedTask.kind !== 'asset') {
-            throw new Error(`Asset pack "${task.name}@${task.version}" is missing local asset task "${assetKey}".`);
-        }
-        return ownedTask;
-    });
+    const localAssetTasks = task.ownedAssets.filter((ownedAsset) => packPlan.ownedAssetKeys.includes((0, upload_content_1.buildAssetKey)(taskCreator, ownedAsset.name)));
     return { packKey, packPlan, localAssetTasks };
 }
 function registerUploadedLocalPackAssets(state, task, taskCreator, packPlan, localAssetTasks, uploadedPack) {
@@ -427,7 +415,6 @@ function registerUploadedLocalPackAssets(state, task, taskCreator, packPlan, loc
         state.uploadedAssetsByKey.set((0, upload_content_1.buildAssetKey)(uploadedLocalAsset.creatorUsername, uploadedLocalAsset.name), uploadedLocalRef);
         (0, upload_graph_1.registerCanonicalNode)(state.graphState, uploadedLocalRef.ref, uploadedLocalRef.versionNodeId);
         (0, upload_graph_1.registerLocalRef)(state.graphState.localAssetNodeByName, state.graphState.ambiguousAssetNames, localTask.name, uploadedLocalRef.versionNodeId);
-        appendTaskRelations(state.graphState, uploadedLocalRef.versionNodeId, localTask.relations, `[${localTask.cataloguePath}] asset "${localTask.name}"`);
     }
 }
 async function uploadPackTask(state, task, taskCreator, options) {
@@ -461,8 +448,8 @@ async function processSingleUploadTask(state, task, taskCreator, options) {
     if (task.kind === 'asset') {
         return await uploadStandaloneAssetTask(state, task, taskCreator, options);
     }
-    if (task.kind === 'embedded-asset') {
-        return await uploadEmbeddedAssetTask(state, task, taskCreator);
+    if (task.kind === 'owned-asset') {
+        return await uploadOwnedAssetTask(state, task, taskCreator);
     }
     if (task.kind === 'asset-pack') {
         return await uploadPackTask(state, task, taskCreator, options);
@@ -544,63 +531,66 @@ async function processUploadTasks(client, tasks, owner, ownerUsername, currentUs
     return results;
 }
 async function upload(pathOrName, options) {
-    await (0, commandContext_1.withEnvironment)('project publish', 'Publishing content', async ({ client, env, envConfig }) => {
-        let userInfo = { username: null, role: null };
-        try {
-            userInfo = await fetchCurrentUserInfo(client, envConfig.apiBase);
-        }
-        catch (error) {
-            if (error instanceof http_1.CLIUnsupportedClientError) {
-                return;
-            }
-            throw error;
-        }
-        const owner = typeof userInfo.username === 'string' && userInfo.username.trim().length > 0
-            ? userInfo.username.trim()
-            : 'unknown';
-        const selection = (0, taskSelection_1.selectTasks)(pathOrName);
-        const workspaceRoot = resolveUploadWorkspaceRoot(pathOrName, selection.resolution);
-        const tagGroupLoad = (0, catalogue_1.resolveCatalogueTagGroups)(workspaceRoot);
-        if (tagGroupLoad.errors.length > 0) {
-            (0, taskSelection_1.reportTaskErrors)(tagGroupLoad.errors.map((message) => ({
-                type: 'invalid-catalogue',
-                message,
-                help: ['Update the tagGroups entries noted above, then retry the publish.'],
-            })), 'project publish');
-            process.exitCode = 1;
-            return;
-        }
-        if (selection.errors.length > 0) {
-            const canPublishTagGroupsOnly = selection.errors.every((error) => error.type === 'no-tasks') && tagGroupLoad.groups.length > 0;
-            if (canPublishTagGroupsOnly) {
-                selection.errors.length = 0;
-            }
-        }
-        if (selection.errors.length > 0) {
-            (0, taskSelection_1.reportTaskErrors)(selection.errors, 'project publish');
-            process.exitCode = 1;
-            return;
-        }
-        const warnings = selection.warnings;
-        const tasks = selection.tasks;
-        if (tagGroupLoad.groups.length > 0 && userInfo.role !== 'ADMIN') {
-            (0, messages_1.printErrorWithHelp)('Publishing tagGroups requires an admin account.', [
-                'Log in as an admin before publishing taxonomy changes.',
-                'Remove tagGroups from catalogue.json if this publish should only upload content.',
-            ], { command: 'project publish' });
-            process.exitCode = 1;
+    const selection = (0, taskSelection_1.selectTasks)(pathOrName);
+    const workspaceRoot = resolveUploadWorkspaceRoot(pathOrName, selection.resolution);
+    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)('project publish', 'Publishing content', { workspacePath: workspaceRoot });
+    if (!ctx) {
+        return;
+    }
+    const { client, env, envConfig } = ctx;
+    let userInfo = { username: null, role: null };
+    try {
+        userInfo = await fetchCurrentUserInfo(client, envConfig.apiBase);
+    }
+    catch (error) {
+        if (error instanceof http_1.CLIUnsupportedClientError) {
             return;
         }
-        const results = [];
-        if (tagGroupLoad.groups.length > 0) {
-            const taxonomyEntries = await syncTagGroupsFromCatalogue(client, tagGroupLoad.groups);
-            taxonomyEntries.forEach((entry) => pushLoggedEntry(results, entry));
-        }
-        if (tasks.length > 0) {
-            const uploadEntries = await processUploadTasks(client, tasks, owner, userInfo.username, userInfo.role, envConfig.webBase, options);
-            results.push(...uploadEntries);
+        throw error;
+    }
+    const owner = typeof userInfo.username === 'string' && userInfo.username.trim().length > 0
+        ? userInfo.username.trim()
+        : 'unknown';
+    const tagGroupLoad = (0, catalogue_1.resolveCatalogueTagGroups)(workspaceRoot);
+    if (tagGroupLoad.errors.length > 0) {
+        (0, taskSelection_1.reportTaskErrors)(tagGroupLoad.errors.map((message) => ({
+            type: 'invalid-catalogue',
+            message,
+            help: ['Update the tagGroups entries noted above, then retry the publish.'],
+        })), 'project publish');
+        process.exitCode = 1;
+        return;
+    }
+    if (selection.errors.length > 0) {
+        const canPublishTagGroupsOnly = selection.errors.every((error) => error.type === 'no-tasks') && tagGroupLoad.groups.length > 0;
+        if (canPublishTagGroupsOnly) {
+            selection.errors.length = 0;
         }
-        (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'upload', environment: env });
-        (0, uploadLog_1.printPublishedAppNextSteps)(results);
-    });
+    }
+    if (selection.errors.length > 0) {
+        (0, taskSelection_1.reportTaskErrors)(selection.errors, 'project publish');
+        process.exitCode = 1;
+        return;
+    }
+    const warnings = selection.warnings;
+    const tasks = selection.tasks;
+    if (tagGroupLoad.groups.length > 0 && userInfo.role !== 'ADMIN') {
+        (0, messages_1.printErrorWithHelp)('Publishing tagGroups requires an admin account.', [
+            'Log in as an admin before publishing taxonomy changes.',
+            'Remove tagGroups from catalogue.json if this publish should only upload content.',
+        ], { command: 'project publish' });
+        process.exitCode = 1;
+        return;
+    }
+    const results = [];
+    if (tagGroupLoad.groups.length > 0) {
+        const taxonomyEntries = await syncTagGroupsFromCatalogue(client, tagGroupLoad.groups);
+        taxonomyEntries.forEach((entry) => pushLoggedEntry(results, entry));
+    }
+    if (tasks.length > 0) {
+        const uploadEntries = await processUploadTasks(client, tasks, owner, userInfo.username, userInfo.role, envConfig.webBase, options);
+        results.push(...uploadEntries);
+    }
+    (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'upload', environment: env });
+    (0, uploadLog_1.printPublishedAppNextSteps)(results);
 }

package/dist/commands/validate.js

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validate = validate;
 const types_1 = require("@playdrop/types");
 const types_2 = require("@playdrop/types");
-const apiClient_1 = require("../apiClient");
-const config_1 = require("../config");
-const environment_1 = require("../environment");
+const commandContext_1 = require("../commandContext");
 const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
@@ -59,21 +57,12 @@ function validateAssetTask(task, assetSpecLookups) {
         throw new Error(errors.join(' '));
     }
 }
-async function loadAuthenticatedValidationContext() {
-    const config = (0, config_1.loadConfig)();
-    const token = typeof config.token === 'string' ? config.token.trim() : '';
-    if (!token) {
+async function loadAuthenticatedValidationContext(workspacePath) {
+    const ctx = await (0, commandContext_1.resolveOptionalEnvironmentContext)('project validate', { workspacePath });
+    if (!ctx) {
         return null;
     }
-    const envName = typeof config.env === 'string' && config.env.trim().length > 0 ? config.env.trim() : 'prod';
-    const envConfig = (0, environment_1.resolveEnvironmentConfig)(envName);
-    if (!envConfig) {
-        return null;
-    }
-    const client = (0, apiClient_1.createCliApiClient)({
-        baseUrl: envConfig.apiBase,
-        token,
-    });
+    const { client } = ctx;
     try {
         const me = await client.me();
         const username = typeof me?.user?.username === 'string' ? me.user.username.trim() : '';
@@ -90,13 +79,16 @@ async function loadAuthenticatedValidationContext() {
         return null;
     }
 }
+function resolveValidationWorkspacePath(pathOrName, resolution) {
+    return resolution === 'name' ? process.cwd() : pathOrName;
+}
 function formatLiveTagClearWarning(input) {
     const countLabel = input.liveTagCount === 1 ? '1 existing live tag' : `${input.liveTagCount} existing live tags`;
     return `${input.entityLabel} "${input.displayName}" would remove ${countLabel} on publish. Add a tags field or pass --clear-tags to confirm.`;
 }
 // eslint-disable-next-line complexity
-async function collectLiveTagClearWarnings(tasks) {
-    const context = await loadAuthenticatedValidationContext();
+async function collectLiveTagClearWarnings(tasks, workspacePath) {
+    const context = await loadAuthenticatedValidationContext(workspacePath);
     if (!context) {
         return [];
     }
@@ -192,7 +184,7 @@ async function validate(pathOrName) {
             else if (task.kind === 'asset') {
                 validateAssetTask(task, assetSpecLookups);
             }
-            else if (task.kind === 'embedded-asset' || task.kind === 'asset-pack') {
+            else if (task.kind === 'owned-asset' || task.kind === 'asset-pack') {
                 // Structural validation already ran during catalogue parsing.
             }
             else {
@@ -222,7 +214,8 @@ async function validate(pathOrName) {
             console.log((0, uploadLog_1.formatTaskLogLine)(entry));
         }
     }
-    const liveTagWarnings = await collectLiveTagClearWarnings(sortedTasks);
+    const workspacePath = resolveValidationWorkspacePath(pathOrName, selection.resolution);
+    const liveTagWarnings = await collectLiveTagClearWarnings(sortedTasks, workspacePath);
     liveTagWarnings.forEach((warning) => warnings.add(warning));
     (0, uploadLog_1.printTaskSummary)(results, warnings, { action: 'validate' });
 }

package/dist/commands/whoami.js

@@ -3,33 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.whoami = whoami;
 const types_1 = require("@playdrop/types");
 const config_1 = require("../config");
-const apiClient_1 = require("../apiClient");
+const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
-const environment_1 = require("../environment");
 const messages_1 = require("../messages");
 async function whoami() {
-    const cfg = (0, config_1.loadConfig)();
-    const currentAccount = (0, config_1.getCurrentAccountSession)(cfg);
-    if (!cfg.token || !cfg.env) {
-        (0, messages_1.printLoginRequired)('Checking your Playdrop account status', 'whoami');
-        process.exitCode = 1;
-        return;
-    }
-    const envConfig = (0, environment_1.resolveEnvironmentConfig)(cfg.env);
-    if (!envConfig) {
-        const choices = (0, environment_1.formatEnvironmentList)();
-        (0, messages_1.printUnknownEnvironment)(cfg.env, choices, 'whoami');
-        process.exitCode = 1;
+    const ctx = await (0, commandContext_1.resolveAuthenticatedEnvironmentContext)('whoami', 'Checking your Playdrop account status', { workspacePath: process.cwd() });
+    if (!ctx) {
         return;
     }
-    if (envConfig.allowInsecureRequests) {
-        process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-    }
-    const base = envConfig.apiBase;
-    async function doMe(currentBase) {
-        const client = (0, apiClient_1.createCliApiClient)({ baseUrl: currentBase, token: cfg.token });
+    const resolvedCtx = ctx;
+    const globalCurrentAccount = (0, config_1.getCurrentAccountSession)((0, config_1.loadConfig)());
+    const hadStoredCurrentAccount = Boolean(globalCurrentAccount);
+    async function doMe() {
         try {
-            return await client.me();
+            return await resolvedCtx.client.me();
         }
         catch (unknownError) {
             if (unknownError instanceof types_1.UnsupportedClientError) {
@@ -48,7 +35,7 @@ async function whoami() {
     }
     let data = null;
     try {
-        data = await doMe(base);
+        data = await doMe();
     }
     catch (e) {
         if (e instanceof http_1.CLIUnsupportedClientError) {
@@ -69,13 +56,23 @@ async function whoami() {
         process.exitCode = 1;
         return;
     }
-    if (!currentAccount) {
+    if (!hadStoredCurrentAccount) {
         (0, config_1.migrateLegacySession)({
             username,
-            env: envConfig.name,
-            token: cfg.token,
+            env: resolvedCtx.env,
+            token: resolvedCtx.token,
         });
     }
-    console.log(`${username} (${envConfig.name})`);
+    if (resolvedCtx.workspaceAuth) {
+        console.log(`Workspace account: ${username} (${resolvedCtx.env})`);
+        console.log('Resolved from: .playdrop.json');
+        if (globalCurrentAccount
+            && (globalCurrentAccount.username !== username || globalCurrentAccount.env !== resolvedCtx.env)) {
+            console.log(`Global default: ${globalCurrentAccount.username} (${globalCurrentAccount.env})`);
+        }
+    }
+    else {
+        console.log(`${username} (${resolvedCtx.env})`);
+    }
     console.log('Next: run "playdrop getting-started" to see the recommended workflow.');
 }

package/dist/devAuth.d.ts

@@ -0,0 +1,16 @@
+export type HostedDevAuthMode = 'prompt' | 'anonymous' | 'viewer' | 'player';
+export type HostedCaptureDevAuthMode = Exclude<HostedDevAuthMode, 'prompt'>;
+export type ResetDevPlayerMode = 'before' | 'after' | 'before-and-after' | 'never';
+export type HostedDevAuthSelection = {
+    devAuth: HostedDevAuthMode;
+    player: 1 | 2 | 3 | 4 | null;
+};
+export declare function parseHostedDevPlayerSlot(value: string | number | undefined): 1 | 2 | 3 | 4 | null;
+export declare function parseHostedDevAuthSelection(input: {
+    devAuth?: string;
+    player?: string | number;
+    defaultMode: HostedDevAuthMode;
+    allowPrompt: boolean;
+}): HostedDevAuthSelection;
+export declare function parseResetDevPlayerMode(value: string | undefined): ResetDevPlayerMode;
+export declare function applyHostedDevAuthSelectionToUrl(url: string, selection: HostedDevAuthSelection): string;

package/dist/devAuth.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHostedDevPlayerSlot = parseHostedDevPlayerSlot;
+exports.parseHostedDevAuthSelection = parseHostedDevAuthSelection;
+exports.parseResetDevPlayerMode = parseResetDevPlayerMode;
+exports.applyHostedDevAuthSelectionToUrl = applyHostedDevAuthSelectionToUrl;
+function parseHostedDevPlayerSlot(value) {
+    if (value === undefined) {
+        return null;
+    }
+    const normalized = String(value).trim();
+    if (normalized === '1' || normalized === '2' || normalized === '3' || normalized === '4') {
+        return Number.parseInt(normalized, 10);
+    }
+    return null;
+}
+function parseHostedDevAuthSelection(input) {
+    const normalizedMode = (input.devAuth?.trim().toLowerCase() || input.defaultMode);
+    if (!input.allowPrompt && normalizedMode === 'prompt') {
+        throw new Error('dev_auth_prompt_not_supported');
+    }
+    if (normalizedMode !== 'prompt'
+        && normalizedMode !== 'anonymous'
+        && normalizedMode !== 'viewer'
+        && normalizedMode !== 'player') {
+        throw new Error('dev_auth_invalid');
+    }
+    if (normalizedMode !== 'player') {
+        return {
+            devAuth: normalizedMode,
+            player: null,
+        };
+    }
+    const player = parseHostedDevPlayerSlot(input.player);
+    if (player === null) {
+        throw new Error('dev_auth_player_slot_required');
+    }
+    return {
+        devAuth: normalizedMode,
+        player,
+    };
+}
+function parseResetDevPlayerMode(value) {
+    const normalized = value?.trim().toLowerCase() || 'never';
+    if (normalized === 'before' || normalized === 'after' || normalized === 'before-and-after' || normalized === 'never') {
+        return normalized;
+    }
+    throw new Error('reset_dev_player_invalid');
+}
+function applyHostedDevAuthSelectionToUrl(url, selection) {
+    const nextUrl = new URL(url);
+    nextUrl.searchParams.set('devAuth', selection.devAuth);
+    if (selection.devAuth === 'player' && selection.player) {
+        nextUrl.searchParams.set('player', String(selection.player));
+    }
+    else {
+        nextUrl.searchParams.delete('player');
+    }
+    return nextUrl.toString();
+}