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

package/dist/scripts/dev-game-ready-smoke.js

@@ -0,0 +1,155 @@
+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 WebSocket = require('ws');
+
+const delay = milliseconds =>
+  new Promise(resolve => setTimeout(resolve, milliseconds));
+
+async function waitForFile(file, process, timeoutMs = 20000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (fs.existsSync(file)) return;
+    if (process.exitCode !== null) {
+      throw new Error(`ttmg dev exited before writing ${file}`);
+    }
+    await delay(100);
+  }
+  throw new Error(`Timed out waiting for ${file}`);
+}
+
+async function sendGameReady(port) {
+  await new Promise((resolve, reject) => {
+    const socket = new WebSocket(`ws://127.0.0.1:${port}`);
+    socket.once('error', reject);
+    socket.once('open', () => {
+      socket.send(
+        JSON.stringify({
+          from: 'browser',
+          method: 'runtimeEvent',
+          payload: {
+            method: 'reportScene',
+            payload: { sceneId: 9999 },
+          },
+        }),
+        error => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          socket.close();
+          resolve();
+        },
+      );
+    });
+  });
+}
+
+async function run() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-game-ready-'));
+  const gameDirectory = path.join(root, 'game');
+  const evidenceDirectory = path.join(root, 'evidence');
+  fs.mkdirSync(gameDirectory);
+  fs.mkdirSync(evidenceDirectory);
+  fs.writeFileSync(path.join(gameDirectory, 'game.js'), 'console.log("game");\n');
+  fs.writeFileSync(path.join(gameDirectory, 'game.json'), '{}\n');
+
+  let stdout = '';
+  let stderr = '';
+  const child = spawn(
+    process.execPath,
+    [
+      path.resolve(__dirname, '../dist/index.js'),
+      'dev',
+      '--client-key',
+      'smoke-client',
+      '--events',
+      'ndjson',
+      '--no-open',
+      '--evidence-dir',
+      evidenceDirectory,
+      '--timeout',
+      '20',
+    ],
+    {
+      cwd: gameDirectory,
+      env: { ...process.env, TTMG_DEV_NO_OPEN: '1' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+  child.stdout.on('data', chunk => {
+    stdout += chunk;
+  });
+  child.stderr.on('data', chunk => {
+    stderr += chunk;
+  });
+
+  try {
+    const manifestFile = path.join(evidenceDirectory, 'manifest.json');
+    await waitForFile(manifestFile, child);
+    const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+    await sendGameReady(manifest.network.wsPort);
+    await delay(300);
+    child.kill('SIGTERM');
+    const exitCode = await new Promise(resolve => child.once('close', resolve));
+    assert.equal(exitCode, 0, stderr || stdout);
+
+    const stdoutEvents = stdout
+      .trim()
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map(line => JSON.parse(line));
+    assert.ok(stdoutEvents.length > 0, 'dev did not emit NDJSON events');
+    assert.equal(
+      stdoutEvents.every(
+        event =>
+          event.schemaVersion === '1' &&
+          typeof event.sessionId === 'string' &&
+          Number.isInteger(event.seq) &&
+          typeof event.type === 'string',
+      ),
+      true,
+      'dev stdout contained a non-event JSON object',
+    );
+    assert.equal(
+      stdoutEvents.some(
+        event =>
+          event.type === 'lifecycle' &&
+          event.payload?.state === 'GAME_READY',
+      ),
+      true,
+      'dev stdout did not contain the GAME_READY event',
+    );
+
+    const events = fs
+      .readFileSync(path.join(evidenceDirectory, 'events.ndjson'), 'utf8')
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .map(JSON.parse);
+    const ready = events.find(
+      event =>
+        event.type === 'lifecycle' && event.payload?.state === 'GAME_READY',
+    );
+    assert.equal(ready?.source, 'runtime');
+    assert.equal(ready?.payload?.sceneId, 9999);
+
+    const summary = JSON.parse(
+      fs.readFileSync(path.join(evidenceDirectory, 'summary.json'), 'utf8'),
+    );
+    assert.equal(summary.status, 'passed');
+    assert.equal(summary.errorCode, null);
+  } finally {
+    if (child.exitCode === null) child.kill('SIGTERM');
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+
+  console.log('dev GAME_READY process smoke passed');
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/dist/scripts/dev-workflow-smoke.js

@@ -0,0 +1,260 @@
+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 entry = process.argv[2] ? path.resolve(process.argv[2]) : path.resolve(__dirname, '../dist/index.js');
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-workflow-process-'));
+const game = path.join(root, 'game');
+fs.mkdirSync(game);
+fs.writeFileSync(path.join(game, 'game.js'), 'console.log("round A");');
+fs.writeFileSync(path.join(game, 'game.json'), '{}');
+// Restarted projects contain previous evidence/builds; startup must exclude it.
+fs.mkdirSync(path.join(game, '.ttmg', 'previous-build'), { recursive: true });
+fs.writeFileSync(path.join(game, '.ttmg', 'previous-build', 'game.js'), 'throw new Error("old output must not be compiled");');
+const configPath = path.join(root, 'ttmgrc.json');
+const initialConfig = JSON.stringify({ clientKey: 'unchanged', lang: 'en-US' });
+fs.writeFileSync(configPath, initialConfig);
+const pause = ms => new Promise(resolve => setTimeout(resolve, ms));
+function run(args, directory = game) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [entry, ...args], {
+      cwd: directory,
+      env: {
+        ...process.env,
+        NO_COLOR: '1',
+        FORCE_COLOR: '0',
+        TTMG_DEV_NO_OPEN: '1',
+        TTMGRC_PATH: configPath,
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '',
+      stderr = '';
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error('CLI timeout'));
+    }, 75000);
+    child.stdout.on('data', data => {
+      stdout += data;
+    });
+    child.stderr.on('data', data => {
+      stderr += data;
+    });
+    child.once('error', reject);
+    child.once('close', code => {
+      clearTimeout(timer);
+      try {
+        const lines = stdout.trim().split(/\r?\n/);
+        assert.equal(
+          lines.length,
+          1,
+          'structured stdout must contain one object: ' + stderr,
+        );
+        resolve({ code, result: JSON.parse(lines[0]) });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+let owner;
+let secondOwner;
+async function main() {
+  try {
+    const start = [
+      'dev',
+      '--mode',
+      'client-preview',
+      '--update-mode',
+      'manual',
+      '--background',
+      '--client-key',
+      'smoke-client',
+      '--record-logs',
+      '--timeout',
+      '90',
+      '--format',
+      'json',
+    ];
+    const first = await run(start);
+    assert.equal(first.code, 0, JSON.stringify(first.result));
+    owner = first.result;
+    assert.equal(owner.updateMode, 'manual');
+    assert.equal(owner.reused, false);
+    assert.equal(fs.existsSync(owner.launch.qrPngPath), true);
+    assert.ok(owner.evidence.runtimeLogs);
+    assert.equal(fs.existsSync(path.join(owner.evidence.directory, 'build-output', '.ttmg')), false);
+    assert.equal(fs.existsSync(path.join(owner.evidence.directory, 'build-output', '__GAME__', '.ttmg')), false);
+    assert.ok(
+      fs.existsSync(path.join(owner.evidence.directory, 'build-output')),
+    );
+    const reused = await run(start);
+    assert.equal(reused.result.sessionId, owner.sessionId);
+    assert.equal(reused.result.reused, true);
+    const otherGame = path.join(root, 'other-game');
+    fs.mkdirSync(otherGame);
+    fs.writeFileSync(path.join(otherGame, 'game.js'), 'console.log("independent game");');
+    fs.writeFileSync(path.join(otherGame, 'game.json'), '{}');
+    const second = await run(start, otherGame);
+    assert.equal(second.code, 0, JSON.stringify(second.result));
+    secondOwner = second.result;
+    assert.notEqual(secondOwner.evidence.directory, owner.evidence.directory);
+    assert.ok(fs.existsSync(path.join(secondOwner.evidence.directory, 'build-output')));
+    fs.writeFileSync(configPath, JSON.stringify({ clientKey: 'different-global-key', lang: 'en-US' }));
+    for (const preview of [owner, secondOwner]) {
+      const response = await fetch(new URL('/game/config', preview.endpoints.page));
+      const config = await response.json();
+      assert.equal(config.data.clientKey, 'smoke-client');
+    }
+    fs.writeFileSync(configPath, initialConfig);
+    // Saving files alone must not start an intermediate build in manual mode.
+    const eventCount = fs
+      .readFileSync(owner.evidence.events, 'utf8')
+      .split('\n')
+      .filter(Boolean).length;
+    fs.writeFileSync(path.join(game, 'game.js'), 'console.log("round B");');
+    await pause(3500);
+    assert.equal(
+      fs.readFileSync(owner.evidence.events, 'utf8').split('\n').filter(Boolean)
+        .length,
+      eventCount,
+    );
+    const sync = await run([
+      'dev',
+      'sync',
+      '--request-id',
+      'round-1',
+      '--format',
+      'json',
+    ]);
+    assert.equal(sync.code, 0, JSON.stringify(sync.result));
+    assert.equal(sync.result.iterationId, 'round-1');
+    const observed = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'round-1',
+      '--timeout',
+      '30',
+      '--format',
+      'json',
+    ]);
+    assert.equal(
+      observed.result.status,
+      'needs_action',
+      JSON.stringify(observed.result),
+    );
+    assert.equal(observed.result.nextAction, 'connect_device');
+    assert.equal(observed.result.runtimeBuildVerified, false);
+    assert.equal(observed.result.launch.qrPngPath, owner.launch.qrPngPath);
+    assert.ok(observed.result.sourceDigest);
+    fs.writeFileSync(path.join(game, 'game.js'), 'console.log("round C");');
+    const retry = await run([
+      'dev',
+      'sync',
+      '--request-id',
+      'round-1',
+      '--format',
+      'json',
+    ]);
+    assert.equal(retry.result.buildId, sync.result.buildId);
+    const next = await run([
+      'dev',
+      'sync',
+      '--request-id',
+      'round-2',
+      '--format',
+      'json',
+    ]);
+    const nextResult = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'round-2',
+      '--timeout',
+      '30',
+      '--format',
+      'json',
+    ]);
+    assert.equal(
+      nextResult.result.status,
+      'needs_action',
+      JSON.stringify(nextResult.result),
+    );
+    assert.notEqual(next.result.buildId, sync.result.buildId);
+    assert.notEqual(
+      nextResult.result.sourceDigest,
+      observed.result.sourceDigest,
+    );
+    const stale = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'round-1',
+      '--format',
+      'json',
+    ]);
+    assert.equal(stale.result.errorCode, 'DEV_ITERATION_SUPERSEDED');
+    assert.equal(stale.code, 1);
+    fs.writeFileSync(path.join(game, 'game.js'), 'function {');
+    await run(['dev', 'sync', '--request-id', 'broken', '--format', 'json']);
+    const failed = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'broken',
+      '--timeout',
+      '30',
+      '--format',
+      'json',
+    ]);
+    assert.equal(failed.result.status, 'failed', JSON.stringify(failed.result));
+    fs.writeFileSync(path.join(game, 'game.js'), 'console.log("recovered");');
+    await run(['dev', 'sync', '--request-id', 'recovered', '--format', 'json']);
+    const recovery = await run([
+      'dev',
+      'observe',
+      '--iteration',
+      'recovered',
+      '--timeout',
+      '30',
+      '--format',
+      'json',
+    ]);
+    assert.equal(
+      recovery.result.status,
+      'needs_action',
+      JSON.stringify(recovery.result),
+    );
+    assert.equal(
+      fs.existsSync(path.join(game, '.ttmg', 'preview-start.lock')),
+      false,
+    );
+    assert.equal(fs.readFileSync(configPath, 'utf8'), initialConfig);
+    console.log(
+      'manual preview process smoke passed: start/reuse, two rounds, stale rejection, failure/recovery; no device connected',
+    );
+  } finally {
+    for (const preview of [owner, secondOwner].filter(Boolean)) {
+      const stopped = await run([
+        'dev',
+        'session',
+        'stop',
+        preview.sessionId,
+        '--sessions-dir',
+        preview.evidence.directory,
+        '--format',
+        'json',
+      ]);
+      assert.equal(stopped.code, 0, JSON.stringify(stopped.result));
+      assert.equal(fs.existsSync(preview.evidence.summary), true);
+    }
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+main().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/dist/scripts/prepare-client-preview-acceptance.js

@@ -0,0 +1,65 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+function prepareFixture(output) {
+  if (!output) throw new Error('Provide a new output directory.');
+  const root = path.resolve(output);
+  fs.mkdirSync(root, { recursive: false });
+  const runId = crypto.randomUUID();
+  try {
+    for (const round of ['A', 'B']) {
+      const directory = path.join(root, `round-${round.toLowerCase()}`);
+      fs.mkdirSync(directory);
+      const marker = `TTMG_ACCEPTANCE:${runId}:${round}`;
+      const code = `// Generated acceptance fixture. This is not a commercial game.
+const marker = ${JSON.stringify(marker)};
+const canvas = tt.createCanvas();
+const info = tt.getSystemInfoSync();
+canvas.width = info.windowWidth;
+canvas.height = info.windowHeight;
+const context = canvas.getContext('2d');
+function render() {
+  context.fillStyle = ${JSON.stringify(round === 'A' ? '#175cd3' : '#067647')};
+  context.fillRect(0, 0, canvas.width, canvas.height);
+  context.fillStyle = '#ffffff';
+  context.font = 'bold 36px sans-serif';
+  context.fillText('ROUND ${round}', 20, 70);
+  context.font = '16px monospace';
+  context.fillText(${JSON.stringify(runId.slice(0, 18))}, 20, 110);
+  context.fillText(${JSON.stringify(runId.slice(18))}, 20, 138);
+  console.info(marker + ':info');
+  console.warn(marker + ':warn');
+  console.error(marker + ':error:EXPECTED_FIXTURE_LOG');
+}
+render();
+tt.onShow(render);
+`;
+      fs.writeFileSync(path.join(directory, 'game.js'), code);
+      fs.writeFileSync(path.join(directory, 'game.json'), '{}\n');
+    }
+    fs.cpSync(path.join(root, 'round-a'), path.join(root, 'project'), { recursive: true });
+    const result = {
+      schemaVersion: '1', status: 'prepared', runId, project: path.join(root, 'project'),
+      rounds: ['A', 'B'].map(round => ({ round, source: path.join(root, `round-${round.toLowerCase()}`),
+        marker: `TTMG_ACCEPTANCE:${runId}:${round}`, severities: ['info', 'warn', 'error'],
+        expectedScreen: `ROUND ${round} and the complete runId` })),
+      clientStarted: false, deviceVerified: false, commercialAcceptance: 'not_evaluated',
+    };
+    fs.writeFileSync(path.join(root, 'acceptance.json'), JSON.stringify(result, null, 2) + '\n');
+    return result;
+  } catch (error) {
+    fs.rmSync(root, { recursive: true, force: true });
+    throw error;
+  }
+}
+module.exports = { prepareFixture };
+if (require.main === module) {
+  try {
+    if (process.argv.length !== 3) throw new Error('Usage: node prepare-client-preview-acceptance.js <new-directory>');
+    console.log(JSON.stringify(prepareFixture(process.argv[2])));
+  } catch (error) {
+    console.log(JSON.stringify({ status: 'failed', error: error.message, deviceVerified: false }));
+    process.exitCode = 1;
+  }
+}

package/dist/scripts/preview-page-server-smoke.js

@@ -0,0 +1,63 @@
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+const entryPath = path.resolve(__dirname, '../dist/index.js');
+const child = spawn(process.execPath, [entryPath, '__preview-page-server'], {
+  detached: true,
+  windowsHide: true,
+  stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+});
+
+const ready = new Promise((resolve, reject) => {
+  const timeout = setTimeout(
+    () => reject(new Error('preview page worker did not become ready')),
+    5000,
+  );
+  child.once('error', reject);
+  child.once('exit', code =>
+    reject(new Error(`preview page worker exited early (${code})`)),
+  );
+  child.on('message', message => {
+    if (message?.type === 'error') reject(new Error(message.error));
+    if (message?.type === 'ready') {
+      clearTimeout(timeout);
+      resolve(message);
+    }
+  });
+});
+
+async function main() {
+  child.send({
+    type: 'start',
+    authorizationUrl: 'https://www.tiktok.com/ttmg/dev/client-key',
+    previewUrl: 'https://www.tiktok.com/preview/process-smoke',
+    clientKey: 'client-key',
+    projectName: 'Process Smoke Game',
+    versionId: 'asset-smoke',
+    token: 'b'.repeat(48),
+    ttlMs: 5000,
+  });
+  const result = await ready;
+  assert.match(result.url, /^http:\/\/127\.0\.0\.1:\d+\/preview\/b{48}$/);
+  const response = await fetch(result.url);
+  assert.equal(response.status, 200);
+  assert.equal(
+    response.headers.get('content-type'),
+    'text/html; charset=utf-8',
+  );
+  const html = await response.text();
+  assert.match(html, /Process Smoke Game/);
+  assert.equal((html.match(/data:image\/png;base64,/g) || []).length, 2);
+  console.log('preview page server process smoke passed');
+}
+
+main()
+  .catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+  })
+  .finally(() => {
+    if (child.connected) child.disconnect();
+    child.kill();
+  });

package/dist/scripts/run-ts-test.js

@@ -0,0 +1,41 @@
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const esbuild = require('esbuild');
+
+const entry = process.argv[2];
+if (!entry) {
+  throw new Error('Missing TypeScript test entry.');
+}
+
+const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-cli-test-'));
+const outputFile = path.join(tempDir, 'test.cjs');
+
+try {
+  esbuild.buildSync({
+    entryPoints: [path.resolve(process.cwd(), entry)],
+    bundle: true,
+    platform: 'node',
+    format: 'cjs',
+    target: 'node20',
+    outfile: outputFile,
+    external: ['esbuild'],
+    sourcemap: 'inline',
+    logLevel: 'warning',
+  });
+  execFileSync(process.execPath, [outputFile], {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      NODE_PATH: [
+        path.resolve(process.cwd(), 'node_modules'),
+        process.env.NODE_PATH,
+      ]
+        .filter(Boolean)
+        .join(path.delimiter),
+    },
+  });
+} finally {
+  fs.rmSync(tempDir, { recursive: true, force: true });
+}