@ttmg/cli 0.3.7-beta.1 → 0.3.7-beta.3

package/dist/index.js

@@ -6772,6 +6772,44 @@ function isAxiosError(e) {
     return !!e?.isAxiosError;
 }
 
+const CREATE_DIRECT_FEED_CARD_URL = 'https://developers.tiktok.com/tiktok/v4/devportal/mini_game/fyf_card/create_direct_feed_card';
+const DIRECT_FEED_CARD_HEADERS$2 = {
+    'Content-Type': 'application/json',
+    'x-use-ppe': '1',
+    'x-tt-env': 'ppe_feed_play',
+};
+async function createDirectFeedCard({ appId, clientKey, directFeedCard, }) {
+    const payload = {
+        app_id: appId,
+        client_key: clientKey,
+        direct_feed_card: directFeedCard,
+    };
+    return request({
+        url: CREATE_DIRECT_FEED_CARD_URL,
+        method: 'POST',
+        headers: DIRECT_FEED_CARD_HEADERS$2,
+        data: payload,
+    });
+}
+
+const GET_DIRECT_FEED_SCENARIOS_URL = 'https://developers.tiktok.com/tiktok/v4/devportal/mini_game/fyf_card/get_direct_feed_scenario';
+const DIRECT_FEED_CARD_HEADERS$1 = {
+    'Content-Type': 'application/json',
+    'x-use-ppe': '1',
+    'x-tt-env': 'ppe_feed_play',
+};
+async function fetchDirectFeedScenarios({ appId, clientKey, }) {
+    return request({
+        url: GET_DIRECT_FEED_SCENARIOS_URL,
+        method: 'POST',
+        headers: DIRECT_FEED_CARD_HEADERS$1,
+        data: {
+            app_id: appId,
+            client_key: clientKey,
+        },
+    });
+}
+
 const GET_GAME_ASSET_PREVIEW_URL = 'https://developers.tiktok.com/tiktok/v4/devportal/mini_game/asset/preview_url';
 async function fetchGameAssetPreviewUrl({ assetId, }) {
     return request({
@@ -9192,49 +9230,130 @@ const gameDirectFeedCardAssetPreviewRoute = {
     },
 };
 
-function hasBlockingCardStatus(value) {
-    if (value === null || value === undefined || value === '') {
-        return false;
+async function resolveAppIdentity$2(body) {
+    const clientKey = body?.clientKey?.trim() ||
+        body?.client_key?.trim() ||
+        getClientKey().clientKey?.trim();
+    let appId = body?.appId?.trim() ||
+        body?.app_id?.trim() ||
+        store.getState().appId?.trim();
+    if (!clientKey) {
+        return {
+            clientKey: '',
+            appId,
+            error: 'Missing client key. Please run `ttmg init` or pass `clientKey` from IDE.',
+        };
     }
-    if (typeof value === 'number') {
-        return value <= 0;
+    if (!appId) {
+        const gameInfoResponse = await fetchGameInfo(clientKey);
+        if (gameInfoResponse.error) {
+            return {
+                clientKey,
+                appId: '',
+                error: gameInfoResponse.error,
+            };
+        }
+        appId = gameInfoResponse.data?.app_id?.trim() || '';
+        if (appId) {
+            store.setState({ appId });
+        }
     }
-    const normalized = String(value).toLowerCase();
-    return [
-        'pending',
-        'review',
-        'reviewing',
-        'processing',
-        'reject',
-        'rejected',
-        'fail',
-        'failed',
-        'disable',
-        'disabled',
-        'offline',
-        'draft',
-        'delete',
-        'deleted',
-    ].some(keyword => normalized.includes(keyword));
-}
-function isUsableDirectFeedCard(card) {
-    if (!card?.content_id) {
-        return false;
+    if (!appId) {
+        return {
+            clientKey,
+            appId: '',
+            error: 'Missing app id. Please open project detail first or pass `appId` from IDE.',
+        };
     }
-    if (hasBlockingCardStatus(card.status)) {
-        return false;
+    return {
+        clientKey,
+        appId,
+        error: null,
+    };
+}
+function normalizeDirectFeedCard(body) {
+    const camelCard = body?.directFeedCard;
+    const snakeCard = body?.direct_feed_card;
+    const normalized = {
+        card_name: camelCard?.cardName?.trim() || snakeCard?.card_name?.trim() || '',
+        card_desc: camelCard?.cardDesc?.trim() || snakeCard?.card_desc?.trim() || '',
+        card_type: Number(camelCard?.cardType ?? snakeCard?.card_type ?? 0),
+        scenario: camelCard?.scenario?.trim() || snakeCard?.scenario?.trim() || '',
+        sub_pkg: camelCard?.subPkg?.trim() || snakeCard?.sub_pkg?.trim() || '__GAME__',
+        params: camelCard?.params?.trim() || snakeCard?.params?.trim() || '',
+    };
+    if (!normalized.card_name || !normalized.card_desc || !normalized.card_type || !normalized.scenario) {
+        return {
+            card: normalized,
+            error: 'Missing required direct-play card fields.',
+        };
     }
-    if (typeof card.audit_status === 'number') {
-        if (card.audit_status <= 1) {
-            return false;
+    return {
+        card: normalized,
+        error: null,
+    };
+}
+const gameDirectFeedCardCreateRoute = {
+    method: 'post',
+    path: '/game/direct-feed-card/create',
+    handler: async (req, res) => {
+        const identity = await resolveAppIdentity$2(req.body);
+        if (identity.error) {
+            res.send({
+                code: errorCode,
+                error: identity.error,
+                data: null,
+            });
+            return;
         }
-    }
-    else if (hasBlockingCardStatus(card.audit_status)) {
+        const directFeedCard = normalizeDirectFeedCard(req.body);
+        if (directFeedCard.error) {
+            res.send({
+                code: errorCode,
+                error: directFeedCard.error,
+                data: null,
+            });
+            return;
+        }
+        const response = await createDirectFeedCard({
+            appId: identity.appId,
+            clientKey: identity.clientKey,
+            directFeedCard: directFeedCard.card,
+        });
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
+            return;
+        }
+        res.send({
+            code: successCode,
+            data: {
+                ...(typeof response.data === 'object' && response.data ? response.data : {}),
+                direct_feed_card: {
+                    ...(typeof response.data === 'object' &&
+                        response.data &&
+                        typeof response.data.direct_feed_card === 'object'
+                        ? (response.data.direct_feed_card ||
+                            {})
+                        : {}),
+                    ...directFeedCard.card,
+                },
+            },
+            ctx: response.ctx,
+        });
+    },
+};
+
+function isUsableDirectFeedCard(card) {
+    if (!card?.content_id) {
         return false;
     }
     return true;
 }
-async function resolveAppIdentity(body) {
+async function resolveAppIdentity$1(body) {
     const clientKey = body?.clientKey?.trim() ||
         body?.client_key?.trim() ||
         getClientKey().clientKey?.trim();
@@ -9279,7 +9398,7 @@ const gameDirectFeedCardListRoute = {
     method: 'post',
     path: '/game/direct-feed-card/list',
     handler: async (req, res) => {
-        const identity = await resolveAppIdentity(req.body);
+        const identity = await resolveAppIdentity$1(req.body);
         if (identity.error) {
             res.send({
                 code: errorCode,
@@ -9319,6 +9438,156 @@ const gameDirectFeedCardListRoute = {
     },
 };
 
+function getStringCandidate(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+function normalizeScenarioOption(item) {
+    const value = getStringCandidate(item.value) ||
+        getStringCandidate(item.key) ||
+        getStringCandidate(item.scenario) ||
+        getStringCandidate(item.scenario_key) ||
+        getStringCandidate(item.scene) ||
+        getStringCandidate(item.id) ||
+        getStringCandidate(item.code);
+    if (!value) {
+        return null;
+    }
+    const label = getStringCandidate(item.label) ||
+        getStringCandidate(item.name) ||
+        getStringCandidate(item.title) ||
+        getStringCandidate(item.desc) ||
+        getStringCandidate(item.description) ||
+        getStringCandidate(item.display_name) ||
+        getStringCandidate(item.displayName) ||
+        getStringCandidate(item.scenario_name) ||
+        value;
+    const cardTypeCandidate = item.card_type ?? item.cardType;
+    const cardType = typeof cardTypeCandidate === 'number'
+        ? cardTypeCandidate
+        : typeof cardTypeCandidate === 'string' && cardTypeCandidate.trim()
+            ? Number(cardTypeCandidate)
+            : undefined;
+    return {
+        label,
+        value,
+        cardType: Number.isFinite(cardType) ? cardType : undefined,
+    };
+}
+function extractScenarioOptions(data) {
+    const dataRecord = data && typeof data === 'object' ? data : null;
+    const candidateLists = [
+        data,
+        dataRecord?.data,
+        dataRecord?.scenarios,
+        dataRecord?.scenario_list,
+        dataRecord?.scenario_infos,
+        dataRecord?.scenario_info_list,
+        dataRecord?.list,
+    ];
+    for (const candidate of candidateLists) {
+        if (!Array.isArray(candidate)) {
+            continue;
+        }
+        const normalized = candidate
+            .map(item => item && typeof item === 'object'
+            ? normalizeScenarioOption(item)
+            : null)
+            .filter((item) => Boolean(item));
+        if (normalized.length > 0) {
+            const deduped = new Map();
+            normalized.forEach(item => {
+                deduped.set(item.value, item);
+            });
+            return Array.from(deduped.values());
+        }
+    }
+    return [];
+}
+async function resolveAppIdentity(body) {
+    const clientKey = body?.clientKey?.trim() ||
+        body?.client_key?.trim() ||
+        getClientKey().clientKey?.trim();
+    let appId = body?.appId?.trim() ||
+        body?.app_id?.trim() ||
+        store.getState().appId?.trim();
+    if (!clientKey) {
+        return {
+            clientKey: '',
+            appId,
+            error: 'Missing client key. Please run `ttmg init` or pass `clientKey` from IDE.',
+        };
+    }
+    if (!appId) {
+        const gameInfoResponse = await fetchGameInfo(clientKey);
+        if (gameInfoResponse.error) {
+            return {
+                clientKey,
+                appId: '',
+                error: gameInfoResponse.error,
+            };
+        }
+        appId = gameInfoResponse.data?.app_id?.trim() || '';
+        if (appId) {
+            store.setState({ appId });
+        }
+    }
+    if (!appId) {
+        return {
+            clientKey,
+            appId: '',
+            error: 'Missing app id. Please open project detail first or pass `appId` from IDE.',
+        };
+    }
+    return {
+        clientKey,
+        appId,
+        error: null,
+    };
+}
+const gameDirectFeedCardScenariosRoute = {
+    method: 'post',
+    path: '/game/direct-feed-card/scenarios',
+    handler: async (req, res) => {
+        const identity = await resolveAppIdentity(req.body);
+        if (identity.error) {
+            res.send({
+                code: errorCode,
+                error: identity.error,
+                data: null,
+            });
+            return;
+        }
+        const response = await fetchDirectFeedScenarios({
+            appId: identity.appId,
+            clientKey: identity.clientKey,
+        });
+        if (response.error) {
+            res.send({
+                code: errorCode,
+                error: response.error,
+                ctx: response.ctx,
+            });
+            return;
+        }
+        const scenarios = extractScenarioOptions(response.data);
+        const data = response.data && typeof response.data === 'object'
+            ? {
+                ...response.data,
+                scenarios,
+                total: scenarios.length,
+            }
+            : {
+                scenarios,
+                total: scenarios.length,
+            };
+        res.send({
+            code: successCode,
+            data,
+            ctx: response.ctx,
+        });
+    },
+};
+
 const gameDetailRoute = {
     method: 'get',
     path: '/game/detail',
@@ -10705,7 +10974,9 @@ const routes = [
     gameDetailRoute,
     gameCheckRoute,
     gameDirectFeedCardAssetPreviewRoute,
+    gameDirectFeedCardCreateRoute,
     gameDirectFeedCardListRoute,
+    gameDirectFeedCardScenariosRoute,
     gameUploadRoute,
     gameWasmSplitConfigRoute,
     gameWasmSplitOptionsRoute,
@@ -11164,7 +11435,7 @@ async function upload({ clientKey, note = '--', dir, }) {
     }
 }
 
-var version = "0.3.7-beta.1";
+var version = "0.3.7-beta.3";
 var pkg = {
 	version: version};