@ttmg/cli 0.4.6-vibe-beta.6 → 0.4.6-vibe-beta.8

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

@@ -4,6 +4,7 @@ const os = require('node:os');
 const path = require('node:path');
 const { spawn } = require('node:child_process');
 const archiver = require('archiver');
+const http = require('node:http');
 
 const entry = path.resolve(__dirname, '../dist/index.js');
 const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-vibe-process-'));
@@ -23,6 +24,11 @@ const input = [
 const png =
   'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aXyoAAAAASUVORK5CYII=';
 const children = new Set();
+let fixtureServer;
+const requests = [];
+let failStatus = false;
+let webMode = false;
+let webPolls = 0;
 const env = {
   ...process.env,
   HOME: temp,
@@ -31,6 +37,7 @@ const env = {
   TTMG_VIBE_PAGE_TTL_MS: '7000',
   TTMG_VIBE_BACKEND: '',
   TTMG_VIBE_API: '',
+  TTMG_VIBE_PPE: '',
 };
 
 function run(args, onEvent, extraEnv = {}) {
@@ -94,6 +101,84 @@ function events(result) {
     .map(line => JSON.parse(line));
 }
 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: '30000'}, stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+  });
+  children.add(authWorker);
+  const workerMessage = predicate => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {authWorker.off('message', receive); reject(new Error('worker timeout'));}, 5000);
+    function receive(message) {
+      if (predicate(message)) {clearTimeout(timer); authWorker.off('message', receive); resolve(message);}
+    }
+    authWorker.on('message', receive);
+  });
+  const ready = await workerMessage(message => message.type === 'ready');
+  const landing = 'https://developers.tiktok.com/portal_h5/minis_import?task_id=123&import_token=process-private-token';
+  let rendered = workerMessage(message => message.type === 'rendered' && message.id === 1);
+  authWorker.send({type: 'render', id: 1, html: '<h1>Waiting</h1>', browserLandingUrl: landing});
+  await rendered;
+  const browserReceipt = path.join(temp, 'browser-open.ndjson');
+  const browserEnv = {
+    NODE_OPTIONS: `--require=${path.join(__dirname, 'vibe-auth-open-test-preload.cjs')}`,
+    TTMG_AUTH_OPEN_TEST_RECEIPT: browserReceipt,
+  };
+  for (const format of ['json', 'ndjson']) {
+    const opened = await run(['auth', 'open', '--page-url', ready.url, '--format', format], undefined, browserEnv);
+    assert.equal(opened.code, 0, opened.stderr);
+    const result = JSON.parse(opened.stdout);
+    assert.equal(result.status, 'open_requested');
+    assert.equal(result.platformWrite, false);
+    assert.doesNotMatch(opened.stdout + opened.stderr, /import_token|process-private-token/);
+  }
+  const launches = fs.readFileSync(browserReceipt, 'utf8').trim().split('\n').map(JSON.parse);
+  assert.equal(launches.length, 2);
+  assert.ok(launches.every(item => item.args.includes(ready.url + '/authorize')));
+  const redirect = await fetch(ready.url + '/authorize', {redirect: 'manual'});
+  assert.equal(redirect.headers.get('location'), landing);
+  assert.equal(redirect.status, 302);
+  rendered = workerMessage(message => message.type === 'rendered' && message.id === 2);
+  authWorker.send({type: 'render', id: 2, html: '<h1>Complete</h1>'});
+  await rendered;
+  const stale = await run(['auth', 'open', '--page-url', ready.url, '--format', 'json'], undefined, browserEnv);
+  assert.equal(stale.code, 1);
+  assert.equal(JSON.parse(stale.stdout).errorCode, 'VIBE_AUTH_PAGE_UNAVAILABLE');
+  for (const args of [[], ['--page-url', landing]]) {
+    const invalid = await run(['auth', 'open', ...args, '--format', 'json'], undefined, browserEnv);
+    assert.equal(invalid.code, 1);
+    assert.equal(JSON.parse(invalid.stdout).errorCode, 'VIBE_INVALID_PAGE_URL');
+    assert.doesNotMatch(invalid.stdout + invalid.stderr, /process-private-token/);
+  }
+  assert.equal(fs.readFileSync(browserReceipt, 'utf8').trim().split('\n').length, 2);
+  authWorker.kill();
+  children.delete(authWorker);
+  fixtureServer = http.createServer((req, res) => {
+    const url = new URL(req.url, 'http://127.0.0.1');
+    requests.push({ path: url.pathname, method: req.method, headers: req.headers });
+    req.resume();
+    const create = url.pathname.endsWith('/create_minis_import_task_for_agent/');
+    const status = url.pathname.endsWith('/get_minis_import_task_status_for_agent/');
+    if (create) webPolls = 0;
+    if (status && webMode) webPolls++;
+    assert.ok(create || status, 'Unexpected real upload endpoint');
+    assert.equal(req.headers['x-use-ppe'], '1');
+    assert.equal(req.headers['x-tt-env'], 'ppe_op_vc');
+    assert.equal(req.headers.cookie, undefined);
+    if (status) {
+      assert.equal(url.searchParams.get('task_id'), '7684370037737553941');
+      assert.equal(url.searchParams.get('import_token'), 'process-test-secret');
+    }
+    const data = create ? {
+      task_id: '7684370037737553941', import_token: 'process-test-secret',
+      landing_url: 'https://developers.tiktok.com/portal_h5/minis_import?task_id=7684370037737553941&import_token=process-test-secret',
+      poll_interval_seconds: 0.01,
+    } : { status: webMode && webPolls >= 5 ? 2 : 1, ready_for_input: webMode && webPolls >= 5 };
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ ...data, error_info: { code: failStatus && status ? 420500 : 0 } }));
+  });
+  await new Promise(resolve => fixtureServer.listen(0, '127.0.0.1', resolve));
+  env.TTMG_VIBE_TEST_PORT = String(fixtureServer.address().port);
+  env.NODE_OPTIONS = `--require ${JSON.stringify(path.join(__dirname, 'vibe-ppe-test-preload.cjs'))}`;
   fs.writeFileSync(icon, Buffer.from(png, 'base64'));
   await new Promise((resolve, reject) => {
     const out = fs.createWriteStream(zip);
@@ -107,6 +192,77 @@ async function main() {
   });
 
   let bindingHtml;
+  const appInfoPath = path.join(temp, 'app-info.json');
+  fs.writeFileSync(appInfoPath, JSON.stringify({
+    description: 'Process contract fixture', category: 'Casual', subcategory: 'Puzzle',
+    terms_of_service: 'https://example.invalid/terms', privacy_policy: 'https://example.invalid/privacy',
+    copyright_confirmation: true,
+  }));
+  const badIcon = await run([...input, '--mock', '--app-info', appInfoPath, '--format', 'json']);
+  assert.equal(badIcon.code, 1);
+  assert.equal(events(badIcon)[0].errorCode, 'VIBE_PLATFORM_ICON_INVALID');
+  assert.equal(events(badIcon)[0].platformWrite, false);
+  assert.equal(requests.length, 0, 'Invalid input must not create a task');
+  assert.equal(fs.existsSync(path.join(temp, '.ttmg/vibe-project.json')), false);
+  const platformHeader = Buffer.from(png, 'base64');
+  platformHeader.writeUInt32BE(1024, 16);
+  platformHeader.writeUInt32BE(1024, 20);
+  fs.writeFileSync(icon, platformHeader); // Header preflight fixture, not a decoded image.
+  const completeDry = await run([...input, '--app-info', appInfoPath, '--dry-run', '--format', 'json']);
+  assert.equal(completeDry.code, 0, completeDry.stderr);
+  assert.equal(events(completeDry)[0].status, 'prepared');
+  assert.equal(requests.length, 0);
+  fs.writeFileSync(appInfoPath, '{private-token');
+  const badInfo = await run([...input, '--mock', '--app-info', appInfoPath, '--format', 'json']);
+  assert.equal(events(badInfo)[0].errorCode, 'VIBE_INVALID_APP_INFO');
+  assert.doesNotMatch(badInfo.stdout + badInfo.stderr, /private-token/);
+  assert.equal(requests.length, 0);
+  const legacyInfo = await run(['upload', '--app-info', appInfoPath, '--format', 'json']);
+  assert.equal(events(legacyInfo)[0].errorCode, 'VIBE_OPTION_REQUIRES_VIBE');
+  assert.equal(events(legacyInfo)[0].platformWrite, false);
+  fs.writeFileSync(icon, Buffer.from(png, 'base64'));
+  // Replay the live package receipt through the built CLI without PPE writes.
+  const uploadPaths = [];
+  const uploadServer = http.createServer((req, res) => {
+    const url = new URL(req.url, 'http://127.0.0.1');
+    const endpoint = url.pathname.split('/').filter(Boolean).at(-1);
+    uploadPaths.push(endpoint);
+    req.resume();
+    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,
+      },
+      get_minis_import_task_status_for_agent: { status: 2, ready_for_input: true },
+      upload_minis_import_app_icon_for_agent: { icon_uri: 'test-icon' },
+      submit_minis_import_info_for_agent: {},
+      upload_minis_import_package_for_agent: { status: 2, package_uri: 'test-package' },
+    };
+    res.writeHead(endpoint in replies ? 200 : 404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error_info: { code: 0 }, ...replies[endpoint] }));
+  });
+  await new Promise(resolve => uploadServer.listen(0, '127.0.0.1', resolve));
+  try {
+    const saved = await run([...input, '--format', 'ndjson'], 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 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);
+    assert.equal(savedFinal.taskStatusRaw, 2);
+    assert.equal(savedEvents.filter(e => e.terminal).length, 1);
+    assert.deepEqual(uploadPaths, [
+      'create_minis_import_task_for_agent', 'get_minis_import_task_status_for_agent',
+      'upload_minis_import_app_icon_for_agent', 'submit_minis_import_info_for_agent',
+      'upload_minis_import_package_for_agent',
+    ]);
+    assert.doesNotMatch(saved.stdout + saved.stderr, /receipt-test-secret|test-package/);
+  } finally {
+    uploadServer.close();
+  }
   const success = await run(
     [...input, '--mock', '--format', 'ndjson', '--poll-interval', '0.2'],
     async event => {
@@ -117,9 +273,9 @@ async function main() {
   assert.equal(success.code, 0, success.stderr);
   assert.match(bindingHtml, /Upload to TikTok/);
   assert.match(bindingHtml, /class="game-avatar"/);
-  assert.match(bindingHtml, /Mock only/);
+  assert.match(bindingHtml, /PPE \+ Mock/);
   assert.match(bindingHtml, /data-phase="binding"/);
-  assert.match(bindingHtml, /无需扫码|no scan needed/);
+  assert.match(bindingHtml, /Phone authorization is not required/);
   assert.doesNotMatch(bindingHtml, /<form|<input/);
   const sequence = events(success);
   const final = sequence[sequence.length - 1];
@@ -129,7 +285,16 @@ async function main() {
   assert.equal(final.nextAction, 'none');
   assert.equal(sequence.filter(e => e.terminal).length, 1);
   assert.equal(final.uploaded, true);
-  assert.equal(final.platformWrite, false);
+  assert.equal(final.platformWrite, true);
+  assert.equal(final.backend, 'ppe-mock');
+  assert.equal(final.taskStatusRaw, 1);
+  assert.equal(final.readyForInput, false);
+  assert.equal(final.simulatedReadyForInput, true);
+  assert.equal(final.simulatedTaskStatusRaw, 3);
+  assert.equal(requests.length, 4);
+  assert.equal(requests[0].method, 'POST');
+  assert.ok(requests.slice(1).every(r => r.method === 'GET'));
+  assert.doesNotMatch(success.stdout, /process-test-secret/);
   assert.equal(final.simulation, true);
   const progress = sequence.filter(
     e => e.status === 'uploading' && e.loadedBytes !== undefined,
@@ -145,10 +310,56 @@ async function main() {
     1,
   );
   const previewHtml = await (await fetch(final.pageUrl)).text();
-  assert.match(previewHtml, /Upload complete/);
+  assert.match(previewHtml, /Simulated upload complete/);
   assert.match(previewHtml, /data-phase="complete"/);
   assert.doesNotMatch(previewHtml, /QR|preview|review|Publish to TikTok/);
 
+  const beforeWeb = requests.length;
+  const webConflict = await run([...input, '--web', '--mock', '--format', 'json']);
+  assert.equal(events(webConflict)[0].errorCode, 'VIBE_WEB_OPTION_CONFLICT');
+  const legacyWeb = await run(['upload', '--web', '--format', 'json']);
+  assert.equal(events(legacyWeb)[0].errorCode, 'VIBE_OPTION_REQUIRES_VIBE');
+  assert.equal(requests.length, beforeWeb);
+  webMode = true;
+  for (const format of ['json', 'ndjson']) {
+    const receipt = path.join(temp, `upload-web-${format}.ndjson`);
+    const web = await run([...input.filter(v => v !== '--no-open'), '--web', '--format', format, '--poll-interval', '0.2'], async event => {
+      if (event.status === 'waiting_authorization') {
+        assert.equal(event.authorizationMode, 'web');
+        assert.equal(event.browserOpenRequested, true);
+        assert.equal(event.simulation, false);
+        assert.equal(event.nextAction, 'open_browser');
+        assert.equal(event.qrPurpose, undefined);
+        const response = await fetch(event.pageUrl + '/authorize', {redirect: 'manual'});
+        assert.equal(response.status, 302);
+        assert.match(response.headers.get('location'), /^https:\/\/developers\.tiktok\.com\/portal_h5\/minis_import\?/);
+        const html = await (await fetch(event.pageUrl)).text();
+        assert.match(html, /Authorize in your browser/);
+        assert.doesNotMatch(html, /alt="Authorization QR"|Scan the QR code/);
+      }
+    }, {
+      NODE_OPTIONS: env.NODE_OPTIONS + ' --require=' + path.join(__dirname, 'vibe-auth-open-test-preload.cjs'),
+      TTMG_AUTH_OPEN_TEST_RECEIPT: receipt,
+      // Explicit --web must not inherit an old Mock backend setting.
+      TTMG_VIBE_BACKEND: 'mock',
+    });
+    assert.equal(web.code, 1, web.stderr);
+    const output = events(web);
+    assert.equal(output.at(-1).errorCode, 'VIBE_REAL_UPLOAD_NOT_READY');
+    assert.equal(output.at(-1).simulation, false);
+    assert.equal(output.at(-1).backend, 'ppe');
+    assert.equal(output.at(-1).readyForInput, true);
+    assert.equal(output.at(-1).uploadAttempted, false);
+    assert.equal(output.at(-1).uploaded, false);
+    assert.equal(webPolls, 5, 'Only true backend readiness unlocks authorization');
+    if (format === 'json') assert.equal(output.length, 1);
+    const opens = fs.readFileSync(receipt, 'utf8').trim().split('\n').map(line => JSON.parse(line));
+    assert.equal(opens.length, 1);
+    assert.ok(opens[0].args.some(arg => /^http:\/\/127\.0\.0\.1:\d+\/[a-f0-9]{48}\/authorize$/.test(arg)));
+    assert.doesNotMatch(JSON.stringify(opens) + web.stdout + web.stderr, /process-test-secret|import_token|aweme:\/\//);
+  }
+  webMode = false;
+
   const json = await run(
     [...input, '--format', 'json', '--poll-interval', '0.01'],
     undefined,
@@ -160,6 +371,44 @@ async function main() {
   assert.equal(JSON.parse(json.stdout).simulation, true);
   assert.match(json.stderr, /http:\/\/127\.0\.0\.1:/);
 
+  const missingPpe = await run([...input, '--format', 'json'], undefined, {
+    TTMG_VIBE_BACKEND: 'ppe',
+  });
+  assert.equal(missingPpe.code, 1);
+  assert.equal(events(missingPpe)[0].errorCode, 'VIBE_INVALID_PPE_ENV');
+  assert.equal(events(missingPpe)[0].platformWrite, false);
+  const dryPpe = await run([...input, '--dry-run', '--format', 'json'], undefined, {
+    TTMG_VIBE_BACKEND: 'ppe', TTMG_VIBE_PPE: 'ppe_op_vc',
+  });
+  assert.equal(dryPpe.code, 0, dryPpe.stderr);
+  assert.equal(events(dryPpe)[0].status, 'prepared');
+  assert.equal(events(dryPpe)[0].platformWrite, false);
+  const missingHybrid = await run([...input, '--format', 'json'], undefined, {
+    TTMG_VIBE_BACKEND: 'ppe-mock',
+  });
+  assert.equal(events(missingHybrid)[0].errorCode, 'VIBE_INVALID_PPE_ENV');
+  assert.equal(events(missingHybrid)[0].platformWrite, false);
+  const dryHybrid = await run([...input, '--dry-run', '--format', 'json'], undefined, {
+    TTMG_VIBE_BACKEND: 'ppe-mock', TTMG_VIBE_PPE: 'ppe_op_vc',
+  });
+  assert.equal(dryHybrid.code, 0, dryHybrid.stderr);
+  assert.equal(events(dryHybrid)[0].status, 'prepared');
+  assert.equal(events(dryHybrid)[0].platformWrite, false);
+  const hybridMockOverride = await run([...input, '--mock', '--poll-interval', '0.01', '--format', 'json'], undefined, {
+    TTMG_VIBE_BACKEND: 'ppe-mock', TTMG_VIBE_PPE: 'ppe_op_vc',
+  });
+  assert.equal(hybridMockOverride.code, 0, hybridMockOverride.stderr);
+  assert.equal(events(hybridMockOverride)[0].backend, 'ppe-mock');
+  assert.equal(events(hybridMockOverride)[0].platformWrite, true);
+
+  failStatus = true;
+  const realFailure = await run([...input, '--mock', '--format', 'json']);
+  assert.equal(realFailure.code, 1, realFailure.stderr);
+  assert.equal(events(realFailure)[0].errorCode, 'VIBE_BACKEND_REJECTED');
+  assert.equal(events(realFailure)[0].uploadAttempted, false);
+  assert.equal(events(realFailure)[0].uploaded, false);
+  failStatus = false;
+
   for (const [scenario, errorCode, attempted] of [
     ['denied', 'VIBE_AUTH_DENIED', false],
     ['upload-failed', 'VIBE_BACKEND_REQUEST_FAILED', true],
@@ -193,6 +442,11 @@ async function main() {
   assert.equal(prepared.backend, 'none');
   assert.equal(prepared.pageUrl, undefined);
   assert.equal(prepared.uploadAttempted, false);
+  const beforeDryMock = requests.length;
+  const dryMock = await run([...input, '--mock', '--dry-run', '--format', 'json']);
+  assert.equal(dryMock.code, 0);
+  assert.equal(events(dryMock)[0].platformWrite, false);
+  assert.equal(requests.length, beforeDryMock);
 
   const project = path.join(temp, 'project');
   fs.mkdirSync(project);
@@ -228,6 +482,9 @@ async function main() {
   assert.equal(help.code, 0);
   assert.match(help.stdout, /--vibe/);
   assert.match(help.stdout, /--client-key/);
+  const authHelp = await run(['auth', 'open', '--help']);
+  assert.equal(authHelp.code, 0);
+  assert.match(authHelp.stdout, /--page-url/);
 
   let cancelledPage;
   const cancelled = await run(
@@ -254,5 +511,6 @@ main()
   })
   .finally(() => {
     for (const child of children) child.kill('SIGKILL');
+    fixtureServer?.close();
     fs.rmSync(temp, { recursive: true, force: true });
   });

package/dist/scripts/wasm-smoke.js

@@ -0,0 +1,53 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+const entry = process.argv[2] ? path.resolve(process.argv[2]) : path.resolve(__dirname, '../dist/index.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-wasm-smoke-'));
+const input = path.join(root, 'original.wasm');
+const wasm = Buffer.from('0061736d010000000105016000017f0304030000000404017000030707010372756e00000909010041000b030001020a1003040010010b0400412a0b040041070b', 'hex');
+const sha = crypto.createHash('sha256').update(wasm).digest('hex');
+function run(args, env = {}) {
+  const result = spawnSync(process.execPath, [entry, ...args, '--format', 'json'], {
+    cwd: root, encoding: 'utf8', timeout: 15000,
+    env: { ...process.env, TTMGRC_PATH: path.join(root, 'rc.json'), ...env },
+  });
+  assert.ifError(result.error);
+  assert.equal(result.stdout.trim().split('\n').length, 1, result.stdout + result.stderr);
+  const body = JSON.parse(result.stdout);
+  assert.equal(result.status, body.status === 'failed' ? 1 : 0, result.stderr);
+  return body;
+}
+try {
+  fs.writeFileSync(input, wasm);
+  const stub = path.join(root, 'missing-binding.js');
+  fs.writeFileSync(stub, "const Module=require('node:module'); const load=Module._load; Module._load=function(name,...args){if(name==='@anrans001/ttmg-wasmtool')throw new Error('fixture unavailable');return load.call(this,name,...args)};");
+  const unavailable = run(['wasm', 'prepare', '--input', input, '--output', path.join(root, 'missing')], { NODE_OPTIONS: '--require=' + stub });
+  assert.equal(unavailable.errorCode, 'WASM_BINDING_UNAVAILABLE');
+  assert.equal(fs.existsSync(path.join(root, 'missing')), false);
+  const preflight = run(['wasm', 'prepare', '--input', input, '--output', path.join(root, 'dry'), '--dry-run'], { NODE_OPTIONS: '--require=' + stub });
+  assert.equal(preflight.status, 'ready');
+  assert.equal(preflight.nativeBindingChecked, false);
+  assert.equal(fs.existsSync(path.join(root, 'dry')), false);
+  const collection = path.join(root, 'collection.json');
+  fs.writeFileSync(collection, JSON.stringify({ schemaVersion: '1', wasmSha256: sha, funcIds: [0, 1], bootFuncIds: [0] }));
+  const prepared = run(['wasm', 'prepare', '--input', input, '--output', path.join(root, 'prepared')]);
+  if (prepared.errorCode === 'WASM_BINDING_UNAVAILABLE') {
+    console.log('wasm process contract passed; native execution unavailable on this host, not verified');
+  } else {
+    assert.equal(prepared.status, 'succeeded', JSON.stringify(prepared));
+    const split = run(['wasm', 'split', '--input', input, '--collection', collection, '--output', path.join(root, 'split')]);
+    assert.equal(split.status, 'succeeded', JSON.stringify(split));
+    assert.equal(split.detail.totalWasmCount, 3);
+    assert.equal(split.detail.mainWasmCount, 2);
+    assert.equal(split.gameValidation, 'not_evaluated');
+    assert.equal(split.input.wasmSha256, sha);
+    assert.deepEqual(JSON.parse(fs.readFileSync(split.manifest, 'utf8')), split);
+    for (const artifact of split.artifacts) assert.equal(crypto.createHash('sha256').update(fs.readFileSync(artifact.path)).digest('hex'), artifact.sha256);
+    assert.deepEqual(fs.readFileSync(input), wasm);
+    assert.equal(fs.existsSync(path.join(root, 'rc.json')), false);
+    console.log(`wasm process contract passed: native prepare/split on ${process.platform}/${process.arch}, immutable input and verified artifacts`);
+  }
+} finally { fs.rmSync(root, { recursive: true, force: true }); }

package/dist/scripts/wasm-worker.js

@@ -0,0 +1,63 @@
+// Native Wasm operations run in a disposable process so a deadline can stop
+// synchronous native code without blocking or corrupting the CLI owner.
+const fs = require('node:fs');
+const path = require('node:path');
+const zlib = require('node:zlib');
+
+process.once('message', request => {
+  let response;
+  try {
+    let binding;
+    try {
+      binding = require('@anrans001/ttmg-wasmtool');
+    } catch {
+      throw Object.assign(new Error('Wasm tool binding is unavailable for this OS/architecture.'), {
+        code: 'WASM_BINDING_UNAVAILABLE',
+      });
+    }
+    if (request.operation === 'prepare') {
+      const output = path.join(request.output, 'prepared.wasm');
+      const result = binding.prepare(request.input, output);
+      if (!fs.existsSync(output) || result.outputSize <= 0)
+        throw new Error('Wasm preparation produced no output.');
+      fs.writeFileSync(output + '.br', zlib.brotliCompressSync(fs.readFileSync(output), {
+        params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 9 },
+      }));
+      response = { ok: true, detail: { outputSize: result.outputSize, timeCost: result.timeCost } };
+    } else if (request.operation === 'split') {
+      const result = binding.split({
+        input: request.input,
+        outputDir: request.output,
+        funcIds: request.funcIds,
+        alwaysInclude: request.bootFuncIds,
+        archive: true,
+        compress: true,
+        quality: 9,
+        callClosure: true,
+        callIndirectClosure: false,
+      });
+      if (result.code !== 0) throw new Error(result.errMsg || 'Wasm split failed.');
+      if (![...request.funcIds, ...request.bootFuncIds].every(id => id < result.totalWasmCount))
+        throw Object.assign(new Error('Collection contains function IDs outside this Wasm module.'), {
+          code: 'WASM_COLLECTION_INVALID',
+        });
+      const detail = {};
+      for (const key of ['totalWasmCount', 'mainWasmCount', 'tableSize', 'timeCost',
+        'globalVarList', 'collectFuncCount', 'alwaysIncludeAdded', 'closureAdded',
+        'indirectClosureAdded', 'indirectClosureTypes', 'exportAdded']) detail[key] = result[key];
+      detail.outputFiles = [result.mainWasmPath, result.subWasmPath, result.funcMetaPath, result.archivePath]
+        .filter(Boolean).map(file => {
+          if (path.dirname(path.resolve(file)) !== path.resolve(request.output))
+            throw new Error('Native output escaped its assigned directory.');
+          return path.basename(file);
+        });
+      response = { ok: true, detail };
+    } else throw new Error('Unknown Wasm operation.');
+    response.detail.bindingVersion = require('@anrans001/ttmg-wasmtool/package.json').version;
+    response.detail.platform = process.platform;
+    response.detail.arch = process.arch;
+  } catch (error) {
+    response = { ok: false, errorCode: error.code || 'WASM_OPERATION_FAILED', error: error.message };
+  }
+  process.send(response, () => process.disconnect());
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttmg/cli",
-  "version": "0.4.6-vibe-beta.6",
+  "version": "0.4.6-vibe-beta.8",
   "description": "TikTok Mini Game Command Line Tool",
   "license": "ISC",
   "bin": {
@@ -31,11 +31,12 @@
     "test:auth": "node scripts/run-ts-test.js src/commands/common/auth.test.ts",
     "test:capabilities": "node scripts/run-ts-test.js src/commands/common/capabilities.test.ts",
     "test:test-account": "node scripts/run-ts-test.js src/commands/common/testAccount.test.ts",
-    "test:dev-session": "node scripts/run-ts-test.js src/commands/native/dev/agentSession.test.ts",
-    "test:dev-session-command": "node scripts/run-ts-test.js src/commands/native/dev/session.test.ts",
+    "test:dev-session": "node scripts/run-ts-test.js src/commands/native/dev/agentSession.test.ts && npm run test:packaging-compatibility",
+    "test:packaging-compatibility": "node scripts/run-ts-test.js src/commands/native/dev/packagingCompatibility.test.ts",
+    "test:dev-session-command": "node scripts/run-ts-test.js src/commands/native/dev/session.test.ts && node scripts/run-ts-test.js src/commands/native/dev/projectSession.test.ts && node scripts/run-ts-test.js src/commands/native/dev/scanPage.test.ts && node scripts/run-ts-test.js src/commands/native/dev/runtime/logArchive.test.ts && node scripts/run-ts-test.js src/commands/native/dev/capture.test.ts",
     "test:dev-runtime-event": "node scripts/run-ts-test.js src/commands/native/dev/utils/scoket.test.ts",
     "test:dev-runtime-client": "node scripts/run-ts-test.js src/commands/native/dev/runtime/runtime.test.ts",
-    "test:dev-session-control": "node scripts/run-ts-test.js src/commands/native/dev/runtime/sessionControl.test.ts",
+    "test:dev-session-control": "node scripts/run-ts-test.js src/commands/native/dev/runtime/sessionControl.test.ts && node scripts/run-ts-test.js src/commands/native/dev/runtime/previewWorkflow.test.ts",
     "test:dev-runtime-session-follow": "node scripts/run-ts-test.js src/commands/native/dev/runtime/runtimeSessionFollow.test.ts",
     "test:dev-client-preview-orchestrator": "node scripts/run-ts-test.js src/commands/native/dev/runtime/clientPreviewOrchestrator.test.ts",
     "test:dev-watch-change": "node scripts/run-ts-test.js src/commands/native/dev/utils/watchChange.test.ts",
@@ -46,9 +47,10 @@
     "test:check-ai": "node scripts/run-ts-test.js src/commands/native/check/ai.test.ts",
     "test:build-structured": "node scripts/run-ts-test.js src/commands/native/build/build.test.ts",
     "test:doctor": "node scripts/run-ts-test.js src/commands/native/doctor/doctor.test.ts",
-    "test:agent-contract": "npm run test:login && npm run test:auth && npm run test:capabilities && npm run test:test-account && npm run test:upload-preview && npm run test:preview-page && npm run test:check && npm run test:check-ai && npm run test:build-structured && npm run test:doctor && npm run test:dev-session && npm run test:dev-session-command && npm run test:dev-runtime-event && npm run test:dev-runtime-client && npm run test:dev-session-control && npm run test:dev-runtime-session-follow && npm run test:dev-client-preview-orchestrator && npm run test:dev-watch-change && npm run test:network && npm run test:vibe && npx tsc --noEmit && npm run build && npm run test:vibe-process && npm run test:preview-page-process && npm run test:preview-page-detached && npm run verify:dist-version && npm run verify:agent-contract",
-    "test:agent-contract:full": "npm run test:agent-contract && npm run test:dev-default-process && npm run test:dev-game-ready-process && npm run test:dev-client-preview-control-process",
-    "publish:beta": "npm publish --registry=https://registry.npmjs.org/ --access public --tag beta",
+    "test:wasm": "node scripts/run-ts-test.js src/commands/native/wasm/wasm.test.ts && node scripts/acceptance-fixture.test.js",
+    "test:agent-contract": "npm run test:login && npm run test:auth && npm run test:capabilities && npm run test:test-account && npm run test:upload-preview && npm run test:preview-page && npm run test:check && npm run test:check-ai && npm run test:build-structured && npm run test:doctor && npm run test:wasm && npm run test:dev-session && npm run test:dev-session-command && npm run test:dev-runtime-event && npm run test:dev-runtime-client && npm run test:dev-session-control && npm run test:dev-runtime-session-follow && npm run test:dev-client-preview-orchestrator && npm run test:dev-watch-change && npm run test:network && npm run test:vibe && npx tsc --noEmit && npm run build && npm run test:vibe-process && npm run test:preview-page-process && npm run test:preview-page-detached && npm run verify:dist-version && npm run verify:agent-contract",
+    "test:agent-contract:full": "npm run test:agent-contract && npm run test:dev-default-process && npm run test:dev-game-ready-process && npm run test:dev-client-preview-control-process && node scripts/dev-workflow-smoke.js",
+    "publish:beta": "npm publish --registry=https://registry.npmjs.org/ --access public --tag vibe-beta",
     "setup": "node scripts/setup.js",
     "reset:local-state": "node scripts/resetLocalState.js",
     "dev:link": "npm run build && npm link",
@@ -60,7 +62,7 @@
   ],
   "author": "zhanghongyang.mocha",
   "dependencies": {
-    "@anrans001/ttmg-wasmtool": "^0.3.2",
+    "@anrans001/ttmg-wasmtool": "^0.3.3",
     "acorn": "^8.15.0",
     "archiver": "^7.0.1",
     "axios": "^1.11.0",
@@ -93,7 +95,7 @@
     "qs": "6.12.1",
     "semver": "^7.7.2",
     "socks-proxy-agent": "^9.0.0",
-    "ttmg-pack": "0.4.13-beta.2",
+    "ttmg-pack": "0.4.13",
     "ws": "^8.18.3"
   },
   "devDependencies": {