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

package/dist/scripts/dev-client-preview-control-smoke.js

@@ -0,0 +1,606 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const net = require('node:net');
+const os = require('node:os');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+function runCli(args, cwd, inspectScanPage) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      process.execPath,
+      [path.resolve(__dirname, '../dist/index.js'), ...args],
+      {
+        cwd,
+        env: {
+          ...process.env,
+          NO_COLOR: '1',
+          FORCE_COLOR: '0',
+          TTMG_DEV_NO_OPEN: '1',
+        },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      },
+    );
+    let stdout = '';
+    let stderr = '';
+    let inspection = Promise.resolve();
+    let inspectionStarted = false;
+    let inspectionError;
+    const timer = setTimeout(() => child.kill('SIGKILL'), 20000);
+    child.stdout.on('data', chunk => {
+      stdout += chunk;
+      if (inspectScanPage && !inspectionStarted) {
+        for (const line of stdout.split(/\r?\n/)) {
+          let event;
+          try {
+            event = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (event.payload?.state !== 'READY_FOR_SCAN') continue;
+          inspectionStarted = true;
+          inspection = inspectScanPage(event.payload).catch(error => {
+            inspectionError = error;
+          });
+          break;
+        }
+      }
+    });
+    child.stderr.on('data', chunk => {
+      stderr += chunk;
+    });
+    child.once('error', error => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once('close', async status => {
+      clearTimeout(timer);
+      await inspection;
+      if (inspectionError) {
+        reject(inspectionError);
+        return;
+      }
+      if (inspectScanPage && !inspectionStarted) {
+        reject(new Error(`No live scan page: ${stderr || stdout}`));
+        return;
+      }
+      resolve({ status, stdout, stderr });
+    });
+  });
+}
+
+function write(socket, value) {
+  socket.write(`${JSON.stringify(value)}\n`);
+}
+
+async function run() {
+  const shortTmp = process.platform === 'win32' ? os.tmpdir() : '/tmp';
+  const root = fs.mkdtempSync(path.join(shortTmp, 'ttmg-preview-control-'));
+  const gameDirectory = path.join(root, 'game');
+  const previewGameDirectory = path.join(
+    root,
+    `client-preview-project-${'x'.repeat(80)}`,
+  );
+  const sessionId = 'dev_control_smoke';
+  const sessionDirectory = path.join(
+    gameDirectory,
+    '.ttmg',
+    'sessions',
+    sessionId,
+  );
+  const screenshotsDirectory = path.join(sessionDirectory, 'screenshots');
+  fs.mkdirSync(screenshotsDirectory, { recursive: true });
+  fs.mkdirSync(previewGameDirectory, { recursive: true });
+  fs.writeFileSync(
+    path.join(previewGameDirectory, 'game.js'),
+    'console.log("game");\n',
+  );
+  fs.writeFileSync(path.join(previewGameDirectory, 'game.json'), '{}\n');
+  const control =
+    process.platform === 'win32'
+      ? {
+          transport: 'named-pipe',
+          path: `\\\\.\\pipe\\ttmg-${sessionId}`,
+        }
+      : {
+          transport: 'unix',
+          path: path.join(sessionDirectory, 'ipc'),
+        };
+  fs.writeFileSync(
+    path.join(sessionDirectory, 'manifest.json'),
+    JSON.stringify({
+      schemaVersion: '1',
+      command: 'dev',
+      platformWrite: false,
+      sessionId,
+      status: 'ready',
+      mode: 'client-preview',
+      project: { clientKey: 'smoke-client', directory: gameDirectory },
+      process: { pid: process.pid, startedAt: Date.now(), command: 'ttmg dev' },
+      runtime: {
+        status: 'ready',
+        runtimeSessionId: 'runtime-control-smoke',
+        protocolVersion: '1.0',
+        capabilities: { logs: true, screenshot: true },
+      },
+      control,
+    }),
+  );
+  const server = net.createServer(socket => {
+    let buffer = '';
+    socket.on('data', chunk => {
+      buffer += chunk.toString();
+      if (!buffer.includes('\n')) return;
+      const request = JSON.parse(buffer.slice(0, buffer.indexOf('\n')));
+      if (request.operation === 'session.status') {
+        write(socket, {
+          requestId: request.requestId,
+          type: 'result',
+          result: { status: 'ready' },
+        });
+        socket.end();
+        return;
+      }
+      if (request.operation === 'logs.snapshot') {
+        write(socket, {
+          requestId: request.requestId,
+          type: 'result',
+          result: {
+            records: [
+              {
+                sequence: '90071992547409930002',
+                timestamp_ms: 2,
+                severity: 'info',
+                kind: 'text',
+                source: 'native_runtime',
+                message: 'snapshot',
+                formatted_line: '[I][native_runtime] snapshot',
+              },
+            ],
+            nextCursor: '90071992547409930002',
+            oldestCursor: '90071992547409930001',
+            snapshotCursor: '90071992547409930002',
+            hasMore: false,
+            cursorExpired: false,
+          },
+        });
+        socket.end();
+        return;
+      }
+      if (request.operation === 'logs.follow') {
+        write(socket, {
+          requestId: request.requestId,
+          type: 'result',
+          result: {
+            records: [],
+            nextCursor: request.params.after,
+            oldestCursor: '1',
+            snapshotCursor: request.params.after,
+            hasMore: false,
+            cursorExpired: false,
+          },
+        });
+        write(socket, {
+          requestId: request.requestId,
+          type: 'event',
+          records: [
+            {
+              sequence: '90071992547409930003',
+              timestamp_ms: 3,
+              severity: 'error',
+              kind: 'text',
+              source: 'structured_trace',
+              message: 'live',
+              formatted_line: '[E][structured_trace] live',
+            },
+          ],
+          cursor: '90071992547409930003',
+        });
+        write(socket, {
+          requestId: request.requestId,
+          type: 'end',
+          cursor: '90071992547409930003',
+          reason: 'timeout',
+        });
+        socket.end();
+        return;
+      }
+      if (request.operation === 'screenshot.capture') {
+        if (
+          request.params.runtimeSessionId &&
+          request.params.runtimeSessionId !== 'runtime-control-smoke'
+        ) {
+          write(socket, {
+            requestId: request.requestId,
+            type: 'error',
+            errorCode: 'RUNTIME_SESSION_MISMATCH',
+            error: 'Runtime session changed.',
+          });
+          socket.end();
+          return;
+        }
+        assert.equal(request.params.format, 'jpeg');
+        assert.equal(request.params.quality, 0.8);
+        const output =
+          request.params.output ||
+          path.join(screenshotsDirectory, 'default.jpeg');
+        fs.writeFileSync(output, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
+        write(socket, {
+          requestId: request.requestId,
+          type: 'result',
+          result: {
+            path: output,
+            runtimeSessionId: 'runtime-control-smoke',
+            mime: 'image/jpeg',
+            size: 4,
+            width: 1,
+            height: 1,
+            captureTime: '1787700000789',
+            sha256: 'smoke-hash',
+          },
+        });
+        socket.end();
+      }
+    });
+  });
+
+  try {
+    const previewRun = await runCli(
+      [
+        'dev',
+        '--mode',
+        'client-preview',
+        '--client-key',
+        'smoke-client',
+        '--events',
+        'ndjson',
+        '--no-open',
+        '--record-logs',
+        '--timeout',
+        '3',
+      ],
+      previewGameDirectory,
+      async ready => {
+        const pageResponse = await fetch(ready.scanPageUrl, {
+          signal: AbortSignal.timeout(1500),
+        });
+        assert.equal(pageResponse.status, 200);
+        assert.match(
+          pageResponse.headers.get('content-security-policy'),
+          /frame-ancestors 'none'/,
+        );
+        assert.equal(
+          pageResponse.headers.get('access-control-allow-origin'),
+          null,
+          'scan page must bypass game CORS middleware',
+        );
+        const html = await pageResponse.text();
+        assert.match(html, /id="status-title"/);
+        const status = await (
+          await fetch(`${ready.scanPageUrl}/status`)
+        ).json();
+        assert.equal(status.state, 'waiting');
+        assert.equal(status.compile, 'succeeded');
+        assert.equal(status.developerOptions.values.enableDomainCheck, true);
+        const editToken = html.match(/editToken="([a-f0-9]+)"/)[1];
+        const saved = await fetch(`${ready.scanPageUrl}/settings`, {
+          method: 'POST', headers: { 'Content-Type': 'application/json',
+            Origin: new URL(ready.scanPageUrl).origin, 'X-TTMG-Scan-Token': editToken },
+          body: JSON.stringify({ ...status.developerOptions.values, enableAdMock: true }),
+        });
+        assert.equal(saved.status, 200);
+        const savedOptions = (await saved.json()).developerOptions;
+        assert.equal(savedOptions.values.enableAdMock, true);
+        assert.equal(savedOptions.delivery, 'pending');
+        assert.deepEqual((await (await fetch(`${ready.scanPageUrl}/status`)).json()).developerOptions, savedOptions);
+        const png = Buffer.from(
+          await (await fetch(`${ready.scanPageUrl}/qr.png`)).arrayBuffer(),
+        );
+        assert.deepEqual(
+          png,
+          fs.readFileSync(ready.qrPngPath),
+          'page and terminal PNG must use the same launch payload',
+        );
+      },
+    );
+    assert.equal(previewRun.status, 2, previewRun.stderr || previewRun.stdout);
+    const previewEvents = previewRun.stdout
+      .trim()
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map(JSON.parse);
+    const readyForScan = previewEvents.find(
+      event =>
+        event.type === 'lifecycle' && event.payload?.state === 'READY_FOR_SCAN',
+    );
+    assert.ok(readyForScan, previewRun.stderr || previewRun.stdout);
+    assert.equal(fs.existsSync(readyForScan.payload.qrPngPath), true);
+    await assert.rejects(
+      fetch(readyForScan.payload.scanPageUrl, {
+        signal: AbortSignal.timeout(1000),
+      }),
+      'scan page stops with the CLI',
+    );
+    assert.match(
+      readyForScan.payload.scanPageUrl,
+      /^http:\/\/127\.0\.0\.1:\d+\/__ttmg\/client-preview\/[a-f0-9]+$/,
+    );
+    const previewManifest = JSON.parse(
+      fs.readFileSync(readyForScan.payload.manifest, 'utf8'),
+    );
+    assert.ok(previewManifest.evidence.runtimeLogs);
+    const savedRead = await runCli(
+      [
+        'dev',
+        'logs',
+        '--source',
+        'archive',
+        '--session',
+        previewManifest.sessionId,
+        '--format',
+        'json',
+      ],
+      previewGameDirectory,
+    );
+    assert.equal(savedRead.status, 0, savedRead.stderr || savedRead.stdout);
+    const saved = JSON.parse(savedRead.stdout);
+    assert.equal(saved.source, 'archive');
+    assert.equal(saved.archive.state, 'closed');
+    assert.deepEqual(saved.records, []);
+    assert.equal(saved.runtimeSessionId, null);
+    assert.equal(saved.platformWrite, false);
+    if (previewManifest.control?.transport === 'unix') {
+      assert.equal(
+        Buffer.byteLength(previewManifest.control.path) <= 100,
+        true,
+      );
+    }
+    assert.match(previewRun.stderr, /QR image:/);
+    assert.equal(
+      previewEvents.filter(
+        event =>
+          event.type === 'compile' && event.payload?.state === 'succeeded',
+      ).length,
+      1,
+      'session evidence must not trigger an endless recompilation loop',
+    );
+
+    const humanPreview = await runCli(
+      [
+        'dev',
+        '--mode',
+        'client-preview',
+        '--client-key',
+        'smoke-client',
+        '--timeout',
+        '1',
+      ],
+      previewGameDirectory,
+    );
+    assert.equal(
+      humanPreview.status,
+      2,
+      humanPreview.stderr || humanPreview.stdout,
+    );
+    assert.match(humanPreview.stdout, /Scan with TikTok|使用 TikTok 扫码/);
+    assert.match(humanPreview.stdout, /QR image:|二维码图片：/);
+    assert.match(humanPreview.stdout, /ttmg dev screenshot/);
+    assert.ok(!humanPreview.stdout.includes('"schemaVersion"'));
+    for (const id of fs.readdirSync(
+      path.join(previewGameDirectory, '.ttmg', 'sessions'),
+    )) {
+      if (id === previewManifest.sessionId) continue;
+      const base = path.join(previewGameDirectory, '.ttmg', 'sessions', id);
+      const unrecorded = JSON.parse(
+        fs.readFileSync(path.join(base, 'manifest.json'), 'utf8'),
+      );
+      assert.equal(unrecorded.evidence.runtimeLogs, undefined);
+      assert.equal(fs.existsSync(path.join(base, 'runtime-logs')), false);
+    }
+
+    await new Promise((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(control.path, resolve);
+    });
+    if (control.transport === 'unix') fs.chmodSync(control.path, 0o600);
+
+    const snapshotRun = await runCli(
+      [
+        'dev',
+        'session',
+        'logs',
+        sessionId,
+        '--after',
+        '90071992547409930001',
+        '--format',
+        'json',
+      ],
+      gameDirectory,
+    );
+    assert.equal(
+      snapshotRun.status,
+      0,
+      snapshotRun.stderr || snapshotRun.stdout,
+    );
+    const snapshotLines = snapshotRun.stdout.trim().split(/\r?\n/);
+    assert.equal(snapshotLines.length, 1);
+    const snapshot = JSON.parse(snapshotLines[0]);
+    assert.equal(snapshot.command, 'dev.session.logs');
+    assert.equal(snapshot.records[0].sequence, '90071992547409930002');
+    assert.equal(typeof snapshot.records[0].sequence, 'string');
+
+    const followRun = await runCli(
+      [
+        'dev',
+        'session',
+        'logs',
+        sessionId,
+        '--after',
+        '90071992547409930002',
+        '--follow',
+        '--timeout',
+        '1',
+        '--format',
+        'ndjson',
+      ],
+      gameDirectory,
+    );
+    assert.equal(followRun.status, 0, followRun.stderr || followRun.stdout);
+    const frames = followRun.stdout.trim().split(/\r?\n/).map(JSON.parse);
+    assert.deepEqual(
+      frames.map(frame => frame.type),
+      ['log_snapshot', 'log_batch', 'follow_end'],
+    );
+    assert.equal(
+      frames.every(frame => frame.platformWrite === false),
+      true,
+    );
+
+    const screenshotOutput = path.join(root, 'screen.jpeg');
+    const screenshotRun = await runCli(
+      [
+        'dev',
+        'session',
+        'screenshot',
+        sessionId,
+        '--output',
+        screenshotOutput,
+        '--format',
+        'json',
+      ],
+      gameDirectory,
+    );
+    assert.equal(
+      screenshotRun.status,
+      0,
+      screenshotRun.stderr || screenshotRun.stdout,
+    );
+    const screenshotLines = screenshotRun.stdout.trim().split(/\r?\n/);
+    assert.equal(screenshotLines.length, 1);
+    const screenshot = JSON.parse(screenshotLines[0]);
+    assert.equal(screenshot.path, screenshotOutput);
+    assert.equal(screenshot.runtimeSessionId, 'runtime-control-smoke');
+    assert.equal(screenshot.mime, 'image/jpeg');
+    assert.equal('data' in screenshot, false);
+    assert.equal(fs.readFileSync(screenshotOutput).toString('hex'), 'ffd8ffd9');
+    for (const command of [
+      ['dev', 'screenshot', '--session', sessionId],
+      ['dev', 'session', 'screenshot', sessionId],
+    ]) {
+      const pinnedRun = await runCli(
+        [
+          ...command,
+          '--runtime-session',
+          'runtime-control-smoke',
+          '--output',
+          path.join(root, `pinned-${command[1]}.jpeg`),
+          '--format',
+          'json',
+        ],
+        gameDirectory,
+      );
+      assert.equal(pinnedRun.status, 0, pinnedRun.stderr || pinnedRun.stdout);
+      const lines = pinnedRun.stdout.trim().split(/\r?\n/);
+      assert.equal(lines.length, 1);
+      assert.equal(
+        JSON.parse(lines[0]).runtimeSessionId,
+        'runtime-control-smoke',
+      );
+      const invalidOutput = path.join(root, `stale-${command[1]}.jpeg`);
+      const staleRun = await runCli(
+        [
+          ...command,
+          '--runtime-session',
+          'old-runtime',
+          '--output',
+          invalidOutput,
+          '--format',
+          'json',
+        ],
+        gameDirectory,
+      );
+      assert.equal(staleRun.status, 1);
+      assert.equal(
+        JSON.parse(staleRun.stdout).errorCode,
+        'RUNTIME_SESSION_MISMATCH',
+      );
+      assert.equal(fs.existsSync(invalidOutput), false);
+    }
+
+    // Professional-developer shortcuts use the same IPC, without a session ID.
+    const subdirectory = path.join(gameDirectory, 'src');
+    fs.mkdirSync(subdirectory);
+    const humanLogs = await runCli(['dev', 'logs'], subdirectory);
+    assert.equal(humanLogs.status, 0, humanLogs.stderr || humanLogs.stdout);
+    assert.match(humanLogs.stdout, /\[INFO\] \[native_runtime\] snapshot/);
+    const jsonLogs = await runCli(
+      ['dev', 'logs', '--format', 'json'],
+      gameDirectory,
+    );
+    assert.equal(jsonLogs.status, 0, jsonLogs.stderr || jsonLogs.stdout);
+    assert.equal(
+      JSON.parse(jsonLogs.stdout).records[0].sequence,
+      '90071992547409930002',
+    );
+    const humanFollow = await runCli(
+      ['dev', 'logs', '--follow', '--timeout', '1'],
+      gameDirectory,
+    );
+    assert.equal(
+      humanFollow.status,
+      0,
+      humanFollow.stderr || humanFollow.stdout,
+    );
+    assert.match(humanFollow.stdout, /\[ERROR\] \[structured_trace\] live/);
+    const aliasFollow = await runCli(
+      ['dev', 'logs', '--follow', '--timeout', '1', '--format', 'ndjson'],
+      gameDirectory,
+    );
+    assert.equal(
+      aliasFollow.status,
+      0,
+      aliasFollow.stderr || aliasFollow.stdout,
+    );
+    assert.deepEqual(
+      aliasFollow.stdout
+        .trim()
+        .split(/\r?\n/)
+        .map(JSON.parse)
+        .map(frame => frame.type),
+      ['log_snapshot', 'log_batch', 'follow_end'],
+    );
+    const humanShot = await runCli(['dev', 'screenshot'], gameDirectory);
+    assert.equal(humanShot.status, 0, humanShot.stderr || humanShot.stdout);
+    assert.match(humanShot.stdout, /default\.jpeg/);
+    assert.ok(fs.existsSync(path.join(screenshotsDirectory, 'default.jpeg')));
+    const jsonShot = await runCli(
+      [
+        'dev',
+        'screenshot',
+        '--output',
+        path.join(root, 'alias.jpeg'),
+        '--format',
+        'json',
+      ],
+      gameDirectory,
+    );
+    assert.equal(jsonShot.status, 0, jsonShot.stderr || jsonShot.stdout);
+    assert.equal(JSON.parse(jsonShot.stdout).mime, 'image/jpeg');
+    const noSession = await runCli(['dev', 'logs', '--format', 'json'], root);
+    assert.equal(noSession.status, 1);
+    assert.equal(
+      JSON.parse(noSession.stdout).errorCode,
+      'DEV_SESSION_NOT_RUNNING',
+    );
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+
+  console.log('client preview control process smoke passed');
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

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

@@ -0,0 +1,88 @@
+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 delay = milliseconds =>
+  new Promise(resolve => setTimeout(resolve, milliseconds));
+
+async function run() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ttmg-default-dev-'));
+  const gameDirectory = path.join(root, 'game');
+  fs.mkdirSync(gameDirectory);
+  fs.writeFileSync(path.join(gameDirectory, 'game.js'), 'console.log("game");\n');
+  fs.writeFileSync(path.join(gameDirectory, 'game.json'), '{}\n');
+  for (const directory of ['.ttmg', '.ttmg-assets', 'assets/.ttmg']) {
+    fs.mkdirSync(path.join(gameDirectory, directory), { recursive: true });
+    fs.writeFileSync(path.join(gameDirectory, directory, 'data.txt'), 'before');
+  }
+
+  let output = '';
+  const child = spawn(
+    process.execPath,
+    [
+      path.resolve(__dirname, '../dist/index.js'),
+      'dev',
+      '--client-key',
+      'smoke-client',
+    ],
+    {
+      cwd: gameDirectory,
+      env: { ...process.env, TTMG_DEV_NO_OPEN: '1' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+  child.stdout.on('data', chunk => {
+    output += chunk;
+  });
+  child.stderr.on('data', chunk => {
+    output += chunk;
+  });
+
+  try {
+    const deadline = Date.now() + 20000;
+    while (
+      !output.includes('Game resources compiled successfully') &&
+      !output.includes('游戏资源编译成功') &&
+      Date.now() < deadline
+    ) {
+      if (child.exitCode !== null) {
+        throw new Error(`Default ttmg dev exited unexpectedly:\n${output}`);
+      }
+      await delay(100);
+    }
+    assert.match(output, /Game resources compiled successfully|游戏资源编译成功/);
+    // Ordinary dev must not create an Agent session. Existing evidence must
+    // not trigger reloads, while similarly named runtime assets still do.
+    assert.equal(fs.existsSync(path.join(gameDirectory, '.ttmg/sessions')), false);
+    const compileCount = () => (output.match(/Game resources compiled successfully|游戏资源编译成功/g) || []).length;
+    const initialCount = compileCount();
+    fs.writeFileSync(path.join(gameDirectory, '.ttmg/data.txt'), 'new log');
+    await delay(4500);
+    assert.equal(compileCount(), initialCount, 'session writes triggered a rebuild');
+    for (const file of ['.ttmg-assets/data.txt', 'assets/.ttmg/data.txt']) {
+      const before = compileCount();
+      fs.writeFileSync(path.join(gameDirectory, file), 'updated runtime asset');
+      const deadline = Date.now() + 15000;
+      while (compileCount() === before && Date.now() < deadline) {
+        if (child.exitCode !== null) throw new Error(`Default dev exited while watching ${file}:\n${output}`);
+        await delay(100);
+      }
+      assert.ok(compileCount() > before, `${file} did not trigger a rebuild`);
+    }
+  } finally {
+    if (child.exitCode === null) {
+      child.kill('SIGTERM');
+      await new Promise(resolve => child.once('close', resolve));
+    }
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+
+  console.log('default dev compatibility smoke passed');
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});