@sovovs/bycli 2.1.44 → 2.1.46

package/cli-manifest.json

@@ -29408,6 +29408,103 @@
     "modulePath": "weixin/search.js",
     "sourceFile": "weixin/search.js"
   },
+  {
+    "site": "weixin",
+    "name": "user-attributes",
+    "description": "读取公众号用户属性，包括性别、年龄、语言、地区、平台和设备品牌",
+    "access": "read",
+    "domain": "mp.weixin.qq.com",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "date",
+        "type": "str",
+        "required": false,
+        "help": "快照日期（YYYY-MM-DD）；默认昨天"
+      },
+      {
+        "name": "dimension",
+        "type": "str",
+        "default": "all",
+        "required": false,
+        "help": "属性维度；默认返回全部维度",
+        "choices": [
+          "all",
+          "gender",
+          "age",
+          "language",
+          "region",
+          "platform",
+          "brand"
+        ]
+      }
+    ],
+    "columns": [
+      "date",
+      "dimension",
+      "name",
+      "code",
+      "parent_code",
+      "count",
+      "percent"
+    ],
+    "type": "js",
+    "modulePath": "weixin/user-attributes.js",
+    "sourceFile": "weixin/user-attributes.js",
+    "navigateBefore": false
+  },
+  {
+    "site": "weixin",
+    "name": "user-growth",
+    "description": "读取公众号用户增长趋势，可选返回全部渠道并下载官方“全部来源”XLS",
+    "access": "write",
+    "domain": "mp.weixin.qq.com",
+    "strategy": "cookie",
+    "browser": true,
+    "args": [
+      {
+        "name": "begin",
+        "type": "str",
+        "required": false,
+        "help": "开始日期（YYYY-MM-DD）；默认 30 天窗口的第一天"
+      },
+      {
+        "name": "end",
+        "type": "str",
+        "required": false,
+        "help": "结束日期（YYYY-MM-DD）；默认昨天"
+      },
+      {
+        "name": "source",
+        "type": "str",
+        "default": "all",
+        "required": false,
+        "help": "传播渠道名称或代码；多个值用逗号分隔"
+      },
+      {
+        "name": "output",
+        "type": "str",
+        "required": false,
+        "help": "可选的官方“全部来源”XLS 保存目录；不传则不下载"
+      }
+    ],
+    "columns": [
+      "date",
+      "source",
+      "source_code",
+      "new_followers",
+      "unfollows",
+      "net_new_followers",
+      "cumulative_followers",
+      "official_xls_path",
+      "official_xls_size"
+    ],
+    "type": "js",
+    "modulePath": "weixin/user-growth.js",
+    "sourceFile": "weixin/user-growth.js",
+    "navigateBefore": false
+  },
   {
     "site": "weread",
     "name": "ai-outline",

package/clis/weixin/_wechat/user-analysis.js

@@ -0,0 +1,299 @@
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
+
+const DOMAIN = 'mp.weixin.qq.com';
+const ENDPOINT = `https://${DOMAIN}/misc/useranalysis`;
+
+const SOURCE_ENTRIES = [
+  ['all', 99999999],
+  ['search', 1],
+  ['qr', 30],
+  ['article', 57],
+  ['card', 17],
+  ['mini-program', 149],
+  ['reprint', 161],
+  ['ad', 100],
+  ['channels-live', 201],
+  ['channels', 200],
+  ['other', 0],
+];
+
+const SOURCE_CODES = new Map(SOURCE_ENTRIES);
+const SOURCE_NAMES = new Map(SOURCE_ENTRIES.map(([name, code]) => [code, name]));
+const DIMENSIONS = ['gender', 'age', 'language', 'region', 'platform', 'brand'];
+
+function argument(condition, message) {
+  if (!condition) throw new ArgumentError(message);
+}
+
+function execution(condition, message) {
+  if (!condition) throw new CommandExecutionError(message);
+}
+
+function object(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function formatLocalDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+function calendarDate(value, name) {
+  argument(typeof value === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(value), `${name} must use YYYY-MM-DD`);
+  const [year, month, day] = value.split('-').map(Number);
+  const parsed = new Date(Date.UTC(year, month - 1, day));
+  argument(
+    parsed.getUTCFullYear() === year
+      && parsed.getUTCMonth() === month - 1
+      && parsed.getUTCDate() === day,
+    `${name} must be a valid calendar date`,
+  );
+  return value;
+}
+
+function yesterday(now) {
+  const date = new Date(now());
+  argument(Number.isFinite(date.getTime()), 'current time must be valid');
+  date.setHours(12, 0, 0, 0);
+  date.setDate(date.getDate() - 1);
+  return date;
+}
+
+export function resolveGrowthRange(args = {}, options = {}) {
+  const now = options.now ?? Date.now;
+  const defaultEnd = yesterday(now);
+  const end = calendarDate(args.end ?? formatLocalDate(defaultEnd), 'end');
+  const [endYear, endMonth, endDay] = end.split('-').map(Number);
+  const defaultBegin = new Date(endYear, endMonth - 1, endDay, 12);
+  defaultBegin.setDate(defaultBegin.getDate() - 29);
+  const begin = calendarDate(args.begin ?? formatLocalDate(defaultBegin), 'begin');
+  argument(begin <= end, 'begin must not be after end');
+  return { begin, end };
+}
+
+export function resolveAttributeDate(value, options = {}) {
+  const now = options.now ?? Date.now;
+  return calendarDate(value ?? formatLocalDate(yesterday(now)), 'date');
+}
+
+export function parseGrowthSources(value = 'all') {
+  if (String(value).trim() === 'all-sources') {
+    return SOURCE_ENTRIES.map(([name, code]) => ({ name, code }));
+  }
+  const rawItems = String(value).split(',').map(item => item.trim()).filter(Boolean);
+  argument(rawItems.length > 0, 'source must not be empty');
+  const seen = new Set();
+  return rawItems.map(raw => {
+    let code;
+    if (SOURCE_CODES.has(raw)) {
+      code = SOURCE_CODES.get(raw);
+    } else if (/^\d+$/.test(raw)) {
+      code = Number(raw);
+      argument(Number.isSafeInteger(code), `source code is too large: ${raw}`);
+    } else {
+      throw new ArgumentError(`unknown source: ${raw}`);
+    }
+    argument(!seen.has(code), `duplicate source: ${raw}`);
+    seen.add(code);
+    return { code, name: SOURCE_NAMES.get(code) ?? `source:${code}` };
+  });
+}
+
+export function parseAttributeDimension(value = 'all') {
+  const dimension = String(value).trim();
+  argument(dimension === 'all' || DIMENSIONS.includes(dimension),
+    `dimension must be one of: all, ${DIMENSIONS.join(', ')}`);
+  return dimension;
+}
+
+function tokenValue(token) {
+  argument(typeof token === 'string' && token.trim().length > 0, 'token is required');
+  return token;
+}
+
+export function buildGrowthUrl({ token, begin, end, sourceCodes }) {
+  argument(Array.isArray(sourceCodes) && sourceCodes.length > 0, 'sourceCodes must not be empty');
+  sourceCodes.forEach(code => argument(Number.isSafeInteger(code) && code >= 0, 'sourceCodes must contain non-negative safe integers'));
+  const params = new URLSearchParams({
+    begin_date: calendarDate(begin, 'begin'),
+    end_date: calendarDate(end, 'end'),
+    source: sourceCodes.join(','),
+    token: tokenValue(token),
+    lang: 'zh_CN',
+    f: 'json',
+    ajax: '1',
+  });
+  return `${ENDPOINT}?${params}`;
+}
+
+export function buildAttributesUrl({ token, date }) {
+  const validDate = calendarDate(date, 'date');
+  const params = new URLSearchParams({
+    action: 'attr',
+    begin_date: validDate,
+    end_date: validDate,
+    token: tokenValue(token),
+    lang: 'zh_CN',
+  });
+  return `${ENDPOINT}?${params}`;
+}
+
+function integer(value, message, { nonnegative = false } = {}) {
+  execution(Number.isSafeInteger(value) && (!nonnegative || value >= 0), message);
+  return value;
+}
+
+function response(payload, label) {
+  execution(object(payload), `WeChat ${label} returned an unreadable response`);
+  execution(payload.base_resp?.ret === 0,
+    `WeChat ${label} failed (ret=${String(payload.base_resp?.ret ?? 'unknown')})`);
+  return payload;
+}
+
+export function normalizeGrowthPayload(payload, requestedSources) {
+  const data = response(payload, 'user growth');
+  execution(Array.isArray(data.category_list), 'WeChat user growth returned an invalid category list');
+  const requestedOrder = new Map(requestedSources.map((source, index) => [source.code, index]));
+  const requestedNames = new Map(requestedSources.map(source => [source.code, source.name]));
+  const rows = [];
+  for (const [categoryIndex, category] of data.category_list.entries()) {
+    execution(object(category), `WeChat user growth returned an invalid category at index ${categoryIndex}`);
+    const sourceCode = integer(category.user_source, `WeChat user growth returned an invalid source at index ${categoryIndex}`, { nonnegative: true });
+    execution(Array.isArray(category.list), `WeChat user growth returned an invalid list for source ${sourceCode}`);
+    for (const [rowIndex, item] of category.list.entries()) {
+      const prefix = `WeChat user growth returned an invalid row at source ${sourceCode} index ${rowIndex}`;
+      execution(object(item), prefix);
+      const date = typeof item.date === 'string' ? item.date : '';
+      try {
+        calendarDate(date, 'date');
+      } catch {
+        throw new CommandExecutionError(prefix);
+      }
+      rows.push({
+        date,
+        source: requestedNames.get(sourceCode) ?? SOURCE_NAMES.get(sourceCode) ?? `source:${sourceCode}`,
+        sourceCode,
+        newFollowers: integer(item.new_user, prefix, { nonnegative: true }),
+        unfollows: integer(item.cancel_user, prefix, { nonnegative: true }),
+        netNewFollowers: integer(item.netgain_user, prefix),
+        cumulativeFollowers: integer(item.cumulate_user, prefix, { nonnegative: true }),
+      });
+    }
+  }
+  return rows.sort((left, right) => left.date.localeCompare(right.date)
+    || (requestedOrder.get(left.sourceCode) ?? Number.MAX_SAFE_INTEGER)
+      - (requestedOrder.get(right.sourceCode) ?? Number.MAX_SAFE_INTEGER));
+}
+
+function percentage(count, total) {
+  if (total === 0) return 0;
+  return Number(((count * 100) / total).toFixed(2));
+}
+
+function displayName(value) {
+  if (value === '' || value === '0' || value === null || value === undefined) return '未知';
+  execution(typeof value === 'string', 'WeChat user attributes returned an invalid name');
+  return value;
+}
+
+function flatDimension(snapshot, dimension, field) {
+  const items = snapshot[field] ?? [];
+  execution(Array.isArray(items), `WeChat user attributes returned an invalid ${dimension} list`);
+  const total = items.reduce((sum, item) => {
+    execution(object(item), `WeChat user attributes returned an invalid ${dimension} row`);
+    return sum + integer(item.count, `WeChat user attributes returned an invalid ${dimension} count`, { nonnegative: true });
+  }, 0);
+  return items.map(item => ({
+    date: snapshot.date,
+    dimension,
+    name: displayName(item.name),
+    code: null,
+    parentCode: null,
+    count: item.count,
+    percent: percentage(item.count, total),
+  }));
+}
+
+function flatRegions(snapshot) {
+  const items = snapshot.regions ?? [];
+  execution(Array.isArray(items), 'WeChat user attributes returned an invalid region list');
+  return items.map(item => {
+    execution(object(item) && object(item.region), 'WeChat user attributes returned an invalid region row');
+    const code = item.region.region_id;
+    const parentCode = item.region.parent_region_id;
+    execution(typeof code === 'string' && typeof parentCode === 'string', 'WeChat user attributes returned invalid region identifiers');
+    return {
+      date: snapshot.date,
+      dimension: 'region',
+      name: displayName(item.region.region_name),
+      code,
+      parentCode,
+      count: integer(item.count, 'WeChat user attributes returned an invalid region count', { nonnegative: true }),
+      percent: null,
+    };
+  });
+}
+
+export function normalizeAttributeSnapshot(snapshot, dimension = 'all') {
+  execution(object(snapshot), 'WeChat user attributes returned an unreadable snapshot');
+  try {
+    calendarDate(snapshot.date, 'date');
+  } catch {
+    throw new CommandExecutionError('WeChat user attributes returned an invalid snapshot date');
+  }
+  const selected = parseAttributeDimension(dimension);
+  const builders = {
+    gender: () => flatDimension(snapshot, 'gender', 'genders'),
+    age: () => flatDimension(snapshot, 'age', 'ages'),
+    language: () => flatDimension(snapshot, 'language', 'langs'),
+    region: () => flatRegions(snapshot),
+    platform: () => flatDimension(snapshot, 'platform', 'platforms'),
+    brand: () => flatDimension(snapshot, 'brand', 'devices'),
+  };
+  const dimensions = selected === 'all' ? DIMENSIONS : [selected];
+  return dimensions.flatMap(key => builders[key]());
+}
+
+export async function collectGrowth({ page, token, begin, end, sources }) {
+  const requestUrl = buildGrowthUrl({ token, begin, end, sourceCodes: sources.map(source => source.code) });
+  const landing = new URL(ENDPOINT);
+  landing.searchParams.set('token', tokenValue(token));
+  landing.searchParams.set('lang', 'zh_CN');
+  let payload;
+  try {
+    await page.goto(landing.toString());
+    await page.wait(1);
+    payload = await page.evaluate(async url => {
+      const result = await fetch(url, { credentials: 'include' });
+      if (!result.ok) throw new Error(`HTTP ${result.status}`);
+      return result.json();
+    }, requestUrl);
+  } catch {
+    throw new CommandExecutionError('Unable to read WeChat user growth from the authenticated browser session');
+  }
+  return normalizeGrowthPayload(payload, sources);
+}
+
+export async function collectAttributes({ page, token, date, dimension }) {
+  let snapshot;
+  try {
+    await page.goto(buildAttributesUrl({ token, date }));
+    await page.wait(1);
+    snapshot = await page.evaluate(() => window.cgiData?.list?.[0] ?? null);
+  } catch {
+    throw new CommandExecutionError('Unable to read WeChat user attributes from the authenticated browser session');
+  }
+  if (snapshot === null) {
+    throw new EmptyResultError(
+      'weixin user-attributes',
+      'No attribute snapshot is available. WeChat publishes it the day after the account reaches 100 followers.',
+    );
+  }
+  const rows = normalizeAttributeSnapshot(snapshot, dimension);
+  if (rows.length === 0) {
+    throw new EmptyResultError('weixin user-attributes', `No ${dimension} attribute rows are available for ${date}.`);
+  }
+  return rows;
+}

package/clis/weixin/_wechat/user-growth-download.js

@@ -0,0 +1,152 @@
+import { constants } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { copyFile, link, mkdir, stat, unlink } from 'node:fs/promises';
+import { extname, resolve } from 'node:path';
+import { ArgumentError, CommandExecutionError, TimeoutError } from '@sovovs/bycli/errors';
+import { buildGrowthUrl } from './user-analysis.js';
+
+const DOWNLOAD_TIMEOUT_MS = 60_000;
+
+function commandError(message) {
+  return new CommandExecutionError(`WeChat user-growth XLS download ${message}`);
+}
+
+export function buildUserGrowthDownloadUrl({ token, begin, end }) {
+  const url = new URL(buildGrowthUrl({
+    token,
+    begin,
+    end,
+    sourceCodes: [99999999],
+  }));
+  url.searchParams.delete('f');
+  url.searchParams.delete('ajax');
+  url.searchParams.set('download', '1');
+  return url.toString();
+}
+
+export function isTrustedUserGrowthDownloadUrl(candidateValue, expectedValue) {
+  let candidate;
+  let expected;
+  try {
+    candidate = new URL(candidateValue);
+    expected = new URL(expectedValue);
+  } catch {
+    return false;
+  }
+  const exactParams = ['download', 'begin_date', 'end_date', 'source', 'token'];
+  return candidate.protocol === 'https:'
+    && candidate.hostname === 'mp.weixin.qq.com'
+    && candidate.port === ''
+    && candidate.pathname === '/misc/useranalysis'
+    && exactParams.every(name => candidate.searchParams.get(name) === expected.searchParams.get(name))
+    && candidate.searchParams.get('download') === '1'
+    && candidate.searchParams.get('source') === '99999999';
+}
+
+async function publishExclusively(source, outputDir, filename, beforePublish) {
+  const extension = extname(filename);
+  const stem = filename.slice(0, -extension.length);
+  const staged = resolve(outputDir, `.bycli-user-growth-${randomUUID()}.tmp`);
+  let stagedCreated = false;
+  try {
+    try {
+      await copyFile(source, staged, constants.COPYFILE_EXCL);
+      stagedCreated = true;
+    } catch {
+      try {
+        await unlink(staged);
+      } catch {
+        // COPYFILE_EXCL may fail before creating its destination.
+      }
+      throw commandError('could not stage the downloaded file');
+    }
+    for (let index = 0; index <= 9999; index += 1) {
+      const candidate = resolve(outputDir, index === 0 ? filename : `${stem}-${index}${extension}`);
+      try {
+        await beforePublish?.();
+        await link(staged, candidate);
+        return candidate;
+      } catch (error) {
+        if (error?.code === 'EEXIST') continue;
+        throw commandError('could not publish the downloaded file');
+      }
+    }
+    throw commandError('could not allocate a destination filename');
+  } finally {
+    if (stagedCreated) {
+      try {
+        await unlink(staged);
+      } catch {
+        // The final hard link remains a complete file.
+      }
+    }
+  }
+}
+
+export async function downloadUserGrowthXls(page, options) {
+  if (typeof options?.outputDir !== 'string' || !options.outputDir.trim()) {
+    throw new ArgumentError('output must be a non-empty directory');
+  }
+  if (typeof page?.waitForDownload !== 'function') {
+    throw commandError('requires browser download support');
+  }
+
+  const expectedUrl = buildUserGrowthDownloadUrl(options);
+  const startedAfterMs = Date.now();
+  let downloaded;
+  try {
+    await page.goto(expectedUrl, { waitUntil: 'none' });
+    downloaded = await page.waitForDownload('download=1', DOWNLOAD_TIMEOUT_MS, {
+      includeRecent: true,
+      startedAfterMs,
+    });
+  } catch (error) {
+    if (error instanceof TimeoutError) throw error;
+    throw commandError('could not complete the browser download');
+  }
+
+  if (!downloaded || downloaded.downloaded !== true) {
+    throw new TimeoutError('Weixin user-growth XLS download', DOWNLOAD_TIMEOUT_MS / 1000);
+  }
+  if (typeof downloaded.filename !== 'string'
+    || !downloaded.filename
+    || extname(downloaded.filename).toLowerCase() !== '.xls'
+    || downloaded.state !== 'complete'
+    || !['safe', 'accepted'].includes(downloaded.danger)) {
+    throw commandError('returned incomplete or unsafe download metadata');
+  }
+  if (![downloaded.url, downloaded.finalUrl]
+    .some(value => isTrustedUserGrowthDownloadUrl(value, expectedUrl))) {
+    throw commandError('rejected an unrelated downloaded file');
+  }
+
+  let sourceInfo;
+  try {
+    sourceInfo = await stat(downloaded.filename);
+  } catch {
+    throw commandError('could not read the downloaded file');
+  }
+  if (!sourceInfo.isFile() || sourceInfo.size <= 0) {
+    throw commandError('returned an empty downloaded file');
+  }
+
+  const outputDir = resolve(options.outputDir);
+  try {
+    await mkdir(outputDir, { recursive: true });
+  } catch {
+    throw commandError('could not create the output directory');
+  }
+  const filename = `weixin-user-growth-${options.begin}-${options.end}-all.xls`;
+  const target = await publishExclusively(
+    downloaded.filename,
+    outputDir,
+    filename,
+    options.beforePublish,
+  );
+  try {
+    await unlink(downloaded.filename);
+  } catch {
+    // Destination publication succeeded; browser temporary cleanup is best effort.
+  }
+  return { status: 'downloaded', path: target, size: sourceInfo.size };
+}

package/clis/weixin/user-attributes.js

@@ -0,0 +1,49 @@
+import { EmptyResultError } from '@sovovs/bycli/errors';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { resolveBrowserCredentials } from './_wechat/auth-session.js';
+import {
+  collectAttributes,
+  parseAttributeDimension,
+  resolveAttributeDate,
+} from './_wechat/user-analysis.js';
+
+const COLUMNS = ['date', 'dimension', 'name', 'code', 'parent_code', 'count', 'percent'];
+
+export const userAttributesCommand = cli({
+  site: 'weixin',
+  name: 'user-attributes',
+  access: 'read',
+  domain: 'mp.weixin.qq.com',
+  description: '读取公众号用户属性，包括性别、年龄、语言、地区、平台和设备品牌',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'date', help: '快照日期（YYYY-MM-DD）；默认昨天' },
+    {
+      name: 'dimension',
+      default: 'all',
+      choices: ['all', 'gender', 'age', 'language', 'region', 'platform', 'brand'],
+      help: '属性维度；默认返回全部维度',
+    },
+  ],
+  columns: COLUMNS,
+  func: async (page, args) => {
+    const { token } = await resolveBrowserCredentials(page);
+    const date = resolveAttributeDate(args.date);
+    const dimension = parseAttributeDimension(args.dimension);
+    const rows = await collectAttributes({ page, token, date, dimension });
+    if (rows.length === 0) {
+      throw new EmptyResultError('weixin user-attributes', `No ${dimension} attribute rows are available for ${date}.`);
+    }
+    return rows.map(row => ({
+      date: row.date,
+      dimension: row.dimension,
+      name: row.name,
+      code: row.code,
+      parent_code: row.parentCode,
+      count: row.count,
+      percent: row.percent,
+    }));
+  },
+});

