@ttmg/cli 0.4.4 → 0.4.6-agent-beta.1

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

@@ -0,0 +1,412 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+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-'));
+const icon = path.join(temp, 'avatar.png');
+const zip = path.join(temp, 'game.zip');
+const input = [
+  'upload',
+  '--vibe',
+  '--title',
+  'Local test game',
+  '--icon',
+  icon,
+  '--package',
+  zip,
+  '--no-open',
+];
+const png =
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aXyoAAAAASUVORK5CYII=';
+const children = new Set();
+let fixtureServer;
+const requests = [];
+let failStatus = false;
+const env = {
+  ...process.env,
+  HOME: temp,
+  USERPROFILE: temp,
+  TTMGRC_PATH: path.join(temp, '.ttmgrc'),
+  TTMG_VIBE_PAGE_TTL_MS: '7000',
+  TTMG_VIBE_BACKEND: '',
+  TTMG_VIBE_API: '',
+  TTMG_VIBE_PPE: '',
+};
+
+function run(args, onEvent, extraEnv = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [entry, ...args], {
+      cwd: temp,
+      env: { ...env, ...extraEnv },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    children.add(child);
+    let stdout = '';
+    let stderr = '';
+    let pending = '';
+    let callbackError;
+    const callbacks = [];
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error('CLI process timed out'));
+    }, 12000);
+    child.stdout.on('data', chunk => {
+      stdout += chunk;
+      pending += chunk;
+      let newline;
+      while ((newline = pending.indexOf('\n')) >= 0) {
+        const line = pending.slice(0, newline);
+        pending = pending.slice(newline + 1);
+        if (onEvent && line.trim()) {
+          try {
+            callbacks.push(
+              Promise.resolve(onEvent(JSON.parse(line), child)).catch(error => {
+                callbackError = error;
+              }),
+            );
+          } catch (error) {
+            callbackError = error;
+          }
+        }
+      }
+    });
+    child.stderr.on('data', chunk => {
+      stderr += chunk;
+    });
+    child.once('error', reject);
+    child.once('close', async (code, signal) => {
+      clearTimeout(timer);
+      children.delete(child);
+      await Promise.all(callbacks);
+      if (callbackError) reject(callbackError);
+      else resolve({ code, signal, stdout, stderr });
+    });
+  });
+}
+function events(result) {
+  assert.doesNotMatch(
+    result.stdout,
+    /upload_uuid|upload_token|import_token|importToken|mock-secret|mock-authorization/,
+  );
+  return result.stdout
+    .trim()
+    .split('\n')
+    .map(line => JSON.parse(line));
+}
+async function main() {
+  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/');
+    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?import_token=process-test-secret',
+      poll_interval_seconds: 0.01,
+    } : { status: 1, ready_for_input: false };
+    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);
+    const archive = archiver('zip');
+    out.once('close', resolve);
+    out.once('error', reject);
+    archive.once('error', reject);
+    archive.pipe(out);
+    archive.append('console.log("local fixture")', { name: 'game.js' });
+    archive.finalize().catch(reject);
+  });
+
+  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 => {
+      if (event.status === 'waiting_authorization')
+        bindingHtml = await (await fetch(event.pageUrl)).text();
+    },
+  );
+  assert.equal(success.code, 0, success.stderr);
+  assert.match(bindingHtml, /Upload to TikTok/);
+  assert.match(bindingHtml, /class="game-avatar"/);
+  assert.match(bindingHtml, /PPE \+ Mock/);
+  assert.match(bindingHtml, /data-phase="binding"/);
+  assert.match(bindingHtml, /Phone authorization is not required/);
+  assert.doesNotMatch(bindingHtml, /<form|<input/);
+  const sequence = events(success);
+  const final = sequence[sequence.length - 1];
+  assert.equal(final.schemaVersion, '2');
+  assert.equal(final.status, 'uploaded');
+  assert.equal(final.terminal, true);
+  assert.equal(final.nextAction, 'none');
+  assert.equal(sequence.filter(e => e.terminal).length, 1);
+  assert.equal(final.uploaded, true);
+  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,
+  );
+  assert.equal(progress[0].loadedBytes, 0);
+  assert.equal(
+    progress[progress.length - 1].loadedBytes,
+    progress[progress.length - 1].totalBytes,
+  );
+  assert.ok(progress.length >= 6);
+  assert.equal(
+    sequence.filter(e => e.status === 'waiting_authorization').length,
+    1,
+  );
+  const previewHtml = await (await fetch(final.pageUrl)).text();
+  assert.match(previewHtml, /Simulated upload complete/);
+  assert.match(previewHtml, /data-phase="complete"/);
+  assert.doesNotMatch(previewHtml, /QR|preview|review|Publish to TikTok/);
+
+  const json = await run(
+    [...input, '--format', 'json', '--poll-interval', '0.01'],
+    undefined,
+    { TTMG_VIBE_BACKEND: 'mock' },
+  );
+  assert.equal(json.code, 0, json.stderr);
+  assert.equal(events(json).length, 1);
+  assert.equal(JSON.parse(json.stdout).status, 'uploaded');
+  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],
+  ]) {
+    const failed = await run([
+      ...input,
+      '--mock',
+      '--mock-scenario',
+      scenario,
+      '--poll-interval',
+      '0.01',
+      '--format',
+      'json',
+    ]);
+    assert.equal(failed.code, 1, failed.stderr);
+    const result = events(failed)[0];
+    assert.equal(result.status, 'failed');
+    assert.equal(result.errorCode, errorCode);
+    assert.equal(result.uploadAttempted, attempted);
+    assert.equal(result.uploaded, false);
+    assert.equal(result.terminal, true);
+    const html = await (await fetch(result.pageUrl)).text();
+    assert.match(html, /data-phase="failed"/);
+    assert.doesNotMatch(html, /alt="Authorization QR"|data-phase="complete"/);
+  }
+
+  const dryRun = await run([...input, '--dry-run', '--format', 'json']);
+  assert.equal(dryRun.code, 0, dryRun.stderr);
+  const prepared = events(dryRun)[0];
+  assert.equal(prepared.status, 'prepared');
+  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);
+  fs.writeFileSync(path.join(project, 'game.js'), 'console.log("game");\n');
+  fs.writeFileSync(path.join(project, 'game.json'), '{}\n');
+  const projectRun = await run([
+    'upload',
+    '--vibe',
+    '--title',
+    'Source game',
+    '--icon',
+    icon,
+    '--dir',
+    project,
+    '--dry-run',
+    '--format',
+    'json',
+  ]);
+  assert.equal(projectRun.code, 0, projectRun.stdout + projectRun.stderr);
+  assert.equal(events(projectRun)[0].status, 'prepared');
+  assert.ok(events(projectRun)[0].packageSizeBytes > 0);
+
+  const missingBackend = await run([...input, '--format', 'json']);
+  assert.equal(missingBackend.code, 1);
+  assert.equal(
+    events(missingBackend)[0].errorCode,
+    'VIBE_BACKEND_NOT_CONFIGURED',
+  );
+  const badMode = await run(['upload', '--title', 'x', '--format', 'json']);
+  assert.equal(badMode.code, 1);
+  assert.equal(events(badMode)[0].errorCode, 'VIBE_OPTION_REQUIRES_VIBE');
+  const help = await run(['upload', '--help']);
+  assert.equal(help.code, 0);
+  assert.match(help.stdout, /--vibe/);
+  assert.match(help.stdout, /--client-key/);
+
+  let cancelledPage;
+  const cancelled = await run(
+    [...input, '--mock', '--mock-scenario', 'timeout', '--format', 'ndjson'],
+    (event, child) => {
+      if (event.status === 'waiting_authorization') {
+        cancelledPage = event.pageUrl;
+        child.kill('SIGINT');
+      }
+    },
+  );
+  assert.equal(cancelled.code, 130, cancelled.stderr);
+  assert.equal(events(cancelled).slice(-1)[0].status, 'cancelled');
+  await assert.rejects(fetch(cancelledPage));
+  // Detached success pages expire without leaving a permanent background worker.
+  await new Promise(resolve => setTimeout(resolve, 2600));
+  await assert.rejects(fetch(final.pageUrl));
+  console.log('vibe upload process smoke passed');
+}
+main()
+  .catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+  })
+  .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/dist/scripts/worker.js

