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

package/dist/scripts/verify-agent-contract.js

@@ -0,0 +1,410 @@
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const cliRoot = path.resolve(__dirname, '..');
+const cliEntry = path.join(cliRoot, 'dist', 'index.js');
+const packageJson = JSON.parse(
+  fs.readFileSync(path.join(cliRoot, 'package.json'), 'utf8'),
+);
+
+function runCli(args, environment = {}) {
+  const env = {
+    ...process.env,
+    NO_COLOR: '1',
+    FORCE_COLOR: '0',
+    ...environment,
+  };
+  delete env.TTMG_LOGIN_EMAIL;
+  delete env.TTMG_LOGIN_PASSWORD;
+  return spawnSync(process.execPath, [cliEntry, ...args], {
+    cwd: cliRoot,
+    env,
+    encoding: 'utf8',
+  });
+}
+
+function assertExit(result, expected, label) {
+  assert.equal(
+    result.status,
+    expected,
+    `${label} exited ${result.status}: ${result.stderr || result.stdout}`,
+  );
+}
+
+// Exercise the shipped bundle with an unavailable native binding, regardless
+// of the host OS. This catches bundler-hoisted imports as well as source imports.
+function runWithoutWasmBinding(args) {
+  const bootstrap = `
+    const Module = require('node:module');
+    const originalLoad = Module._load;
+    Module._load = function (request, ...rest) {
+      if (request === '@anrans001/ttmg-wasmtool') {
+        throw new Error('WASM_BINDING_MUST_NOT_LOAD_FOR_THIS_COMMAND');
+      }
+      return originalLoad.call(this, request, ...rest);
+    };
+    const [entry, ...args] = process.argv.slice(1);
+    process.argv = [process.execPath, entry, ...args];
+    require(entry);
+  `;
+  return spawnSync(process.execPath, ['-e', bootstrap, cliEntry, ...args], {
+    cwd: cliRoot,
+    env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+}
+
+function parseSingleJson(result, label) {
+  const output = result.stdout.trim();
+  assert.ok(output, `${label} did not write a JSON result to stdout`);
+  const lines = output.split(/\r?\n/);
+  assert.equal(
+    lines.length,
+    1,
+    `${label} contaminated structured stdout with ${lines.length} lines`,
+  );
+  return JSON.parse(lines[0]);
+}
+
+function assertNoSecretKeys(value, label) {
+  const blocked = new Set([
+    'password',
+    'cookie',
+    'authorization',
+    'otp',
+    'proxy',
+  ]);
+  const pending = [value];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current || typeof current !== 'object') continue;
+    for (const [key, child] of Object.entries(current)) {
+      assert.equal(
+        blocked.has(key.toLowerCase()),
+        false,
+        `${label} exposed blocked key: ${key}`,
+      );
+      pending.push(child);
+    }
+  }
+}
+
+assert.ok(fs.existsSync(cliEntry), 'dist/index.js is missing; run build first');
+assertExit(runWithoutWasmBinding(['--help']), 0, 'help without Wasm binding');
+const withoutWasmCapabilities = runWithoutWasmBinding([
+  'capabilities', '--format', 'json',
+]);
+assertExit(withoutWasmCapabilities, 0, 'capabilities without Wasm binding');
+assert.equal(
+  parseSingleJson(withoutWasmCapabilities, 'capabilities without Wasm binding').command,
+  'capabilities',
+);
+const withoutWasmBuild = runWithoutWasmBinding([
+  'build', '--dir', __filename, '--format', 'json',
+]);
+assertExit(withoutWasmBuild, 1, 'build validation without Wasm binding');
+assert.equal(
+  parseSingleJson(withoutWasmBuild, 'build validation without Wasm binding').errorCode,
+  'BUILD_DIRECTORY_NOT_FOUND',
+);
+assert.match(
+  packageJson.scripts.prepack,
+  /verify:dist-version/,
+  'prepack must verify the built CLI version',
+);
+assert.match(
+  packageJson.scripts.prepack,
+  /verify:agent-contract/,
+  'prepack must verify the built CLI agent contract',
+);
+
+const capabilitiesResult = runCli(['capabilities', '--format', 'json']);
+assertExit(capabilitiesResult, 0, 'capabilities');
+const capabilities = parseSingleJson(capabilitiesResult, 'capabilities');
+assert.equal(capabilities.command, 'capabilities');
+assert.equal(capabilities.structuredOutput.stdoutProtocolOnly, true);
+assert.equal(capabilities.commands.check.platformWrite, false);
+assert.equal(capabilities.commands.check.ai.option, '--ai');
+assert.equal(
+  capabilities.commands.check.ai.command,
+  'ttmg check --ai --format json',
+);
+assert.equal(capabilities.commands.build.platformWrite, false);
+assert.equal(capabilities.commands.dev.platformWrite, false);
+assert.equal(
+  capabilities.commands.dev.command,
+  'ttmg dev --format json --no-open',
+);
+assert.equal(
+  capabilities.commands.dev.eventsCommand,
+  'ttmg dev --events ndjson --no-open',
+);
+assert.equal(capabilities.commands.dev.outputModesMutuallyExclusive, true);
+assert.equal(capabilities.commands.dev.clientPreview.available, true);
+assert.equal(capabilities.commands.dev.clientPreview.textOutput, true);
+assert.equal(
+  capabilities.commands.dev.clientPreview.scanPage.urlField,
+  'launch.scanPageUrl',
+);
+assert.equal(
+  capabilities.commands.dev.clientPreview.scanPage.structuredModeAutoOpen,
+  false,
+);
+assert.equal(capabilities.commands.dev.sessionLogs.shortcut, 'ttmg dev logs');
+assert.equal(
+  capabilities.commands.dev.sessionScreenshot.shortcut,
+  'ttmg dev screenshot',
+);
+assert.equal(capabilities.commands.dev.clientPreview.protocolVersion, '1.0');
+assert.equal(capabilities.commands.dev.clientPreview.humanScanRequired, true);
+assert.equal(capabilities.commands.dev.clientPreview.deviceLaunch, false);
+assert.equal(capabilities.commands.dev.clientPreview.verifiedOnDevice, false);
+assert.equal(capabilities.commands.dev.sessionLogs.available, true);
+assert.equal(capabilities.commands.dev.sessionScreenshot.available, true);
+assert.equal(capabilities.commands.uploadPreview.platformWrite, true);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.option,
+  '--serve-preview-page',
+);
+assert.equal(capabilities.commands.uploadPreview.previewPage.inMemory, true);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.reuseScope,
+  'clientKey',
+);
+assert.equal(capabilities.commands.uploadPreview.previewPage.latestOnly, true);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.renewsTtlOnUpload,
+  true,
+);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.textModeAutoOpen,
+  true,
+);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.structuredModeAutoOpen,
+  false,
+);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.noOpenOption,
+  '--no-open',
+);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.presentation.preferredAction,
+  'open_url',
+);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.presentation.terminalInline,
+  false,
+);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.presentation.sameHostRequired,
+  true,
+);
+assert.equal(capabilities.commands.uploadPreview.previewPage.ttlSeconds, 3600);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.expiredNoticeTtlSeconds,
+  3600,
+);
+assert.equal(
+  capabilities.commands.uploadPreview.previewPage.localhostOnly,
+  true,
+);
+assert.equal(capabilities.dev.gameReadyProtocol, true);
+assert.equal(capabilities.dev.gameReady, false);
+assert.equal(capabilities.dev.runtimeLogs, false);
+assert.equal(capabilities.dev.screenshot, false);
+assert.equal(capabilities.dev.clientPreviewProtocol.runtimeLogsVerified, false);
+assert.equal(capabilities.dev.clientPreviewProtocol.screenshotVerified, false);
+assertNoSecretKeys(capabilities, 'capabilities');
+
+const conflictingDevOutput = runCli([
+  'dev',
+  '--format',
+  'json',
+  '--events',
+  'ndjson',
+  '--no-open',
+]);
+assertExit(conflictingDevOutput, 1, 'conflicting dev output modes');
+assert.equal(
+  conflictingDevOutput.stdout,
+  '',
+  'conflicting dev output modes must not write protocol data to stdout',
+);
+assert.match(
+  conflictingDevOutput.stderr,
+  /output modes cannot be combined|输出模式不能同时使用/,
+);
+
+const devHelp = runCli(['dev', '--help']);
+assertExit(devHelp, 0, 'dev help');
+assert.match(devHelp.stdout, /--mode <mode>/);
+assert.match(devHelp.stdout, /--record-logs\b/);
+for (const shortcut of ['logs', 'screenshot']) {
+  const help = runCli(['dev', shortcut, '--help']);
+  assertExit(help, 0, `${shortcut} shortcut help`);
+  assert.match(help.stdout, /--session <sessionId>/);
+  assert.match(help.stdout, /--sessions-dir <path>/);
+  assert.match(help.stdout, /--format <format>/);
+}
+
+const logsHelp = runCli(['dev', 'session', 'logs', '--help']);
+assert.equal(capabilities.commands.dev.iterationWorkflow.runtimeBuildVerified, false);
+assert.match(runCli(['dev', '--help']).stdout, /--background\b/);
+assert.match(runCli(['dev', '--help']).stdout, /--update-mode <mode>/);
+for (const action of ['sync', 'observe']) {
+  const help = runCli(['dev', action, '--help']);
+  assertExit(help, 0, `dev ${action} help`);
+  const missing = runCli(['dev', action, '--format', 'json']);
+  assertExit(missing, 1, `dev ${action} missing identifier`);
+  assert.equal(parseSingleJson(missing, action).errorCode, 'DEV_ITERATION_INVALID_ID');
+  assert.notEqual(runCli(['dev', action, '--unknown-option']).status, 0);
+}
+const invalidBackground = runCli(['dev', '--background', '--format', 'json']);
+assertExit(invalidBackground, 1, 'background mode validation');
+assert.equal(parseSingleJson(invalidBackground, 'background').errorCode, 'DEV_ITERATION_INVALID_OPTIONS');
+const invalidManual = runCli(['dev', '--update-mode', 'invalid', '--format', 'json']);
+assertExit(invalidManual, 1, 'update mode validation');
+assert.equal(parseSingleJson(invalidManual, 'manual').errorCode, 'DEV_ITERATION_INVALID_OPTIONS');
+// Both formats perform the same local build validation; the former text placeholder is retired.
+const missingBuildDirectory = path.join(os.tmpdir(), 'ttmg-build-dir-that-does-not-exist-' + process.pid);
+for (const format of ['text', 'json']) {
+  const result = runCli(['build', '--dir', missingBuildDirectory, '--format', format]);
+  assertExit(result, 1, `build ${format} invalid directory`);
+  if (format === 'json') assert.equal(parseSingleJson(result, 'build').errorCode, 'BUILD_DIRECTORY_NOT_FOUND');
+}
+assertExit(logsHelp, 0, 'dev session logs help');
+assert.match(logsHelp.stdout, /--follow\b/);
+assert.match(logsHelp.stdout, /--until <cursor>/);
+assert.match(logsHelp.stdout, /--source <source>/);
+assert.match(logsHelp.stdout, /--runtime-session <id>/);
+assert.equal(
+  capabilities.commands.dev.sessionLogs.archive.defaultEnabled,
+  false,
+);
+assert.equal(capabilities.commands.dev.sessionLogs.nextQuery, true);
+const invalidRecording = runCli([
+  'dev',
+  '--record-logs',
+  '--format',
+  'json',
+  '--no-open',
+]);
+assertExit(invalidRecording, 1, 'log recording requires client-preview');
+assert.equal(
+  parseSingleJson(invalidRecording, 'invalid log recording').errorCode,
+  'DEV_LOG_INVALID_OPTIONS',
+);
+const invalidLogSource = runCli([
+  'dev',
+  'logs',
+  '--source',
+  'unknown',
+  '--format',
+  'json',
+]);
+assertExit(invalidLogSource, 1, 'invalid log source');
+assert.equal(
+  parseSingleJson(invalidLogSource, 'invalid log source').errorCode,
+  'DEV_LOG_INVALID_OPTIONS',
+);
+
+const screenshotHelp = runCli(['dev', 'session', 'screenshot', '--help']);
+assertExit(screenshotHelp, 0, 'dev session screenshot help');
+assert.match(screenshotHelp.stdout, /--image-format <format>/);
+assert.match(screenshotHelp.stdout, /--runtime-session <id>/);
+assert.match(
+  runCli(['dev', 'screenshot', '--help']).stdout,
+  /--runtime-session <id>/,
+);
+for (const command of [
+  ['dev', 'screenshot'],
+  ['dev', 'session', 'screenshot', 'missing-session'],
+]) {
+  const unknownOption = runCli([...command, '--runtime-sesion', 'unknown']);
+  assert.notEqual(
+    unknownOption.status,
+    0,
+    'unknown screenshot option must fail',
+  );
+}
+
+const checkHelp = runCli(['check', '--help']);
+assertExit(checkHelp, 0, 'check help');
+assert.match(checkHelp.stdout, /Usage: ttmg check \[options\]/);
+assert.match(checkHelp.stdout, /--ai\b/);
+assert.doesNotMatch(checkHelp.stdout, /check \[profile\]/);
+
+const unsupportedCheckProfile = runCli(['check', 'ai']);
+assert.notEqual(
+  unsupportedCheckProfile.status,
+  0,
+  'ttmg check ai must remain unsupported; use the --ai option',
+);
+
+const uploadHelp = runCli(['upload', '--help']);
+assertExit(uploadHelp, 0, 'upload help');
+assert.match(uploadHelp.stdout, /--preview\b/);
+assert.match(uploadHelp.stdout, /--serve-preview-page\b/);
+assert.match(uploadHelp.stdout, /--no-open\b/);
+assert.doesNotMatch(uploadHelp.stdout, /--allow-upload\b/);
+
+const tempDirectory = fs.mkdtempSync(
+  path.join(os.tmpdir(), 'ttmg-agent-contract-'),
+);
+try {
+  const configPath = path.join(tempDirectory, '.ttmgrc');
+  const authResult = runCli(['auth', 'status', '--format', 'json'], {
+    TTMGRC_PATH: configPath,
+  });
+  assertExit(authResult, 0, 'auth status');
+  const auth = parseSingleJson(authResult, 'auth status');
+  assert.equal(auth.command, 'auth.status');
+  assert.equal(auth.status, 'not_authenticated');
+  assert.equal(auth.authenticated, false);
+  assertNoSecretKeys(auth, 'auth status');
+
+  const loginResult = runCli(['login', '--implicit', '--verbose'], {
+    TTMGRC_PATH: configPath,
+  });
+  assertExit(loginResult, 1, 'implicit login without credentials');
+  const login = parseSingleJson(loginResult, 'implicit login');
+  assert.equal(login.operation, 'login');
+  assert.equal(login.status, 'failed');
+  assert.equal(login.errorCode, 'CREDENTIALS_REQUIRED');
+  assert.equal(login.cookieStored, false);
+  assertNoSecretKeys(login, 'implicit login');
+  assert.equal(fs.existsSync(configPath), false);
+} finally {
+  fs.rmSync(tempDirectory, { recursive: true, force: true });
+}
+
+for (const operation of ['prepare', 'split']) {
+  assertExit(runWithoutWasmBinding(['wasm', operation, '--help']), 0, `wasm ${operation} help without binding`);
+  const invalid = runCli(['wasm', operation, '--format', 'json']);
+  assertExit(invalid, 1, `wasm ${operation} missing input`);
+  assert.equal(parseSingleJson(invalid, `wasm ${operation}`).errorCode, 'WASM_INVALID_OPTIONS');
+}
+const wasmSmoke = spawnSync(process.execPath, [path.join(cliRoot, 'scripts/wasm-smoke.js'), cliEntry], {
+  cwd: cliRoot, encoding: 'utf8', timeout: 60000,
+});
+assertExit(wasmSmoke, 0, 'Wasm built-artifact process smoke');
+console.log(wasmSmoke.stdout.trim());
+const captureHelp = runCli(['dev', 'capture', '--help']);
+assertExit(captureHelp, 0, 'capture help');
+assert.match(captureHelp.stdout, /--timeout/);
+const invalidCapture = runCli(['dev', 'capture', '--timeout', '0', '--format', 'json']);
+assertExit(invalidCapture, 1, 'capture invalid timeout');
+assert.equal(parseSingleJson(invalidCapture, 'capture invalid timeout').errorCode, 'DEV_CAPTURE_INVALID_OPTIONS');
+assertExit(runCli(['dev', 'capture', '--format', 'ndjson']), 1, 'capture invalid format inherited from dev');
+assertExit(runCli(['dev', 'capture', '--unknown-option']), 1, 'capture unknown option');
+const captureSmoke = spawnSync(process.execPath, [path.join(cliRoot, 'scripts/dev-capture-smoke.js'), cliEntry], {
+  cwd: cliRoot, encoding: 'utf8', timeout: 45000,
+});
+assertExit(captureSmoke, 0, 'capture built-artifact process smoke');
+console.log(captureSmoke.stdout.trim());
+console.log('built CLI agent contract verified');