package/clis/weixin/user-growth.js

@@ -0,0 +1,66 @@
+import { ArgumentError, EmptyResultError } from '@sovovs/bycli/errors';
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { resolveBrowserCredentials } from './_wechat/auth-session.js';
+import {
+  collectGrowth,
+  parseGrowthSources,
+  resolveGrowthRange,
+} from './_wechat/user-analysis.js';
+import { downloadUserGrowthXls } from './_wechat/user-growth-download.js';
+
+const COLUMNS = [
+  'date',
+  'source',
+  'source_code',
+  'new_followers',
+  'unfollows',
+  'net_new_followers',
+  'cumulative_followers',
+  'official_xls_path',
+  'official_xls_size',
+];
+
+export const userGrowthCommand = cli({
+  site: 'weixin',
+  name: 'user-growth',
+  access: 'write',
+  domain: 'mp.weixin.qq.com',
+  description: '读取公众号用户增长趋势，可选返回全部渠道并下载官方“全部来源”XLS',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'begin', help: '开始日期（YYYY-MM-DD）；默认 30 天窗口的第一天' },
+    { name: 'end', help: '结束日期（YYYY-MM-DD）；默认昨天' },
+    { name: 'source', default: 'all', help: '传播渠道名称或代码；多个值用逗号分隔' },
+    { name: 'output', help: '可选的官方“全部来源”XLS 保存目录；不传则不下载' },
+  ],
+  columns: COLUMNS,
+  func: async (page, args) => {
+    const outputDir = typeof args.output === 'string' ? args.output.trim() : null;
+    if (args.output !== undefined && (!outputDir || typeof args.output !== 'string')) {
+      throw new ArgumentError('output must be a non-empty directory');
+    }
+    const { token } = await resolveBrowserCredentials(page);
+    const { begin, end } = resolveGrowthRange(args);
+    const sources = parseGrowthSources(args.source);
+    const rows = await collectGrowth({ page, token, begin, end, sources });
+    if (rows.length === 0) {
+      throw new EmptyResultError('weixin user-growth', `No user growth rows are available from ${begin} through ${end}.`);
+    }
+    const artifact = outputDir
+      ? await downloadUserGrowthXls(page, { token, begin, end, outputDir })
+      : null;
+    return rows.map(row => ({
+      date: row.date,
+      source: row.source,
+      source_code: row.sourceCode,
+      new_followers: row.newFollowers,
+      unfollows: row.unfollows,
+      net_new_followers: row.netNewFollowers,
+      cumulative_followers: row.cumulativeFollowers,
+      official_xls_path: artifact?.path ?? null,
+      official_xls_size: artifact?.size ?? null,
+    }));
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sovovs/bycli",
-  "version": "2.1.44",
+  "version": "2.1.46",
   "publishConfig": {
     "access": "public"
   },