@ttmg/cli 0.4.6-vibe-beta.22 → 0.4.6-vibe-beta.24

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttmg/cli",
-  "version": "0.4.6-vibe-beta.22",
+  "version": "0.4.6-vibe-beta.24",
   "description": "TikTok Mini Game Command Line Tool",
   "license": "ISC",
   "bin": {

package/dist/scripts/vibe-upload-smoke.js

@@ -319,7 +319,8 @@ async function main() {
     const replies = {
       create_minis_import_task_for_agent: {
         task_id: '7684370037737619477', import_token: 'receipt-test-secret',
-        landing_url: 'https://example.invalid/auth', poll_interval_seconds: 0.01,
+        landing_url: 'https://example.invalid/auth?task_id=7684370037737619477&import_token=receipt-test-secret',
+        poll_interval_seconds: 0.01,
       },
       get_minis_import_task_detail_for_agent: { status: 2, ready_for_input: true, preview_url: 'https://www.tiktok.com/minis/receipt-preview' },
       upload_minis_import_app_icon_for_agent: { icon_uri: 'test-icon' },
@@ -331,14 +332,35 @@ async function main() {
   });
   await new Promise(resolve => uploadServer.listen(0, '127.0.0.1', resolve));
   try {
-    const saved = await run([...input, '--format', 'ndjson'], undefined, {
+    const saved = await run([...input, '--format', 'ndjson', '--verbose'], undefined, {
       TTMG_VIBE_BACKEND: 'local-http',
       TTMG_VIBE_API: `http://127.0.0.1:${uploadServer.address().port}`,
     });
     assert.equal(saved.code, 0, saved.stderr);
     const savedEvents = events(saved);
     const waitingPage = savedEvents.find(e => e.status === 'waiting_authorization').pageUrl;
-    assert.deepEqual(saved.stderr.split(/\r?\n/).filter(line => line.startsWith('page: ')), [`page: ${waitingPage}`]);
+    const savedStderr = saved.stderr.split(/\r?\n/).filter(Boolean);
+    assert.deepEqual(savedStderr.filter(line => line.startsWith('page: ')), [`page: ${waitingPage}`]);
+    const httpTraces = savedStderr.filter(line => line.startsWith('{')).map(JSON.parse);
+    assert.deepEqual(httpTraces.map(trace => trace.event), [
+      'http_request', 'http_response',
+      'http_request', 'http_response',
+      'http_request', 'http_response',
+      'http_request', 'http_response',
+      'http_request', 'http_response',
+      'http_request', 'http_response',
+    ]);
+    const createRequest = httpTraces.find(trace => trace.event === 'http_request' && trace.url.endsWith('/create_minis_import_task_for_agent/'));
+    const createResponse = httpTraces.find(trace => trace.event === 'http_response' && trace.url.endsWith('/create_minis_import_task_for_agent/'));
+    assert.equal(createRequest.request.source_project_id.length, 36);
+    assert.equal(createRequest.request.task_idempotency_id.length, 36);
+    assert.equal(createResponse.response.task_id, '7684370037737619477');
+    assert.equal(createResponse.response.import_token, '[REDACTED]');
+    assert.match(createResponse.response.landing_url, /import_token=%5BREDACTED%5D/);
+    const pollRequests = httpTraces.filter(trace => trace.event === 'http_request' && trace.url.endsWith('/get_minis_import_task_detail_for_agent/'));
+    assert.ok(pollRequests.length >= 2);
+    assert.ok(pollRequests.every(trace => trace.request.task_id === '7684370037737619477' && trace.request.import_token === '[REDACTED]'));
+    assert.doesNotMatch(saved.stderr, /receipt-test-secret/);
     const savedFinal = savedEvents.at(-1);
     assert.equal(savedFinal.status, 'uploaded', JSON.stringify(savedEvents.map(e => ({ status: e.status, terminal: e.terminal, step: e.uploadStep, uploaded: e.uploaded }))));
     assert.equal(savedFinal.uploaded, true);
@@ -350,7 +372,7 @@ async function main() {
       'upload_minis_import_package_for_agent',
       'get_minis_import_task_detail_for_agent',
     ]);
-    assert.doesNotMatch(saved.stdout + saved.stderr, /receipt-test-secret|test-package/);
+    assert.doesNotMatch(saved.stdout + saved.stderr, /receipt-test-secret/);
   } finally {
     uploadServer.close();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttmg/cli",
-  "version": "0.4.6-vibe-beta.22",
+  "version": "0.4.6-vibe-beta.24",
   "description": "TikTok Mini Game Command Line Tool",
   "license": "ISC",
   "bin": {

package/src/commands/common/game/categories.test.ts

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'crypto';
+import { GAME_CATEGORIES, GAME_CATEGORY_CATALOG_VERSION, getGameCategories, isGameCategoryPair } from './categories';
+import { applyVibeCategory, VIBE_PPE_DEFAULT_APP_INFO } from '../vibe/appInfo';
+
+const result = getGameCategories({ format: 'json' });
+assert.equal(result.platformWrite, false);
+assert.equal(result.categoryCount, 12);
+assert.equal(result.subcategoryCount, 114);
+assert.equal(result.errorCode, null);
+assert.equal(GAME_CATEGORY_CATALOG_VERSION, 'sha256:' + createHash('sha256').update(JSON.stringify(GAME_CATEGORIES)).digest('hex'));
+assert.equal(new Set(GAME_CATEGORIES.map(item => item.value)).size, 12);
+for (const category of GAME_CATEGORIES) {
+  assert.equal(new Set(category.subcategories.map(item => item.value)).size, category.subcategories.length);
+  for (const item of category.subcategories) assert.ok(item.description.trim());
+}
+assert.deepEqual(getGameCategories({ category: 'Puzzle' }).categories.map(item => item.value), ['Puzzle']);
+assert.equal(getGameCategories({ category: 'puzzle' }).errorCode, 'GAME_CATEGORY_UNKNOWN');
+assert.equal(getGameCategories({ category: '' }).errorCode, 'GAME_CATEGORY_UNKNOWN');
+assert.equal(getGameCategories({ format: 'xml' }).errorCode, 'GAME_CATEGORIES_INVALID_FORMAT');
+assert.ok(isGameCategoryPair('Action', "Shoot'em Up"));
+assert.ok(isGameCategoryPair('Action', "Beat 'em up"));
+assert.ok(!isGameCategoryPair('Other', 'Physics'));
+assert.ok(!isGameCategoryPair('Casino', 'Bingo'));
+
+assert.equal(applyVibeCategory({}), undefined);
+const legacy = { ...VIBE_PPE_DEFAULT_APP_INFO, category: 'Casual', subcategory: 'Puzzle', description: 'Legacy description' };
+assert.equal(applyVibeCategory({}, legacy), legacy, 'Old file callers remain unchanged when new flags are absent');
+const pair = { category: 'Puzzle', subcategory: 'Physics' };
+assert.deepEqual(applyVibeCategory(pair), { ...VIBE_PPE_DEFAULT_APP_INFO, ...pair });
+assert.deepEqual(applyVibeCategory(pair, legacy), { ...legacy, ...pair });
+assert.equal(VIBE_PPE_DEFAULT_APP_INFO.category, 'Other');
+assert.equal(legacy.category, 'Casual', 'Overrides must not mutate old input');
+for (const options of [{category:'Puzzle'}, {subcategory:'Physics'}])
+  assert.throws(() => applyVibeCategory(options), /VIBE_CATEGORY_PAIR_REQUIRED/);
+for (const options of [{category:'Other',subcategory:'Physics'}, {category:'puzzle',subcategory:'Physics'}, {category:'',subcategory:''}])
+  assert.throws(() => applyVibeCategory(options), /VIBE_INVALID_CATEGORY/);
+console.log('game category catalog and compatibility tests passed');

package/src/commands/common/game/categories.ts

@@ -0,0 +1,48 @@
+import { randomUUID } from 'crypto';
+import catalog from './categoryCatalog.json';
+import { t } from '../../../libs/i18n';
+
+export const GAME_CATEGORY_CATALOG_VERSION = catalog.catalogVersion;
+export const GAME_CATEGORIES = catalog.categories;
+
+export function isGameCategoryPair(category: string, subcategory: string) {
+  return GAME_CATEGORIES.some(item => item.value === category &&
+    item.subcategories.some(child => child.value === subcategory));
+}
+
+export function getGameCategories(options: { category?: string; format?: string } = {}) {
+  const errorCode = !['text', 'json', 'ndjson'].includes(options.format || 'text')
+    ? 'GAME_CATEGORIES_INVALID_FORMAT'
+    : options.category !== undefined && !GAME_CATEGORIES.some(item => item.value === options.category)
+      ? 'GAME_CATEGORY_UNKNOWN' : null;
+  const categories = errorCode ? [] : GAME_CATEGORIES.filter(item =>
+    options.category === undefined || item.value === options.category);
+  return {
+    schemaVersion: '1',
+    command: 'game categories',
+    operationId: `game_categories_${randomUUID()}`,
+    status: errorCode ? 'failed' : 'ready',
+    terminal: true,
+    platformWrite: false,
+    catalogVersion: GAME_CATEGORY_CATALOG_VERSION,
+    source: catalog.source,
+    descriptionLanguage: 'en',
+    categoryCount: categories.length,
+    subcategoryCount: categories.reduce((count, item) => count + item.subcategories.length, 0),
+    categories,
+    errorCode,
+    error: errorCode ? t(errorCode === 'GAME_CATEGORY_UNKNOWN'
+      ? 'cli.command.game.categories.unknown' : 'cli.command.game.categories.invalidFormat') : null,
+  };
+}
+
+export function gameCategories(options: { category?: string; format?: string }) {
+  const result = getGameCategories(options);
+  if (options.format && options.format !== 'text') console.log(JSON.stringify(result));
+  else if (result.error) console.error(result.error);
+  else for (const category of result.categories) {
+    console.log(category.value);
+    for (const item of category.subcategories) console.log(`  ${item.value}: ${item.description}`);
+  }
+  if (result.errorCode) process.exitCode = 1;
+}