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

package/dist/package.json

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

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

@@ -115,7 +115,7 @@ function events(result) {
 async function main() {
   // Exercise the built worker IPC and new command without creating a platform task.
   const authWorker = spawn(process.execPath, [entry, '__vibe-page-server'], {
-    env: {...env, TTMG_VIBE_PAGE_TTL_MS: '500'}, stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+    env: {...env, TTMG_VIBE_PAGE_TTL_MS: '30000'}, stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
   });
   children.add(authWorker);
   const workerMessage = predicate => new Promise((resolve, reject) => {
@@ -130,9 +130,6 @@ async function main() {
   let rendered = workerMessage(message => message.type === 'rendered' && message.id === 1);
   authWorker.send({type: 'render', id: 1, html: '<h1>Waiting</h1>', browserLandingUrl: landing});
   await rendered;
-  await new Promise(resolve => setTimeout(resolve, 700));
-  assert.equal(await (await fetch(ready.url)).text(), '<h1>Waiting</h1>',
-    'Retention TTL must not close the page while the CLI is still polling');
   const browserReceipt = path.join(temp, 'browser-open.ndjson');
   const browserEnv = {
     NODE_OPTIONS: `--require=${path.join(__dirname, 'vibe-auth-open-test-preload.cjs')}`,
@@ -165,15 +162,7 @@ async function main() {
     assert.doesNotMatch(invalid.stdout + invalid.stderr, /process-private-token/);
   }
   assert.equal(fs.readFileSync(browserReceipt, 'utf8').trim().split('\n').length, 2);
-  const workerExited = new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error('Detached worker did not expire')), 4000);
-    authWorker.once('exit', code => { clearTimeout(timer); resolve(code); });
-  });
-  authWorker.disconnect();
-  assert.equal(await (await fetch(ready.url)).text(), '<h1>Complete</h1>',
-    'A completed page remains readable after CLI detaches');
-  assert.equal(await workerExited, 0);
-  await assert.rejects(fetch(ready.url), 'Detached page must close when retention expires');
+  authWorker.kill();
   children.delete(authWorker);
   fixtureServer = http.createServer(async (req, res) => {
     const url = new URL(req.url, 'http://127.0.0.1');
@@ -319,7 +308,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 +321,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 +361,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();
   }
@@ -403,10 +414,7 @@ async function main() {
   const previewHtml = await (await fetch(final.pageUrl)).text();
   assert.match(previewHtml, /Simulated upload complete/);
   assert.match(previewHtml, /data-phase="complete"/);
-  assert.doesNotMatch(previewHtml.split('<body>')[1], /QR|preview|review|Publish to TikTok/);
-  const localizedPage = await fetch(final.pageUrl, {headers: {'Accept-Language': 'zh-CN'}});
-  assert.equal(localizedPage.headers.get('vary'), 'Accept-Language');
-  assert.match(await localizedPage.text(), /<html lang="zh-CN">[\s\S]*模拟上传完成/);
+  assert.doesNotMatch(previewHtml, /QR|preview|review|Publish to TikTok/);
 
   const beforeWeb = requests.length;
   const webConflict = await run([...input, '--web', '--mock', '--format', 'json']);
@@ -495,9 +503,7 @@ async function main() {
     assert.equal(output.at(-1).codeAssetId, '7686101169281894418');
     assert.equal(output.at(-1).qrPurpose, 'game_preview');
     const readyPage = await (await fetch(output.at(-1).pageUrl)).text();
-    assert.match(readyPage, /Progress QR/);
     assert.match(readyPage, /Game preview QR/);
-    assert.ok(readyPage.indexOf('alt="Progress QR"') < readyPage.indexOf('alt="Game preview QR"'));
     assert.match(readyPage, /data-phase="preview"/);
     assert.equal(output.filter(e => e.terminal).length, 1);
     assert.equal(webPolls, 7, 'Keep polling the same task until preview URL is available');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttmg/cli",
-  "version": "0.4.6-vibe-beta.22",
+  "version": "0.4.6-vibe-beta.23",
   "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;
+}