package/dist/scripts/vibe-ppe-test-preload.cjs

@@ -0,0 +1,23 @@
+// Explicit test-process preload only; never loaded by the CLI. Replace HTTPS
+// transport with a local fixture so --mock regressions cannot create real tasks.
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const https = require('node:https');
+const port = Number(process.env.TTMG_VIBE_TEST_PORT);
+assert.ok(Number.isInteger(port) && port > 0 && port < 65536);
+https.request = (options, callback) => {
+  assert.equal(typeof options, 'object');
+  assert.equal(options.hostname, 'developers.tiktok.com');
+  assert.equal(options.protocol, 'https:');
+  assert.match(options.path, /^\/bff\/app_info\/minis_import\/(create_minis_import_task_for_agent|get_minis_import_task_status_for_agent)\//);
+  return http.request({
+    ...options,
+    protocol: 'http:', hostname: '127.0.0.1', host: undefined, port,
+    agent: undefined, servername: undefined,
+  }, callback);
+};
+https.get = (options, callback) => {
+  const request = https.request(options, callback);
+  request.end();
+  return request;
+};

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

@@ -0,0 +1,72 @@
+// A local fixture runner, not a second upload implementation.
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+const entry = path.resolve(__dirname, '../dist/index.js');
+if (!fs.existsSync(entry)) throw new Error('Run npm run build first.');
+const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-vibe-demo-'));
+const project = path.join(directory, 'game');
+fs.mkdirSync(project);
+fs.writeFileSync(
+  path.join(project, 'game.js'),
+  'console.log("Vibe mock demo");\n',
+);
+fs.writeFileSync(path.join(project, 'game.json'), '{}\n');
+// Localize this Chinese fixture demo without changing the user's CLI settings.
+fs.writeFileSync(
+  path.join(directory, '.ttmgrc'),
+  JSON.stringify({ lang: 'zh-CN' }),
+);
+const icon = path.join(directory, 'fixture-icon.png');
+// Tiny valid PNG fixture; normal usage still takes the user's own local image.
+fs.writeFileSync(
+  icon,
+  Buffer.from(
+    'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aXyoAAAAASUVORK5CYII=',
+    'base64',
+  ),
+);
+console.error(
+  'Integration demo: creates a real PPE task; authorization and uploads are simulated. No environment setup or phone authorization required.',
+);
+const child = spawn(
+  process.execPath,
+  [
+    entry,
+    'upload',
+    '--vibe',
+    '--mock',
+    '--title',
+    '星环守卫',
+    '--icon',
+    icon,
+    '--dir',
+    project,
+    ...process.argv.slice(2),
+  ],
+  {
+    cwd: directory,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      HOME: directory,
+      USERPROFILE: directory,
+      TTMGRC_PATH: path.join(directory, '.ttmgrc'),
+    },
+  },
+);
+const cancel = () => child.kill('SIGINT');
+process.once('SIGINT', cancel);
+process.once('SIGTERM', cancel);
+child.once('error', () => {
+  console.error('Unable to start CLI demo.');
+  process.exitCode = 1;
+});
+child.once('close', code => {
+  process.off('SIGINT', cancel);
+  process.off('SIGTERM', cancel);
+  process.exitCode = code ?? 1;
+  fs.rmSync(directory, { recursive: true, force: true });
+});