@jackwener/opencli 1.7.22 → 1.8.1

package/clis/confluence/search.js

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { atlassianRequest, parseLimit, queryString, requireNonEmptyRows, requireString } from '../_atlassian/shared.js';
+import { confluenceConfig, confluenceResults, normalizeSearchResult, withSpaceCql } from './shared.js';
+
+cli({
+    site: 'confluence',
+    name: 'search',
+    access: 'read',
+    description: 'Search Confluence content with CQL',
+    domain: 'atlassian.net',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'cql', positional: true, required: true, help: 'CQL query, e.g. "type = page and title ~ \\"RCA\\""' },
+        { name: 'space', type: 'string', help: 'Limit search to a Confluence space key' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results to return (1-100)' },
+    ],
+    columns: ['id', 'title', 'type', 'spaceKey', 'status', 'lastModified', 'url'],
+    func: async (args) => {
+        const config = confluenceConfig();
+        const cql = withSpaceCql(requireString(args.cql, 'CQL'), args.space);
+        const limit = parseLimit(args.limit, 20, 100, 'confluence limit');
+        // CQL search is still exposed through Confluence REST v1 for Cloud;
+        // page CRUD uses v2 where available.
+        const path = `/rest/api/search${queryString({ cql, limit })}`;
+        const data = await atlassianRequest(config, path, { label: 'confluence search' });
+        const results = confluenceResults(data, 'confluence search');
+        return requireNonEmptyRows(
+            results.map((result) => normalizeSearchResult(result, config)),
+            'confluence search',
+            `No Confluence content matched "${cql}".`,
+        );
+    },
+});

package/clis/confluence/shared.js