@@ -17,7 +17,8 @@ const messages = {
     'worker.compile.initOutputFailed':
       'Failed to initialize output directory: {error}',
     'worker.compile.buildFailed': 'Build failed',
-    'worker.update.noGlobalInstall': 'Global install of {pkgName} was not detected',
+    'worker.update.noGlobalInstall':
+      'Global install of {pkgName} was not detected',
     'worker.update.available': 'Update available!',
     'worker.update.changelog': 'Changelog:',
     'worker.update.toUpdate': 'To update, run:',
@@ -143,29 +144,32 @@ async function compile(context = {}) {
     parentPort?.postMessage({ type: 'status', status: 'start' });
 
     // 调用打包
-    const { isSuccess, errorMsg, packages } = await debugPkgs({
-      entry: entryDir,
-      output: outputDir,
-      dev: {
-        enable: true,
-        port: devPort,
-        host: 'localhost',
-        enableSourcemap: true,
-        enableLog: false,
+    const { isSuccess, errorMsg, packages, checkResults } = await debugPkgs(
+      {
+        entry: entryDir,
+        output: outputDir,
+        dev: {
+          enable: true,
+          port: devPort,
+          host: 'localhost',
+          enableSourcemap: true,
+          enableLog: false,
+        },
+        build: {
+          enableAPICheck: true,
+          enableOdr: false,
+          pkgSizeLimit: 30 * 1024 * 1024,
+          mainPkgSizeLimit: 4 * 1024 * 1024,
+          independentSubPkgSizeLimit: 4 * 1024 * 1024,
+        },
+        // 如果 ttmg-pack 支持透传选项，可考虑加上 stdio/并发等设置：
+        // spawnOptions: { stdio: ['ignore', 'pipe', 'pipe'] },
+        // concurrency: 4,
       },
-      build: {
-        enableAPICheck: true,
-        enableOdr: false,
-        pkgSizeLimit: 30 * 1024 * 1024,
-        mainPkgSizeLimit: 4 * 1024 * 1024,
-        independentSubPkgSizeLimit: 4 * 1024 * 1024,
+      {
+        lang,
       },
-      // 如果 ttmg-pack 支持透传选项，可考虑加上 stdio/并发等设置：
-      // spawnOptions: { stdio: ['ignore', 'pipe', 'pipe'] },
-      // concurrency: 4,
-    }, {
-      lang,
-    });
+    );
     if (fs.existsSync(path.join(outputDir, '__TTMG_TEMP__'))) {
       fs.rmSync(path.join(outputDir, '__TTMG_TEMP__'), {
         recursive: true,
@@ -179,6 +183,7 @@ async function compile(context = {}) {
         status: 'end',
         isSuccess: false,
         errorMsg: errorMsg || t('worker.compile.buildFailed'),
+        checkResults: checkResults || [],
       });
     } else {
       parentPort?.postMessage({
@@ -186,6 +191,7 @@ async function compile(context = {}) {
         status: 'end',
         isSuccess: true,
         packages,
+        checkResults: checkResults || [],
       });
     }
   } catch (err) {