@playdrop/playdrop-cli 0.16.16 → 0.17.1

package/dist/catalogue.js

@@ -23,13 +23,9 @@ const LISTING_VIDEO_EXTENSIONS = new Set([".mp4"]);
 exports.APP_DESCRIPTION_RECOMMENDED_MIN_CHARACTERS = 120;
 exports.APP_DESCRIPTION_RECOMMENDED_MIN_WORDS = 20;
 exports.APP_RELEASE_NOTES_MAX_CHARACTERS = 240;
-const BOXEL_GENERATED_FILE_ROLES = new Set(["mesh", "preview"]);
-const BOXEL_REQUIRED_FILE_ROLES = ["primary", "mesh", "preview"];
-const VOX_GENERATED_FILE_ROLES = new Set(["boxel", "mesh", "preview"]);
-const VOX_REQUIRED_FILE_ROLES = ["primary", "boxel", "mesh", "preview"];
 const MAX_CONTENT_TAGS_PER_ITEM = 20;
 const APP_ALLOWED_LICENSES = new Set(["CLOSED", "PLAYDROP", "MIT"]);
-const ASSET_ALLOWED_LICENSES = new Set(["CLOSED", "PLAYDROP", "CC0"]);
+const ASSET_ALLOWED_LICENSES = new Set(["CLOSED", "PLAYDROP", "MIT", "CC0"]);
 const ASSET_SUBCATEGORY_SET_BY_CATEGORY = types_1.ASSET_SUBCATEGORY_DEFINITIONS.reduce((acc, definition) => {
     if (!acc[definition.category]) {
         acc[definition.category] = new Set();
@@ -56,38 +52,6 @@ function normalizeAppReleaseNotes(value, options = {}) {
     }
     return releaseNotes;
 }
-function normalizeFileRole(role) {
-    return role.trim().toLowerCase();
-}
-function inferGeneratedModel3DFormat(category, subcategory, format, files) {
-    if (category !== "MODEL_3D" || !(0, types_1.isModel3DAssetSubcategory)("MODEL_3D", subcategory)) {
-        return null;
-    }
-    const normalizedFormat = typeof format === "string" ? format.trim().toUpperCase() : "";
-    if (normalizedFormat === "PLAYDROP_BOXEL_JSON" || normalizedFormat === "VOX") {
-        return normalizedFormat;
-    }
-    const primary = typeof files?.primary === "string" ? files.primary.trim().toLowerCase() : "";
-    if (primary.endsWith(".boxel.json")) {
-        return "PLAYDROP_BOXEL_JSON";
-    }
-    if (primary.endsWith(".vox")) {
-        return "VOX";
-    }
-    return null;
-}
-function getGeneratedModel3DFileRoles(format) {
-    if (format === "VOX") {
-        return {
-            generated: VOX_GENERATED_FILE_ROLES,
-            required: VOX_REQUIRED_FILE_ROLES,
-        };
-    }
-    return {
-        generated: BOXEL_GENERATED_FILE_ROLES,
-        required: BOXEL_REQUIRED_FILE_ROLES,
-    };
-}
 function extractGlbJsonChunk(buffer) {
     if (buffer.length < 20) {
         throw new Error("invalid_glb_payload");
@@ -1228,6 +1192,56 @@ function buildAppTasks(rootDir, catalogues, options) {
                 }
                 authMode = rawAuthMode;
             }
+            let server = null;
+            if (Object.prototype.hasOwnProperty.call(entry, "server")) {
+                const rawServer = entry.server;
+                if (!rawServer || typeof rawServer !== "object" || Array.isArray(rawServer)) {
+                    errors.push(`[${label}] Skipping ${rawName}: server must be an object with entry and rooms.`);
+                    continue;
+                }
+                const unknownServerKeys = Object.keys(rawServer).filter((key) => key !== "entry" && key !== "rooms");
+                if (unknownServerKeys.length > 0) {
+                    errors.push(`[${label}] Skipping ${rawName}: server contains unsupported key "${unknownServerKeys[0]}".`);
+                    continue;
+                }
+                const serverEntry = typeof rawServer.entry === "string" ? rawServer.entry.trim().replace(/\\/g, "/") : "";
+                if (!serverEntry || (!serverEntry.endsWith(".ts") && !serverEntry.endsWith(".mts"))) {
+                    errors.push(`[${label}] Skipping ${rawName}: server.entry must be a project-local TypeScript file.`);
+                    continue;
+                }
+                const serverEntryPath = (0, node_path_1.resolve)(file.directory, serverEntry);
+                const relativeServerEntry = (0, node_path_1.relative)(file.directory, serverEntryPath);
+                if (relativeServerEntry.startsWith("..") || relativeServerEntry === "") {
+                    errors.push(`[${label}] Skipping ${rawName}: server.entry must stay inside the project directory.`);
+                    continue;
+                }
+                if (!(0, node_fs_1.existsSync)(serverEntryPath) || !(0, node_fs_1.statSync)(serverEntryPath).isFile()) {
+                    errors.push(`[${label}] Skipping ${rawName}: server.entry was not found at ${serverEntryPath}.`);
+                    continue;
+                }
+                if (!Array.isArray(rawServer.rooms) || rawServer.rooms.length < 1 || rawServer.rooms.length > 2) {
+                    errors.push(`[${label}] Skipping ${rawName}: server.rooms must contain one or two room names.`);
+                    continue;
+                }
+                const roomNames = rawServer.rooms.map((value) => (typeof value === "string" ? value.trim() : ""));
+                if (roomNames.some((room) => !/^[a-z][a-z0-9_-]{0,63}$/.test(room))) {
+                    errors.push(`[${label}] Skipping ${rawName}: server room names must start with a lowercase letter and use only lowercase letters, digits, _ or - (max 64 characters).`);
+                    continue;
+                }
+                if (new Set(roomNames).size !== roomNames.length) {
+                    errors.push(`[${label}] Skipping ${rawName}: server.rooms must not contain duplicates.`);
+                    continue;
+                }
+                if (isExternalMode) {
+                    errors.push(`[${label}] Skipping ${rawName}: server is supported only for HOSTED apps.`);
+                    continue;
+                }
+                if (!packageJsonPath) {
+                    errors.push(`[${label}] Skipping ${rawName}: server apps require a package.json in the project.`);
+                    continue;
+                }
+                server = { entry: serverEntry, entryPath: serverEntryPath, rooms: roomNames };
+            }
             let controllerMode;
             const rawControllerMode = typeof entry.controllerMode === "string" ? entry.controllerMode.trim().toUpperCase() : "";
             if (rawControllerMode) {
@@ -1454,6 +1468,60 @@ function buildAppTasks(rootDir, catalogues, options) {
                 }
                 design = parsedDesign.value;
             }
+            let players;
+            if (Object.prototype.hasOwnProperty.call(entry, "players")) {
+                const parsedPlayers = (0, types_1.normalizeAppPlayers)(entry.players);
+                if (!parsedPlayers.ok) {
+                    errors.push(`[${label}] App "${rawName}" ${parsedPlayers.error}`);
+                    continue;
+                }
+                players = parsedPlayers.value;
+            }
+            const normalizeLongFormText = (field) => {
+                if (!Object.prototype.hasOwnProperty.call(entry, field)) {
+                    return undefined;
+                }
+                const raw = entry[field];
+                if (typeof raw !== "string" || raw.trim().length === 0) {
+                    errors.push(`[${label}] App "${rawName}" ${field} must be a non-empty Markdown string.`);
+                    return undefined;
+                }
+                return raw.trim();
+            };
+            const makingOf = normalizeLongFormText("makingOf");
+            const controls = normalizeLongFormText("controls");
+            if ((Object.prototype.hasOwnProperty.call(entry, "makingOf") && !makingOf) ||
+                (Object.prototype.hasOwnProperty.call(entry, "controls") && !controls)) {
+                continue;
+            }
+            let creation;
+            if (Object.prototype.hasOwnProperty.call(entry, "creation")) {
+                const parsedCreation = (0, types_1.normalizeAppCreationMetadata)(entry.creation);
+                if (!parsedCreation.ok) {
+                    errors.push(`[${label}] App "${rawName}" ${parsedCreation.error}`);
+                    continue;
+                }
+                creation = parsedCreation.value;
+            }
+            let sourceRepository;
+            if (Object.prototype.hasOwnProperty.call(entry, "sourceRepository")) {
+                const rawSourceRepository = entry.sourceRepository;
+                if (typeof rawSourceRepository !== "string" || rawSourceRepository.trim().length === 0) {
+                    errors.push(`[${label}] App "${rawName}" sourceRepository must be a non-empty HTTPS URL.`);
+                    continue;
+                }
+                try {
+                    const parsedSourceRepository = new URL(rawSourceRepository.trim());
+                    if (parsedSourceRepository.protocol !== "https:") {
+                        throw new Error("invalid_source_repository");
+                    }
+                    sourceRepository = parsedSourceRepository.toString();
+                }
+                catch {
+                    errors.push(`[${label}] App "${rawName}" sourceRepository must be a non-empty HTTPS URL.`);
+                    continue;
+                }
+            }
             let tweaks;
             if (Object.prototype.hasOwnProperty.call(entry, "tweaks")) {
                 const parsedTweaks = (0, types_1.normalizeAppTweaks)(entry.tweaks);
@@ -1503,12 +1571,6 @@ function buildAppTasks(rootDir, catalogues, options) {
                 const ownedFormat = typeof owned?.format === "string" && owned.format.trim().length > 0
                     ? owned.format.trim().toUpperCase()
                     : undefined;
-                const generatedModel3DFormat = subcategory
-                    ? inferGeneratedModel3DFormat(category, subcategory, ownedFormat, fileEntries)
-                    : null;
-                const generatedModel3DRoles = generatedModel3DFormat
-                    ? getGeneratedModel3DFileRoles(generatedModel3DFormat)
-                    : null;
                 if (!fileEntries || Object.keys(fileEntries).length === 0) {
                     errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" must define files.`);
                     continue;
@@ -1524,14 +1586,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                     }
                     const relativeEmbeddedPath = fileValue.trim();
                     const absoluteEmbeddedPath = (0, node_path_1.resolve)(file.directory, relativeEmbeddedPath);
-                    const normalizedRole = normalizeFileRole(role);
-                    const allowMissingGenerated = Boolean(generatedModel3DRoles?.generated.has(normalizedRole));
                     if (!(0, node_fs_1.existsSync)(absoluteEmbeddedPath) || !(0, node_fs_1.statSync)(absoluteEmbeddedPath).isFile()) {
-                        if (allowMissingGenerated) {
-                            files[role] = relativeEmbeddedPath.replace(/\\/g, "/");
-                            filePaths[role] = absoluteEmbeddedPath;
-                            continue;
-                        }
                         errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" file not found at ${absoluteEmbeddedPath}.`);
                         ownedAssetHasError = true;
                         continue;
@@ -1542,14 +1597,6 @@ function buildAppTasks(rootDir, catalogues, options) {
                 if (ownedAssetHasError) {
                     continue;
                 }
-                if (generatedModel3DRoles) {
-                    const normalizedRoles = new Set(Object.keys(files).map((role) => normalizeFileRole(role)));
-                    const missingRoles = generatedModel3DRoles.required.filter((role) => !normalizedRoles.has(role));
-                    if (missingRoles.length > 0) {
-                        errors.push(`[${label}] Skipping ${rawName}: owned asset "${ownedName}" with subcategory=${subcategory} must define files.${missingRoles.join(" and files.")}.`);
-                        continue;
-                    }
-                }
                 if (category === "SPRITESHEET") {
                     const hasAtlas = Object.prototype.hasOwnProperty.call(files, "atlas");
                     const hasManifest = Object.prototype.hasOwnProperty.call(files, "manifest");
@@ -1671,6 +1718,11 @@ function buildAppTasks(rootDir, catalogues, options) {
                 primarySurface: metadata.primarySurface,
                 playtestTapes: metadata.playtestTapes,
                 design,
+                players,
+                makingOf,
+                controls,
+                creation,
+                sourceRepository,
                 tweaks,
                 missingMetadata: metadata.missingFields,
                 // Versioning fields
@@ -1684,6 +1736,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                 controllerMode,
                 previewable,
                 editorSupported,
+                server,
                 externalUrl,
                 listing,
                 // Admin-only field
@@ -1900,12 +1953,6 @@ function buildAssetTasks(catalogues, assetSpecTasks) {
             const fileEntries = entry.files && typeof entry.files === "object" && !Array.isArray(entry.files)
                 ? entry.files
                 : null;
-            const generatedModel3DFormat = !isCustomAsset && category && subcategory
-                ? inferGeneratedModel3DFormat(category, subcategory, format, fileEntries)
-                : null;
-            const generatedModel3DRoles = generatedModel3DFormat
-                ? getGeneratedModel3DFileRoles(generatedModel3DFormat)
-                : null;
             if (!fileEntries || Object.keys(fileEntries).length === 0) {
                 errors.push(`[${label}] Asset "${name}" must define files.`);
                 continue;
@@ -1921,14 +1968,7 @@ function buildAssetTasks(catalogues, assetSpecTasks) {
                 }
                 const relativePath = value.trim();
                 const absolutePath = (0, node_path_1.resolve)(file.directory, relativePath);
-                const normalizedRole = normalizeFileRole(role);
-                const allowMissingGenerated = Boolean(generatedModel3DRoles?.generated.has(normalizedRole));
                 if (!(0, node_fs_1.existsSync)(absolutePath) || !(0, node_fs_1.statSync)(absolutePath).isFile()) {
-                    if (allowMissingGenerated) {
-                        files[role] = relativePath.replace(/\\/g, "/");
-                        filePaths[role] = absolutePath;
-                        continue;
-                    }
                     errors.push(`[${label}] Asset "${name}" file not found at ${absolutePath}.`);
                     hasError = true;
                     continue;
@@ -1939,14 +1979,6 @@ function buildAssetTasks(catalogues, assetSpecTasks) {
             if (hasError) {
                 continue;
             }
-            if (!isCustomAsset && generatedModel3DRoles) {
-                const normalizedRoles = new Set(Object.keys(files).map((role) => normalizeFileRole(role)));
-                const missingRoles = generatedModel3DRoles.required.filter((role) => !normalizedRoles.has(role));
-                if (missingRoles.length > 0) {
-                    errors.push(`[${label}] Asset "${name}" with subcategory=${subcategory} must define files.${missingRoles.join(" and files.")}.`);
-                    continue;
-                }
-            }
             if (!isCustomAsset && category === "SPRITESHEET") {
                 const hasAtlas = Object.prototype.hasOwnProperty.call(files, "atlas");
                 const hasManifest = Object.prototype.hasOwnProperty.call(files, "manifest");
@@ -2090,12 +2122,6 @@ function buildAssetPackTasks(catalogues) {
                 const ownedFormat = typeof owned?.format === "string" && owned.format.trim().length > 0
                     ? owned.format.trim().toUpperCase()
                     : undefined;
-                const generatedModel3DFormat = subcategory
-                    ? inferGeneratedModel3DFormat(category, subcategory, ownedFormat, fileEntries)
-                    : null;
-                const generatedModel3DRoles = generatedModel3DFormat
-                    ? getGeneratedModel3DFileRoles(generatedModel3DFormat)
-                    : null;
                 if (!fileEntries || Object.keys(fileEntries).length === 0) {
                     errors.push(`[${label}] Skipping asset pack "${name}": owned asset "${ownedName}" must define files.`);
                     continue;
@@ -2111,14 +2137,7 @@ function buildAssetPackTasks(catalogues) {
                     }
                     const relativeOwnedPath = fileValue.trim();
                     const absoluteOwnedPath = (0, node_path_1.resolve)(file.directory, relativeOwnedPath);
-                    const normalizedRole = normalizeFileRole(role);
-                    const allowMissingGenerated = Boolean(generatedModel3DRoles?.generated.has(normalizedRole));
                     if (!(0, node_fs_1.existsSync)(absoluteOwnedPath) || !(0, node_fs_1.statSync)(absoluteOwnedPath).isFile()) {
-                        if (allowMissingGenerated) {
-                            files[role] = relativeOwnedPath.replace(/\\/g, "/");
-                            filePaths[role] = absoluteOwnedPath;
-                            continue;
-                        }
                         errors.push(`[${label}] Skipping asset pack "${name}": owned asset "${ownedName}" file not found at ${absoluteOwnedPath}.`);
                         ownedAssetHasError = true;
                         continue;
@@ -2129,14 +2148,6 @@ function buildAssetPackTasks(catalogues) {
                 if (ownedAssetHasError) {
                     continue;
                 }
-                if (generatedModel3DRoles) {
-                    const normalizedRoles = new Set(Object.keys(files).map((role) => normalizeFileRole(role)));
-                    const missingRoles = generatedModel3DRoles.required.filter((role) => !normalizedRoles.has(role));
-                    if (missingRoles.length > 0) {
-                        errors.push(`[${label}] Skipping asset pack "${name}": owned asset "${ownedName}" with subcategory=${subcategory} must define files.${missingRoles.join(" and files.")}.`);
-                        continue;
-                    }
-                }
                 if (category === "SPRITESHEET") {
                     const hasAtlas = Object.prototype.hasOwnProperty.call(files, "atlas");
                     const hasManifest = Object.prototype.hasOwnProperty.call(files, "manifest");
@@ -2233,6 +2244,20 @@ function buildAssetPackTasks(catalogues) {
                 errors.push(`[${label}] Asset pack "${name}" visibility must be PUBLIC or PRIVATE.`);
                 continue;
             }
+            let sourcePath;
+            if (typeof entry.source === "string" && entry.source.trim()) {
+                const relativeSourcePath = entry.source.trim();
+                const absoluteSourcePath = (0, node_path_1.resolve)(file.directory, relativeSourcePath);
+                if (!relativeSourcePath.toLowerCase().endsWith(".zip")) {
+                    errors.push(`[${label}] Asset pack "${name}" source must be a ZIP archive.`);
+                    continue;
+                }
+                if (!(0, node_fs_1.existsSync)(absoluteSourcePath) || !(0, node_fs_1.statSync)(absoluteSourcePath).isFile()) {
+                    errors.push(`[${label}] Asset pack "${name}" source not found at ${absoluteSourcePath}.`);
+                    continue;
+                }
+                sourcePath = absoluteSourcePath;
+            }
             let listing;
             const rawListing = entry.listing;
             let listingValidationFailed = false;
@@ -2375,6 +2400,7 @@ function buildAssetPackTasks(catalogues) {
                 visibility,
                 license,
                 releaseNotes: typeof entry.releaseNotes === "string" ? entry.releaseNotes : undefined,
+                sourcePath,
                 tags,
                 listing,
                 relations,

package/dist/commandContext.d.ts

@@ -1,25 +1,28 @@
 import type { ApiClient } from "@playdrop/api-client";
-import type { AiClient } from "@playdrop/ai-client";
 import { type CliAccountSession, type CliConfig } from "./config";
 import { type EnvironmentConfig } from "./environment";
 import { type ResolvedWorkspaceAuthConfig } from "./workspaceAuth";
 export type EnvironmentContext = {
     client: ApiClient;
-    aiClient: AiClient;
     env: string;
     envConfig: EnvironmentConfig;
     token: string;
     config: CliConfig;
     account: CliAccountSession | null;
     workspaceAuth: ResolvedWorkspaceAuthConfig | null;
+    getToken: () => string;
+    refreshToken: (force?: boolean) => Promise<string>;
 };
 type EnvironmentCallback = (ctx: EnvironmentContext) => Promise<void> | void;
 export type ResolveAuthenticatedEnvironmentOptions = {
     env?: string;
     workspacePath?: string;
+    forceRefresh?: boolean;
 };
 export declare function resolveAuthenticatedEnvironmentContext(command: string, actionLabel: string, options?: ResolveAuthenticatedEnvironmentOptions): Promise<EnvironmentContext | null>;
 export declare function resolveOptionalEnvironmentContext(command: string, options?: ResolveAuthenticatedEnvironmentOptions): Promise<EnvironmentContext | null>;
 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 declare function withPublicEnvironment(command: string, callback: EnvironmentCallback, options?: {
+    env?: string;
+}): Promise<void>;
 export {};

package/dist/commandContext.js

@@ -4,12 +4,82 @@ exports.resolveAuthenticatedEnvironmentContext = resolveAuthenticatedEnvironment
 exports.resolveOptionalEnvironmentContext = resolveOptionalEnvironmentContext;
 exports.withEnvironment = withEnvironment;
 exports.withPublicEnvironment = withPublicEnvironment;
+const types_1 = require("@playdrop/types");
 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";
+const ACCESS_TOKEN_REFRESH_WINDOW_MS = 5 * 60 * 1000;
+function readAccessTokenExpiryMs(token) {
+    try {
+        const payloadSegment = token.split(".")[1];
+        if (!payloadSegment)
+            return null;
+        const payload = JSON.parse(Buffer.from(payloadSegment, "base64url").toString("utf8"));
+        return typeof payload.exp === "number" && Number.isFinite(payload.exp) ? payload.exp * 1000 : null;
+    }
+    catch {
+        return null;
+    }
+}
+function accessTokenIsValid(token, nowMs = Date.now()) {
+    const expiresAtMs = readAccessTokenExpiryMs(token);
+    return expiresAtMs !== null && expiresAtMs > nowMs;
+}
+function accessTokenNeedsRefresh(token, nowMs = Date.now()) {
+    const expiresAtMs = readAccessTokenExpiryMs(token);
+    return expiresAtMs === null || expiresAtMs - nowMs <= ACCESS_TOKEN_REFRESH_WINDOW_MS;
+}
+function extractLoginAccessToken(data) {
+    const token = data.accessToken ?? (typeof data === "object" && data !== null && "token" in data ? String(data.token) : "");
+    if (!token.trim())
+        throw new Error("cli_session_refresh_token_missing");
+    return token.trim();
+}
+async function refreshStoredAccountSession(input) {
+    if (!input.force && !accessTokenNeedsRefresh(input.account.token)) {
+        return input.account;
+    }
+    if (!input.account.deviceApiKey) {
+        const expiryMs = readAccessTokenExpiryMs(input.account.token);
+        const storedConfigVersion = (0, config_1.loadConfig)().version ?? 0;
+        if (!input.force && storedConfigVersion < 3 && expiryMs === null) {
+            return input.account;
+        }
+        throw new Error('cli_session_refresh_requires_login: this session predates durable CLI auth. Run "playdrop auth login" once to upgrade it.');
+    }
+    try {
+        const login = await (0, apiClient_1.createCliApiClient)({ baseUrl: input.envConfig.apiBase }).loginWithApiKey({
+            apiKey: input.account.deviceApiKey,
+        });
+        const username = login.user?.username?.trim() ?? "";
+        if (username !== input.account.username) {
+            throw new Error("cli_session_refresh_account_mismatch");
+        }
+        const token = extractLoginAccessToken(login);
+        (0, config_1.saveAccountSession)({
+            username,
+            env: input.account.env,
+            token,
+            deviceApiKey: input.account.deviceApiKey,
+        });
+        return (0, config_1.findAccountSession)(username, input.account.env) ?? { ...input.account, token };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "cli_session_refresh_account_mismatch") {
+            throw new Error('cli_device_credentials_invalid: this computer token belongs to another account. Run "playdrop auth login" again.');
+        }
+        if (error instanceof types_1.ApiError && (error.status === 401 || error.status === 403)) {
+            throw new Error('cli_device_credentials_invalid: this computer token was revoked or is no longer authorized. Run "playdrop auth login" again.');
+        }
+        if (accessTokenIsValid(input.account.token)) {
+            return input.account;
+        }
+        throw new Error(`cli_session_refresh_failed: no valid access token remains (${error instanceof Error ? error.message : String(error)}).`);
+    }
+}
 function normalizeRequestedEnv(value) {
     if (typeof value !== "string") {
         return undefined;
@@ -37,37 +107,43 @@ function resolveConfiguredEnvironment(envName, command, options) {
     return envConfig;
 }
 function buildContext(cfg, envConfig, account, workspaceAuth = null) {
-    const token = account?.token ?? cfg.token ?? "";
+    let activeAccount = account;
+    let token = activeAccount?.token ?? cfg.token ?? "";
     const onBehalfCreatorUsername = workspaceAuth?.config.ownerUsername ?? null;
     const agentTaskToken = workspaceAuth?.config.taskToken ?? null;
     const agentTaskId = workspaceAuth?.config.taskId ?? null;
     const agentTaskAttempt = workspaceAuth?.config.taskAttempt ?? null;
     const client = (0, apiClient_1.createCliApiClient)({
         baseUrl: envConfig.apiBase,
-        token,
-        onBehalfCreatorUsername,
-        agentTaskToken,
-        agentTaskId,
-        agentTaskAttempt,
-    });
-    const aiClient = (0, apiClient_1.createCliAiClient)({
-        baseUrl: envConfig.aiBase,
-        token,
+        tokenProvider: () => token,
         onBehalfCreatorUsername,
         agentTaskToken,
         agentTaskId,
         agentTaskAttempt,
     });
-    return {
+    const context = {
         client,
-        aiClient,
         env: envConfig.name,
         envConfig,
-        token,
+        get token() {
+            return token;
+        },
         config: cfg,
         account,
         workspaceAuth,
+        getToken: () => token,
+        refreshToken: async (force = true) => {
+            if (!activeAccount) {
+                throw new Error("cli_session_refresh_requires_login");
+            }
+            activeAccount = await refreshStoredAccountSession({ account: activeAccount, envConfig, force });
+            token = activeAccount.token;
+            context.account = activeAccount;
+            context.config = (0, config_1.loadConfig)();
+            return token;
+        },
     };
+    return context;
 }
 function buildLegacyAccountSession(cfg) {
     if (!cfg.token || !cfg.env) {
@@ -274,7 +350,12 @@ async function resolveAuthenticatedEnvironmentContext(command, actionLabel, opti
     if (!resolved) {
         return null;
     }
-    return buildContext(resolved.cfg, resolved.envConfig, resolved.account, resolved.workspaceAuth);
+    const account = await refreshStoredAccountSession({
+        account: resolved.account,
+        envConfig: resolved.envConfig,
+        force: options.forceRefresh,
+    });
+    return buildContext((0, config_1.loadConfig)(), resolved.envConfig, account, resolved.workspaceAuth);
 }
 async function resolveOptionalEnvironmentContext(command, options = {}) {
     const loaded = await loadWorkspaceAwareConfig(command, options);
@@ -325,7 +406,12 @@ async function resolveOptionalEnvironmentContext(command, options = {}) {
     if (!envConfig) {
         return null;
     }
-    return buildContext((0, config_1.loadConfig)(), envConfig, selectedAccount, workspaceAuth);
+    const account = await refreshStoredAccountSession({
+        account: selectedAccount,
+        envConfig,
+        force: options.forceRefresh,
+    });
+    return buildContext((0, config_1.loadConfig)(), envConfig, account, workspaceAuth);
 }
 async function withEnvironment(command, actionLabel, callback, options = {}) {
     const ctx = await resolveAuthenticatedEnvironmentContext(command, actionLabel, options);
@@ -334,10 +420,14 @@ async function withEnvironment(command, actionLabel, callback, options = {}) {
     }
     await callback(ctx);
 }
-async function withPublicEnvironment(command, callback) {
+async function withPublicEnvironment(command, callback, options = {}) {
     const cfg = (0, config_1.loadConfig)();
-    const account = (0, config_1.getCurrentAccountSession)(cfg);
-    const envConfig = resolveConfiguredEnvironment(account?.env ?? cfg.env, command, {
+    const currentAccount = (0, config_1.getCurrentAccountSession)(cfg);
+    const requestedEnv = options.env?.trim();
+    const account = requestedEnv && currentAccount
+        ? (0, config_1.findAccountSession)(currentAccount.username, requestedEnv, cfg)
+        : currentAccount;
+    const envConfig = resolveConfiguredEnvironment(requestedEnv ?? account?.env ?? cfg.env, command, {
         requireAuth: false,
         allowDefaultPublicEnv: true,
     });

package/dist/commands/build.js

@@ -5,7 +5,6 @@ const taskSelection_1 = require("../taskSelection");
 const taskUtils_1 = require("../taskUtils");
 const uploadLog_1 = require("../uploadLog");
 const apps_1 = require("../apps");
-const model_artifacts_1 = require("../assets/model-artifacts");
 async function build(pathOrName) {
     const selection = (0, taskSelection_1.selectTasks)(pathOrName);
     if (selection.errors.length > 0) {
@@ -29,12 +28,6 @@ async function build(pathOrName) {
                 const artifacts = await (0, apps_1.buildApp)(task);
                 detail = `bundleHash=${artifacts.bundleHash}`;
             }
-            else if (task.kind === "asset" || task.kind === "owned-asset") {
-                const generated = await (0, model_artifacts_1.prepareModel3DAssetArtifacts)(task);
-                if (!generated) {
-                    throw new Error(`project build does not support ${task.kind} "${entityId}" because it has no local build step.`);
-                }
-            }
             else {
                 throw new Error(`project build does not support ${task.kind} "${entityId}".`);
             }

package/dist/commands/captureListing.d.ts

@@ -3,6 +3,7 @@ import type { BrowserContextOptions } from "playwright-core";
 import { type TaskCaptureSession } from "../appUrls";
 type CaptureListingOptions = {
     app?: string;
+    surface?: string;
     duration?: string | number;
     width?: string | number;
     height?: string | number;
@@ -15,6 +16,7 @@ type CaptureListingOptions = {
 type ParsedCaptureListingOptions = {
     targetArg?: string;
     appName?: string;
+    surface: AppSurface | null;
     durationSeconds: number;
     width: number;
     height: number;
@@ -124,6 +126,7 @@ export type ExportedListingAudio = {
     mimeType: string;
     base64: string;
 };
+export declare function resolveCaptureSurfaces(declared: AppSurface[], selected: AppSurface | null): AppSurface[];
 export declare function resolveListingCaptureRouteSegment(previewable: boolean): "dev-preview";
 export declare function resolveCaptureListingDevRouterPort(env?: NodeJS.ProcessEnv): number;
 export declare function resolveListingCaptureLocalDevPort(devRouterPort: number): number | null;