@@ -0,0 +1,173 @@
+import {
+    atlassianRequest,
+    getConfluenceConfig,
+    htmlToMarkdown,
+    markdownToConfluenceStorage,
+    queryString,
+    requirePayloadArray,
+    requirePayloadObject,
+    requirePayloadString,
+    readUtf8File,
+    requireString,
+} from '../_atlassian/shared.js';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+
+export function confluenceConfig() {
+    return getConfluenceConfig();
+}
+
+function confluenceUrl(config, link) {
+    if (!link) return '';
+    if (/^https?:\/\//i.test(link)) return link;
+    return `${config.baseUrl}${link.startsWith('/') ? link : `/${link}`}`;
+}
+
+function pageStorageBody(page) {
+    return page?.body?.storage?.value
+        ?? page?.body?.view?.value
+        ?? '';
+}
+
+export function normalizeConfluencePage(page, config) {
+    const row = requirePayloadObject(page, 'confluence page');
+    const id = requirePayloadString(row.id, 'page id', 'confluence page');
+    const title = requirePayloadString(row.title, 'title', 'confluence page');
+    const storage = pageStorageBody(row);
+    const version = row.version?.number != null ? Number(row.version.number) : undefined;
+    const links = row._links && typeof row._links === 'object' && !Array.isArray(row._links) ? row._links : {};
+    const webui = links.webui ?? links.tinyui ?? '';
+    return {
+        id,
+        title,
+        status: String(row.status ?? ''),
+        spaceId: row.spaceId != null ? String(row.spaceId) : undefined,
+        spaceKey: row.space?.key ? String(row.space.key) : undefined,
+        parentId: row.parentId != null ? String(row.parentId) : undefined,
+        version,
+        createdAt: row.createdAt ? String(row.createdAt) : undefined,
+        updatedAt: row.version?.createdAt ?? row.version?.when ?? undefined,
+        url: confluenceUrl(config, webui),
+        body: {
+            storage,
+            markdown: htmlToMarkdown(storage),
+        },
+    };
+}
+
+export async function getPage(config, pageId) {
+    if (config.deployment === 'cloud') {
+        const page = await atlassianRequest(config, `/api/v2/pages/${encodeURIComponent(pageId)}${queryString({ 'body-format': 'storage' })}`, {
+            label: `confluence page ${pageId}`,
+        });
+        return requirePayloadObject(page, `confluence page ${pageId}`);
+    }
+    const page = await atlassianRequest(config, `/rest/api/content/${encodeURIComponent(pageId)}${queryString({ expand: 'body.storage,version,space,ancestors' })}`, {
+        label: `confluence page ${pageId}`,
+    });
+    return requirePayloadObject(page, `confluence page ${pageId}`);
+}
+
+export async function readPageBodyFile(args) {
+    const text = await readUtf8File(args.file);
+    if (args.representation === 'storage') return text;
+    return markdownToConfluenceStorage(text);
+}
+
+export function createPagePayload(config, args, storage) {
+    const title = requireString(args.title, 'Confluence page title');
+    const space = requireString(args.space, 'Confluence space');
+    if (config.deployment === 'cloud') {
+        return {
+            spaceId: space,
+            status: 'current',
+            title,
+            ...(args.parent ? { parentId: String(args.parent) } : {}),
+            body: { representation: 'storage', value: storage },
+        };
+    }
+    return {
+        type: 'page',
+        status: 'current',
+        title,
+        space: { key: space },
+        ...(args.parent ? { ancestors: [{ id: String(args.parent) }] } : {}),
+        body: { storage: { representation: 'storage', value: storage } },
+    };
+}
+
+export function updatePagePayload(config, current, args, storage) {
+    const page = requirePayloadObject(current, 'confluence current page');
+    const id = requirePayloadString(page.id, 'page id', 'confluence current page');
+    const title = args.title ? requireString(args.title, 'Confluence page title') : requirePayloadString(page.title, 'title', 'confluence current page');
+    const currentVersion = Number(page.version?.number);
+    if (!Number.isSafeInteger(currentVersion) || currentVersion < 1) {
+        throw new CommandExecutionError('confluence update could not determine the current page version.');
+    }
+    const nextVersion = currentVersion + 1;
+    if (config.deployment === 'cloud') {
+        return {
+            id,
+            status: 'current',
+            title,
+            body: { representation: 'storage', value: storage },
+            version: {
+                number: nextVersion,
+                ...(args['version-message'] ? { message: String(args['version-message']) } : {}),
+            },
+        };
+    }
+    return {
+        id,
+        type: 'page',
+        status: 'current',
+        title,
+        body: { storage: { representation: 'storage', value: storage } },
+        version: {
+            number: nextVersion,
+            ...(args['version-message'] ? { message: String(args['version-message']) } : {}),
+        },
+    };
+}
+
+export function normalizeSearchResult(result, config) {
+    const row = requirePayloadObject(result, 'confluence search result');
+    const content = row.content ?? row;
+    const contentObject = requirePayloadObject(content, 'confluence search result content');
+    const id = requirePayloadString(contentObject.id, 'content id', 'confluence search result');
+    const title = requirePayloadString(row.title ?? contentObject.title, 'title', 'confluence search result');
+    const space = row.space ?? contentObject.space ?? {};
+    return {
+        id,
+        title,
+        type: String(contentObject.type ?? row.entityType ?? ''),
+        spaceKey: String(space?.key ?? ''),
+        status: String(contentObject.status ?? ''),
+        lastModified: String(row.lastModified ?? contentObject.version?.when ?? contentObject.version?.createdAt ?? ''),
+        url: confluenceUrl(config, row.url ?? contentObject._links?.webui ?? ''),
+        excerpt: row.excerpt ? htmlToMarkdown(row.excerpt) : '',
+    };
+}
+
+export function confluenceResults(data, label) {
+    const payload = requirePayloadObject(data, label);
+    return requirePayloadArray(payload.results, label);
+}
+
+export function withSpaceCql(cql, space) {
+    const q = String(cql ?? '').trim();
+    const s = String(space ?? '').trim();
+    if (!s) return q;
+    const escaped = s.replace(/"/g, '\\"');
+    if (!q) return `space = "${escaped}"`;
+    return `space = "${escaped}" and (${q})`;
+}
+
+export const __test__ = {
+    createPagePayload,
+    getPage,
+    normalizeConfluencePage,
+    normalizeSearchResult,
+    readPageBodyFile,
+    updatePagePayload,
+    withSpaceCql,
+};

package/clis/confluence/update.js

@@ -0,0 +1,38 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { atlassianRequest, requireExecute, requirePayloadObject, requireString } from '../_atlassian/shared.js';
+import { confluenceConfig, getPage, normalizeConfluencePage, readPageBodyFile, updatePagePayload } from './shared.js';
+
+cli({
+    site: 'confluence',
+    name: 'update',
+    access: 'write',
+    description: 'Update a Confluence page body from Markdown or storage XHTML',
+    domain: 'atlassian.net',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Confluence page id' },
+        { name: 'file', type: 'string', required: true, help: 'Markdown file path' },
+        { name: 'title', type: 'string', help: 'Optional replacement title; defaults to current title' },
+        { name: 'version-message', type: 'string', help: 'Confluence version message' },
+        { name: 'representation', type: 'string', default: 'markdown', choices: ['markdown', 'storage'], help: 'Input file format' },
+        { name: 'execute', type: 'boolean', help: 'Actually update the remote page' },
+    ],
+    columns: ['status', 'id', 'title', 'spaceId', 'spaceKey', 'version', 'url'],
+    func: async (args) => {
+        requireExecute(args, 'confluence update');
+        const config = confluenceConfig();
+        const id = requireString(args.id, 'Confluence page id');
+        const current = await getPage(config, id);
+        const storage = await readPageBodyFile(args);
+        const payload = updatePagePayload(config, current, args, storage);
+        const path = config.deployment === 'cloud' ? `/api/v2/pages/${encodeURIComponent(id)}` : `/rest/api/content/${encodeURIComponent(id)}`;
+        const page = requirePayloadObject(await atlassianRequest(config, path, {
+            method: 'PUT',
+            body: payload,
+            label: `confluence update ${id}`,
+        }), `confluence update ${id}`);
+        const normalized = normalizeConfluencePage(page, config);
+        return [{ ...normalized, pageStatus: normalized.status, status: 'updated' }];
+    },
+});

package/clis/douyin/_shared/browser-fetch.js

@@ -1,4 +1,11 @@
-import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { unwrapEvaluateResult } from './evaluate-result.js';
+
+function isAuthLikeError(code, message) {
+    const text = String(message ?? '');
+    return code === 401 || code === 403 || /login|cookie|auth|captcha|verify|forbidden|permission|登录|登陆|权限|验证|验证码/i.test(text);
+}
+
 /**
  * Execute a fetch() call inside the Chrome browser context via page.evaluate.
  * This ensures a_bogus signing and cookies are handled automatically by the browser.
@@ -6,36 +13,53 @@ import { CommandExecutionError } from '@jackwener/opencli/errors';
 export async function browserFetch(page, method, url, options = {}) {
     const js = `
     (async () => {
-      const res = await fetch(${JSON.stringify(url)}, {
-        method: ${JSON.stringify(method)},
-        credentials: 'include',
-        headers: {
-          'Content-Type': 'application/json',
-          ...${JSON.stringify(options.headers ?? {})}
-        },
-        ${options.body ? `body: JSON.stringify(${JSON.stringify(options.body)}),` : ''}
-      });
-      const text = await res.text();
-      if (!text) return null;
-      return JSON.parse(text);
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), ${Number(options.timeoutMs ?? 30000)});
+      try {
+        const res = await fetch(${JSON.stringify(url)}, {
+          method: ${JSON.stringify(method)},
+          credentials: 'include',
+          signal: controller.signal,
+          headers: {
+            'Content-Type': 'application/json',
+            ...${JSON.stringify(options.headers ?? {})}
+          },
+          ${options.body ? `body: JSON.stringify(${JSON.stringify(options.body)}),` : ''}
+        });
+        const text = await res.text();
+        try {
+          return JSON.parse(text);
+        } catch (error) {
+          return { status_code: res.ok ? -2 : res.status, status_msg: \`JSON parse failed: \${text.slice(0, 500) || String(error && error.message || error)}\` };
+        }
+      } catch (error) {
+        return { status_code: -1, status_msg: String(error && error.message || error) };
+      } finally {
+        clearTimeout(timer);
+      }
     })()
   `;
     let result;
     try {
-        result = await page.evaluate(js);
+        result = unwrapEvaluateResult(await page.evaluate(js));
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new CommandExecutionError(`Douyin API request failed: ${message}`);
+        throw new CommandExecutionError(`Douyin API request failed (${method} ${url}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (result == null) {
+        throw new CommandExecutionError(`Empty response from Douyin API (${method} ${url})`);
     }
-    if (result === null || result === undefined) {
-        throw new CommandExecutionError('Empty response from Douyin API');
+    if (Array.isArray(result) || typeof result !== 'object') {
+        throw new CommandExecutionError(`Malformed response from Douyin API (${method} ${url})`);
     }
     if (result && typeof result === 'object' && 'status_code' in result) {
         const code = result.status_code;
         if (code !== 0) {
-            const msg = result.status_msg ?? 'unknown error';
-            throw new CommandExecutionError(`Douyin API error ${code}: ${msg}`);
+            const msg = result.status_msg ?? result.message ?? 'unknown error';
+            if (isAuthLikeError(code, msg)) {
+                throw new AuthRequiredError('creator.douyin.com', `Douyin API auth/permission error ${code} at ${method} ${url}: ${msg}`);
+            }
+            throw new CommandExecutionError(`Douyin API error ${code} at ${method} ${url}: ${msg}`);
         }
     }
     return result;

package/clis/douyin/_shared/browser-fetch.test.js

@@ -1,4 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { browserFetch } from './browser-fetch.js';
 function makePage(result) {
     return {
@@ -18,10 +19,20 @@ describe('browserFetch', () => {
         const result = await browserFetch(page, 'GET', 'https://creator.douyin.com/api/test');
         expect(result).toEqual({ status_code: 0, data: { ak: 'KEY' } });
     });
+    it('unwraps Browser Bridge {session,data} envelopes', async () => {
+        const page = makePage({ session: 'site:douyin:test', data: { status_code: 0, data: { ok: true } } });
+        await expect(browserFetch(page, 'GET', 'https://creator.douyin.com/api/test'))
+            .resolves.toEqual({ status_code: 0, data: { ok: true } });
+    });
     it('throws when status_code is non-zero', async () => {
         const page = makePage({ status_code: 8, message: 'fail' });
         await expect(browserFetch(page, 'GET', 'https://creator.douyin.com/api/test')).rejects.toThrow('Douyin API error 8');
     });
+    it('maps auth-like API errors to AuthRequiredError', async () => {
+        const page = makePage({ status_code: 401, status_msg: 'login required' });
+        await expect(browserFetch(page, 'GET', 'https://creator.douyin.com/api/test'))
+            .rejects.toBeInstanceOf(AuthRequiredError);
+    });
     it('returns result even when no status_code field', async () => {
         const page = makePage({ some_field: 'value' });
         const result = await browserFetch(page, 'GET', 'https://creator.douyin.com/api/test');
@@ -35,9 +46,19 @@ describe('browserFetch', () => {
         const page = makePage(undefined);
         await expect(browserFetch(page, 'GET', 'https://creator.douyin.com/api/test')).rejects.toThrow('Empty response from Douyin API');
     });
+    it('throws typed on malformed primitive response body', async () => {
+        const page = makePage('not-json-object');
+        await expect(browserFetch(page, 'GET', 'https://creator.douyin.com/api/test'))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+    it('throws typed when browser fetch returns a non-JSON body', async () => {
+        const page = makePage({ status_code: -2, status_msg: 'JSON parse failed: <html>not-json</html>' });
+        await expect(browserFetch(page, 'GET', 'https://creator.douyin.com/api/test'))
+            .rejects.toThrow('Douyin API error -2');
+    });
     it('wraps browser-side fetch or JSON parse failures', async () => {
         const page = makePage(null);
         page.evaluate.mockRejectedValueOnce(new SyntaxError('Unexpected token < in JSON'));
-        await expect(browserFetch(page, 'GET', 'https://creator.douyin.com/api/test')).rejects.toThrow('Douyin API request failed: Unexpected token < in JSON');
+        await expect(browserFetch(page, 'GET', 'https://creator.douyin.com/api/test')).rejects.toThrow('Douyin API request failed (GET https://creator.douyin.com/api/test): Unexpected token < in JSON');
     });
 });

package/clis/douyin/_shared/evaluate-result.js

@@ -0,0 +1,16 @@
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+
+export function unwrapEvaluateResult(payload) {
+  if (payload && !Array.isArray(payload) && typeof payload === 'object' && 'session' in payload && 'data' in payload) {
+    return payload.data;
+  }
+  return payload;
+}
+
+export function requireObjectEvaluateResult(payload, context) {
+  const result = unwrapEvaluateResult(payload);
+  if (!result || Array.isArray(result) || typeof result !== 'object') {
+    throw new CommandExecutionError(`${context}: malformed evaluate payload`);
+  }
+  return result;
+}

package/clis/douyin/_shared/tos-upload.js

@@ -56,6 +56,31 @@ function sha256Hex(data) {
     }
     return hash.digest('hex');
 }
+const CRC32_TABLE = new Uint32Array(256).map((_, index) => {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+        value = (value & 1) ? (0xEDB88320 ^ (value >>> 1)) : (value >>> 1);
+    }
+    return value >>> 0;
+});
+function crc32Hex(data) {
+    let crc = 0xffffffff;
+    for (const byte of data) {
+        crc = CRC32_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    }
+    return ((crc ^ 0xffffffff) >>> 0).toString(16).padStart(8, '0');
+}
+function gatewayBaseUrl(tosUrl) {
+    const parsedUrl = new URL(tosUrl);
+    return `https://${parsedUrl.host}/upload/v1${parsedUrl.pathname}`;
+}
+function gatewayHeaders(auth, uploadHeader, userId = '') {
+    return {
+        Authorization: auth,
+        'X-Storage-U': encodeURIComponent(userId),
+        ...(uploadHeader ?? {}),
+    };
+}
 function extractRegionFromHost(host) {
     // e.g. "tos-cn-i-alisg.volces.com" → "cn-i-alisg"
     // e.g. "tos-cn-beijing.ivolces.com" → "cn-beijing"
@@ -129,6 +154,7 @@ async function tosRequest(opts) {
         method,
         headers,
         body: fetchBody,
+        signal: AbortSignal.timeout(60000),
     });
     const responseBody = await res.text();
     const responseHeaders = {};
@@ -140,86 +166,95 @@ async function tosRequest(opts) {
 function nowDatetime() {
     return new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
 }
+function extractUploadId(body) {
+    const xmlMatch = body.match(/<UploadId>([^<]+)<\/UploadId>/i);
+    if (xmlMatch) return xmlMatch[1];
+    try {
+        const json = JSON.parse(body);
+        return json?.payload?.uploadID
+            || json?.payload?.uploadId
+            || json?.payload?.UploadID
+            || json?.payload?.UploadId
+            || json?.data?.uploadid
+            || json?.data?.uploadID
+            || json?.data?.uploadId
+            || json?.data?.UploadID
+            || json?.data?.UploadId
+            || json?.UploadID
+            || json?.UploadId
+            || json?.uploadID
+            || json?.uploadId
+            || null;
+    }
+    catch {
+        return null;
+    }
+}
 // ── Phase 1: Init multipart upload ───────────────────────────────────────────
-async function initMultipartUpload(tosUrl, auth, credentials) {
-    const initUrl = `${tosUrl}?uploads`;
-    const datetime = nowDatetime();
-    // Use the pre-computed auth for INIT, as it comes from ApplyVideoUpload
-    const headers = {
-        Authorization: auth,
-        'x-amz-date': datetime,
-        'x-amz-security-token': credentials.session_token,
-        'content-type': 'application/octet-stream',
-    };
-    const res = await tosRequest({ method: 'POST', url: initUrl, headers });
+async function initMultipartUpload(tosUrl, auth, uploadHeader, userId) {
+    const initUrl = `${gatewayBaseUrl(tosUrl)}?uploadmode=part&phase=init`;
+    const res = await tosRequest({
+        method: 'POST',
+        url: initUrl,
+        headers: gatewayHeaders(auth, uploadHeader, userId),
+    });
     if (res.status !== 200) {
-        throw new CommandExecutionError(`TOS init multipart upload failed with status ${res.status}: ${res.body}`, 'Check that TOS credentials are valid and not expired.');
+        throw new CommandExecutionError(`TOS init multipart upload failed with status ${res.status}: ${res.body}`, 'Check that TOS upload authorization is valid and not expired.');
     }
-    // Parse UploadId from XML: <UploadId>...</UploadId>
-    const match = res.body.match(/<UploadId>([^<]+)<\/UploadId>/);
-    if (!match) {
+    const uploadId = extractUploadId(res.body);
+    if (!uploadId) {
         throw new CommandExecutionError(`TOS init response missing UploadId: ${res.body}`);
     }
-    return match[1];
+    return uploadId;
 }
 // ── Phase 2: Upload a single part ────────────────────────────────────────────
-async function uploadPart(tosUrl, partNumber, uploadId, data, credentials, region) {
-    const parsedUrl = new URL(tosUrl);
-    parsedUrl.searchParams.set('partNumber', String(partNumber));
-    parsedUrl.searchParams.set('uploadId', uploadId);
-    const url = parsedUrl.toString();
-    const datetime = nowDatetime();
-    const headers = computeAws4Headers({
-        method: 'PUT',
-        url,
-        headers: { 'content-type': 'application/octet-stream' },
-        body: data,
-        credentials,
-        service: 'tos',
-        region,
-        datetime,
-    });
-    const res = await tosRequest({ method: 'PUT', url, headers, body: data });
-    if (res.status !== 200) {
-        throw new CommandExecutionError(`TOS upload part ${partNumber} failed with status ${res.status}: ${res.body}`, 'Check that STS2 credentials are valid and not expired.');
+async function uploadPart(tosUrl, partNumber, uploadId, data, auth, uploadHeader, userId) {
+    const crc32 = crc32Hex(data);
+    const url = `${gatewayBaseUrl(tosUrl)}?uploadid=${encodeURIComponent(uploadId)}&part_number=${partNumber}&phase=transfer`;
+    const headers = {
+        ...gatewayHeaders(auth, uploadHeader, userId),
+        'Content-CRC32': crc32,
+        'Content-Type': 'application/octet-stream',
+        'X-Use-Init-Upload-Optimize': '1',
+        'X-Use-Large-Local-Cache': '1',
+    };
+    const res = await tosRequest({ method: 'POST', url, headers, body: data });
+    let parsed;
+    try {
+        parsed = JSON.parse(res.body);
     }
-    const etag = res.headers['etag'];
-    if (!etag) {
-        throw new CommandExecutionError(`TOS upload part ${partNumber} response missing ETag header`);
+    catch {
+        parsed = null;
     }
-    return etag;
+    if (res.status !== 200 || parsed?.code !== 2000) {
+        throw new CommandExecutionError(`TOS upload part ${partNumber} failed with status ${res.status}: ${res.body}`, 'Check that TOS upload authorization is valid and not expired.');
+    }
+    return parsed?.data?.crc32 || crc32;
 }
 // ── Phase 3: Complete multipart upload ───────────────────────────────────────
-async function completeMultipartUpload(tosUrl, uploadId, parts, credentials, region) {
-    const parsedUrl = new URL(tosUrl);
-    parsedUrl.searchParams.set('uploadId', uploadId);
-    const url = parsedUrl.toString();
-    const xmlBody = '<CompleteMultipartUpload>' +
-        parts
-            .sort((a, b) => a.partNumber - b.partNumber)
-            .map(p => `<Part><PartNumber>${p.partNumber}</PartNumber><ETag>${p.etag}</ETag></Part>`)
-            .join('') +
-        '</CompleteMultipartUpload>';
-    const datetime = nowDatetime();
-    const headers = computeAws4Headers({
-        method: 'POST',
-        url,
-        headers: { 'content-type': 'application/xml' },
-        body: xmlBody,
-        credentials,
-        service: 'tos',
-        region,
-        datetime,
-    });
+async function completeMultipartUpload(tosUrl, uploadId, parts, auth, uploadHeader, userId) {
+    const url = `${gatewayBaseUrl(tosUrl)}?uploadmode=part&phase=finish&uploadid=${encodeURIComponent(uploadId)}`;
+    const body = parts
+        .sort((a, b) => a.partNumber - b.partNumber)
+        .map(p => `${p.partNumber}:${p.crc32}`)
+        .join(',');
     const res = await tosRequest({
         method: 'POST',
         url,
-        headers,
-        body: xmlBody,
+        headers: gatewayHeaders(auth, uploadHeader, userId),
+        body,
     });
-    if (res.status !== 200) {
+    let parsed;
+    try {
+        parsed = JSON.parse(res.body);
+    }
+    catch {
+        parsed = null;
+    }
+    if (res.status !== 200 || parsed?.code !== 2000) {
         throw new CommandExecutionError(`TOS complete multipart upload failed with status ${res.status}: ${res.body}`, 'Check that all parts were uploaded successfully.');
     }
+    return parsed?.data?.key || null;
 }
 let _readSyncOverride = null;
 /** @internal — for testing only */
@@ -237,7 +272,7 @@ export async function tosUpload(options) {
     if (fileSize === 0) {
         throw new CommandExecutionError(`Video file is empty: ${filePath}`);
     }
-    const { tos_upload_url: tosUrl, auth } = uploadInfo;
+    const { tos_upload_url: tosUrl, auth, upload_header: uploadHeader, user_id: userId } = uploadInfo;
     const parsedTosUrl = new URL(tosUrl);
     const region = extractRegionFromHost(parsedTosUrl.host);
     const resumePath = getResumeFilePath(filePath);
@@ -251,7 +286,7 @@ export async function tosUpload(options) {
     }
     else {
         // Start fresh
-        uploadId = await initMultipartUpload(tosUrl, auth, credentials);
+        uploadId = await initMultipartUpload(tosUrl, auth, uploadHeader, userId);
         completedParts = [];
         saveResumeState(resumePath, { uploadId, fileSize, parts: completedParts });
     }
@@ -277,8 +312,8 @@ export async function tosUpload(options) {
             if (bytesRead !== chunkSize) {
                 throw new CommandExecutionError(`Short read on part ${partNumber}: expected ${chunkSize} bytes, got ${bytesRead}`);
             }
-            const etag = await uploadPart(tosUrl, partNumber, uploadId, buffer, credentials, region);
-            completedParts.push({ partNumber, etag });
+            const crc32 = await uploadPart(tosUrl, partNumber, uploadId, buffer, auth, uploadHeader, userId);
+            completedParts.push({ partNumber, crc32 });
             saveResumeState(resumePath, { uploadId, fileSize, parts: completedParts });
             uploadedBytes = Math.min(offset + chunkSize, fileSize);
             if (onProgress)
@@ -288,8 +323,9 @@ export async function tosUpload(options) {
     finally {
         fs.closeSync(fd);
     }
-    await completeMultipartUpload(tosUrl, uploadId, completedParts, credentials, region);
+    const completedKey = await completeMultipartUpload(tosUrl, uploadId, completedParts, auth, uploadHeader, userId);
     deleteResumeState(resumePath);
+    return completedKey;
 }
 // ── Internal exports for testing ─────────────────────────────────────────────
-export { PART_SIZE, RESUME_DIR, extractRegionFromHost, getResumeFilePath, loadResumeState, saveResumeState, deleteResumeState, computeAws4Headers, };
+export { PART_SIZE, RESUME_DIR, extractRegionFromHost, getResumeFilePath, loadResumeState, saveResumeState, deleteResumeState, computeAws4Headers, extractUploadId, crc32Hex, gatewayBaseUrl, gatewayHeaders, };