@ttmg/cli 0.4.6-vibe-beta.22 → 0.4.6-vibe-beta.24

package/dist/index.js

@@ -16386,7 +16386,7 @@ async function authStatus(options = {}) {
     return result;
 }
 
-var version = "0.4.6-vibe-beta.22";
+var version = "0.4.6-vibe-beta.24";
 var engines = {
 	node: ">=20.19.1 <21 || >=22"
 };
@@ -18084,10 +18084,11 @@ withVerboseOption(program
     .option('--poll-interval <seconds>', t('cli.command.upload.vibePollInterval'))
     .option('--timeout <seconds>', t('cli.command.upload.vibeTimeout'))
     .option('--format <format>', t('cli.command.upload.format'), 'text')
-    .addHelpText('after', t('cli.command.upload.vibeWebGuide'))).action(async (cmd) => {
-    if (cmd.vibe) {
+    .addHelpText('after', t('cli.command.upload.vibeWebGuide'))).action(async (cmd, command) => {
+    const uploadOptions = { ...command.optsWithGlobals(), ...cmd };
+    if (uploadOptions.vibe) {
         const { vibeUpload } = await Promise.resolve().then(function () { return index$1; });
-        await vibeUpload(cmd);
+        await vibeUpload(uploadOptions);
         return;
     }
     if ([
@@ -18668,6 +18669,50 @@ const MINIS_IMPORT_PATHS = {
     info: `${prefix}submit_minis_import_info_for_agent/`,
     package: `${prefix}upload_minis_import_package_for_agent/`,
 };
+const sensitiveKey = /authorization|cookie|password|secret|token|email/i;
+function safeTraceUrl(value) {
+    try {
+        const url = new URL(value);
+        for (const key of url.searchParams.keys()) {
+            if (sensitiveKey.test(key))
+                url.searchParams.set(key, '[REDACTED]');
+        }
+        return url.toString();
+    }
+    catch {
+        return value;
+    }
+}
+function safeTraceError(value) {
+    return String(value ?? '')
+        .replace(/([?&](?:import_token|access_token|token)=)[^&#\s]*/gi, '$1[REDACTED]')
+        .replace(/((?:import_token|access_token|token)[=:]\s*)[^,;\s]*/gi, '$1[REDACTED]');
+}
+function safeTraceValue(value, key = '', seen = new WeakSet()) {
+    if (sensitiveKey.test(key))
+        return '[REDACTED]';
+    if (Buffer.isBuffer(value))
+        return { type: 'Buffer', sizeBytes: value.length };
+    if (typeof value === 'string')
+        return /url$/i.test(key) || /^https?:\/\//i.test(value) ? safeTraceUrl(value) : value;
+    if (!value || typeof value !== 'object')
+        return value;
+    if (seen.has(value))
+        return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.map(item => safeTraceValue(item, '', seen));
+    return Object.fromEntries(Object.entries(value).map(([childKey, childValue]) => [
+        childKey,
+        safeTraceValue(childValue, childKey, seen),
+    ]));
+}
+function emitTrace(sink, trace) {
+    try {
+        sink?.(trace);
+    }
+    catch { /* Diagnostics must never affect uploads. */ }
+}
 function safeWebUrl(value) {
     if (typeof value !== 'string')
         throw new VibeError('VIBE_INVALID_RESPONSE');
@@ -18833,7 +18878,7 @@ function createBackend(mode, transport) {
         },
     };
 }
-function createLocalHttpBackend(baseUrl) {
+function createLocalHttpBackend(baseUrl, adapter, trace) {
     let base;
     try {
         base = new URL(safeWebUrl(baseUrl));
@@ -18846,16 +18891,16 @@ function createLocalHttpBackend(baseUrl) {
         base.search ||
         base.hash)
         throw new VibeError('VIBE_INVALID_LOCAL_ENDPOINT');
-    return createHttpBackend('local-http', base.origin);
+    return createHttpBackend('local-http', base.origin, {}, adapter, trace);
 }
-function createPpeBackend(lane, adapter) {
+function createPpeBackend(lane, adapter, trace) {
     // No default lane and no production fallback. Keep PPE requests on the known host.
     if (!lane || !/^ppe_[a-zA-Z0-9_-]{1,64}$/.test(lane))
         throw new VibeError('VIBE_INVALID_PPE_ENV');
     const backend = createHttpBackend('ppe', 'https://developers.tiktok.com', {
         'x-use-ppe': '1',
         'x-tt-env': lane,
-    }, adapter);
+    }, adapter, trace);
     return {
         ...backend,
         uploadAvailable: true,
@@ -18864,11 +18909,11 @@ function createPpeBackend(lane, adapter) {
 /** Opt-in integration demo: only creation and polling can reach PPE. */
 // Release-owned configuration, not a developer setup step. Remove PPE routing
 // here when the production chain is ready; do not change the Skill command.
-function createVibeTrialBackend(scenario, adapter) {
-    return createPpeMockBackend('ppe_op_vc', adapter, scenario);
+function createVibeTrialBackend(scenario, adapter, trace) {
+    return createPpeMockBackend('ppe_op_vc', adapter, scenario, trace);
 }
-function createPpeMockBackend(lane, adapter, scenario = 'success') {
-    const real = createPpeBackend(lane, adapter);
+function createPpeMockBackend(lane, adapter, scenario = 'success', trace) {
+    const real = createPpeBackend(lane, adapter, trace);
     const mock = createMockBackend(scenario);
     let realTask;
     let mockTask;
@@ -18914,7 +18959,7 @@ function createPpeMockBackend(lane, adapter, scenario = 'success') {
         uploadPackage: async (task, input, signal, onProgress) => mock.uploadPackage(uploadTask(task), input, signal, onProgress),
     };
 }
-function createHttpBackend(mode, baseURL, environmentHeaders = {}, adapter) {
+function createHttpBackend(mode, baseURL, environmentHeaders = {}, adapter, trace) {
     // Own the agents so an early multipart response cannot leave upload sockets
     // keeping the CLI alive after its terminal result. Never destroy global agents.
     const httpAgent = new http.Agent();
@@ -18928,7 +18973,11 @@ function createHttpBackend(mode, baseURL, environmentHeaders = {}, adapter) {
         httpAgent,
         httpsAgent,
     });
+    let requestSequence = 0;
     const backend = createBackend(mode, async (request) => {
+        const requestId = ++requestSequence;
+        const startedAt = Date.now();
+        const url = new URL(request.path, baseURL).toString();
         try {
             let body;
             let headers = {};
@@ -18950,18 +18999,42 @@ function createHttpBackend(mode, baseURL, environmentHeaders = {}, adapter) {
                 body = JSON.stringify(request.data).replace(/"task_id":"([1-9]\d*)"/, '"task_id":$1');
                 headers = { 'Content-Type': 'application/json' };
             }
-            return (await client.request({
+            const requestHeaders = { ...environmentHeaders, ...headers };
+            emitTrace(trace, {
+                event: 'http_request', requestId, method: request.method, url,
+                headers: safeTraceValue(requestHeaders),
+                request: safeTraceValue(request.data),
+            });
+            const response = await client.request({
                 method: request.method,
                 url: request.path,
                 params: request.method === 'GET' ? request.data : undefined,
                 data: body,
-                headers: { ...environmentHeaders, ...headers },
+                headers: requestHeaders,
                 signal: request.signal,
                 maxBodyLength: Infinity,
                 onUploadProgress: p => request.onProgress?.(p.loaded, p.total),
-            })).data;
+            });
+            emitTrace(trace, {
+                event: 'http_response', requestId, method: request.method, url,
+                statusCode: response.status,
+                headers: safeTraceValue(response.headers),
+                response: safeTraceValue(response.data),
+                elapsedMs: Date.now() - startedAt,
+            });
+            return response.data;
         }
-        catch {
+        catch (error) {
+            emitTrace(trace, {
+                event: 'http_error', requestId, method: request.method, url,
+                statusCode: error?.response?.status,
+                headers: safeTraceValue(error?.response?.headers),
+                response: safeTraceValue(error?.response?.data),
+                elapsedMs: Date.now() - startedAt,
+                error: request.signal.aborted
+                    ? 'Request cancelled'
+                    : safeTraceError(error?.message || error),
+            });
             throw new VibeError(request.signal.aborted
                 ? 'VIBE_CANCELLED'
                 : 'VIBE_BACKEND_REQUEST_FAILED');
@@ -20166,6 +20239,16 @@ async function executeVibeUpload(options, onEvent = () => { }, dependencies = {}
         errorCode: null,
         error: null,
     };
+    const httpTrace = options.verbose
+        ? trace => console.error(JSON.stringify({
+            schemaVersion: '1',
+            command: 'upload',
+            mode: 'vibe',
+            operationId: result.operationId,
+            ts: Date.now(),
+            ...trace,
+        }))
+        : undefined;
     const emit = (status, fields = {}) => {
         result = {
             ...result,
@@ -20235,13 +20318,13 @@ async function executeVibeUpload(options, onEvent = () => { }, dependencies = {}
         }, timeoutMs);
         if (!options.dryRun && !backend) {
             if (options.mock)
-                backend = deps.createTrialBackend(options.mockScenario);
+                backend = deps.createTrialBackend(options.mockScenario, undefined, httpTrace);
             else if (hybridSelected)
-                backend = createPpeMockBackend(ppeLane, undefined, options.mockScenario);
+                backend = createPpeMockBackend(ppeLane, undefined, options.mockScenario, httpTrace);
             else if (ppeSelected)
-                backend = createPpeBackend(ppeLane);
+                backend = createPpeBackend(ppeLane, undefined, httpTrace);
             else if (options.vibeApi)
-                backend = createLocalHttpBackend(options.vibeApi);
+                backend = createLocalHttpBackend(options.vibeApi, undefined, httpTrace);
             else
                 throw new VibeError('VIBE_BACKEND_NOT_CONFIGURED');
         }
@@ -20288,11 +20371,14 @@ async function executeVibeUpload(options, onEvent = () => { }, dependencies = {}
             hybrid: backend.mode === 'ppe-mock',
         };
         const sourceProjectId = deps.projectId(options);
+        // The project ID identifies the game; the task request ID is new for each upload.
+        // Keep it separate from the operation ID used in progress events.
+        const taskIdempotencyId = crypto.randomUUID();
         emit('creating_task', { platformWrite: backend.mode === 'ppe' || backend.mode === 'ppe-mock' });
         task = await backend.createTask({
             source_type: 1,
             source_project_id: sourceProjectId,
-            task_idempotency_id: result.operationId,
+            task_idempotency_id: taskIdempotencyId,
             minis_type: minisType,
         }, controller.signal);
         ensureActive();