@ttmg/cli 0.4.6-vibe-beta.5 → 0.4.6-vibe-beta.7

package/dist/package.json

@@ -1,19 +1,23 @@
 {
   "name": "@ttmg/cli",
-  "version": "0.4.6-vibe-beta.5",
+  "version": "0.4.6-vibe-beta.7",
   "description": "TikTok Mini Game Command Line Tool",
   "license": "ISC",
   "bin": {
     "ttmg": "dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "vibe-upload.md"
   ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
+    "demo:vibe": "npm run build && node scripts/vibe-upload-demo.js",
+    "test:vibe": "node scripts/run-ts-test.js src/commands/common/vibe/vibe.test.ts",
+    "test:vibe-process": "node scripts/vibe-upload-smoke.js",
     "prepack": "npm run build && npm run verify:dist-version && npm run verify:agent-contract",
     "build": "node scripts/build.js",
     "verify:dist-version": "node scripts/verify-dist-version.js",
@@ -30,14 +34,20 @@
     "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-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-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",
     "test:dev-game-ready-process": "npm run build && node scripts/dev-game-ready-smoke.js",
     "test:dev-default-process": "npm run build && node scripts/dev-default-smoke.js",
+    "test:dev-client-preview-control-process": "npm run build && node scripts/dev-client-preview-control-smoke.js",
     "test:check": "node scripts/run-ts-test.js src/commands/native/check/check.test.ts",
     "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:network && npx tsc --noEmit && npm run build && 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",
+    "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",
     "setup": "node scripts/setup.js",
     "reset:local-state": "node scripts/resetLocalState.js",

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

@@ -0,0 +1,322 @@
+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) {
+  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' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      },
+    );
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', chunk => {
+      stdout += chunk;
+    });
+    child.stderr.on('data', chunk => {
+      stderr += chunk;
+    });
+    child.once('error', reject);
+    child.once('close', status => 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 === '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') {
+        assert.equal(request.params.format, 'jpeg');
+        assert.equal(request.params.quality, 0.8);
+        const output = request.params.output;
+        fs.writeFileSync(output, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
+        write(socket, {
+          requestId: request.requestId,
+          type: 'result',
+          result: {
+            path: output,
+            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',
+        '--timeout',
+        '1',
+      ],
+      previewGameDirectory,
+    );
+    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);
+    const previewManifest = JSON.parse(
+      fs.readFileSync(readyForScan.payload.manifest, 'utf8'),
+    );
+    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',
+    );
+
+    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.mime, 'image/jpeg');
+    assert.equal('data' in screenshot, false);
+    assert.equal(fs.readFileSync(screenshotOutput).toString('hex'), 'ffd8ffd9');
+  } 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/verify-agent-contract.js

@@ -103,6 +103,13 @@ assert.equal(
   '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.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,
@@ -153,6 +160,10 @@ assert.equal(
 );
 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([
@@ -174,6 +185,19 @@ assert.match(
   /output modes cannot be combined|输出模式不能同时使用/,
 );
 
+const devHelp = runCli(['dev', '--help']);
+assertExit(devHelp, 0, 'dev help');
+assert.match(devHelp.stdout, /--mode <mode>/);
+
+const logsHelp = runCli(['dev', 'session', 'logs', '--help']);
+assertExit(logsHelp, 0, 'dev session logs help');
+assert.match(logsHelp.stdout, /--follow\b/);
+assert.match(logsHelp.stdout, /--until <cursor>/);
+
+const screenshotHelp = runCli(['dev', 'session', 'screenshot', '--help']);
+assertExit(screenshotHelp, 0, 'dev session screenshot help');
+assert.match(screenshotHelp.stdout, /--image-format <format>/);
+
 const checkHelp = runCli(['check', '--help']);
 assertExit(checkHelp, 0, 'check help');
 assert.match(checkHelp.stdout, /Usage: ttmg check \[options\]/);

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 });
+});