@northmoon-labs/social-cli 0.1.0

package/dist/cli/output.js

@@ -0,0 +1,386 @@
+import Table from 'cli-table3';
+import pc from 'picocolors';
+export class CliError extends Error {
+    code;
+    status;
+    payload;
+    meta;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = 'CliError';
+        this.code = code;
+        this.status = options.status ?? null;
+        this.payload = options.payload ?? null;
+        this.meta = options.meta ?? null;
+    }
+}
+export function maskSecret(value) {
+    if (!value)
+        return null;
+    if (value.length <= 8)
+        return '***';
+    return `${value.slice(0, 4)}***${value.slice(-4)}`;
+}
+export function printSuccess(data, provider, json) {
+    if (json) {
+        console.log(JSON.stringify({
+            ok: true,
+            data,
+            error: null,
+            meta: provider ? {
+                providerCode: provider.c,
+                providerMessage: provider.m,
+                providerTimestamp: provider.t,
+                requestId: provider.lb
+            } : null
+        }, null, 2));
+        return;
+    }
+    if (typeof data === 'string') {
+        console.log(data);
+        return;
+    }
+    console.log(formatHuman(data));
+}
+export function printError(error, json) {
+    const cliError = normalizeError(error);
+    if (json) {
+        console.log(JSON.stringify({
+            ok: false,
+            data: null,
+            error: {
+                code: cliError.code,
+                message: cliError.message,
+                status: cliError.status,
+                payload: cliError.payload
+            },
+            meta: cliError.meta
+        }, null, 2));
+        return;
+    }
+    console.error(`${stderrColor('nmsocial:', pc.red)} ${cliError.message}`);
+}
+export function normalizeError(error) {
+    if (error instanceof CliError)
+        return error;
+    if (error instanceof Error && error.name === 'AbortError') {
+        return new CliError('NETWORK_TIMEOUT', 'request timed out');
+    }
+    return new CliError('NETWORK_ERROR', error instanceof Error ? error.message : 'unexpected error', { payload: error });
+}
+function formatHuman(data) {
+    if (data === null || data === undefined)
+        return stdoutColor('OK', pc.green);
+    if (typeof data === 'number' || typeof data === 'boolean' || typeof data === 'bigint')
+        return String(data);
+    if (Array.isArray(data))
+        return formatTable(data);
+    if (!isRecord(data))
+        return String(data);
+    if (data.dryRun === true && isRecord(data.body)) {
+        return JSON.stringify(data.body, null, 2);
+    }
+    if (Array.isArray(data.records))
+        return formatTable(data.records);
+    if (Array.isArray(data.items))
+        return formatTable(data.items);
+    if (isConfigLike(data))
+        return formatKeyValues(configLabels(data));
+    if (isOverviewLike(data))
+        return formatKeyValues(metricLabels(data));
+    const keys = Object.keys(data);
+    if (keys.length === 0)
+        return stdoutColor('OK', pc.green);
+    if (keys.length <= 12 && keys.every((key) => isScalar(data[key]))) {
+        return formatKeyValues(data);
+    }
+    return JSON.stringify(data, null, 2);
+}
+function formatTable(rows) {
+    if (rows.length === 0)
+        return 'No results';
+    const records = rows.filter(isRecord);
+    if (records.length !== rows.length)
+        return rows.map((row) => String(row)).join('\n');
+    const columns = selectColumns(records);
+    if (!columns.length)
+        return `${records.length} result${records.length === 1 ? '' : 's'}`;
+    const table = new Table({
+        head: columns.map((column) => stdoutColor(humanizeKey(column).toLowerCase(), pc.bold)),
+        chars: {
+            top: '',
+            'top-mid': '',
+            'top-left': '',
+            'top-right': '',
+            bottom: '',
+            'bottom-mid': '',
+            'bottom-left': '',
+            'bottom-right': '',
+            left: '',
+            'left-mid': '',
+            mid: '-',
+            'mid-mid': '  ',
+            right: '',
+            'right-mid': '',
+            middle: '  '
+        },
+        style: {
+            border: [],
+            compact: true,
+            head: []
+        },
+        wordWrap: true
+    });
+    for (const record of records) {
+        table.push(columns.map((column) => displayCell(record[column], column, record)));
+    }
+    return table.toString();
+}
+function selectColumns(records) {
+    const preferred = [
+        'id',
+        'taskId',
+        'name',
+        'title',
+        'type',
+        'platform',
+        'platformName',
+        'openId',
+        'accountName',
+        'accountNameSummary',
+        'username',
+        'nickname',
+        'commentUsername',
+        'text',
+        'status',
+        'visibilityStatus',
+        'enabled',
+        'taskType',
+        'postType',
+        'triggerRule',
+        'sendRule',
+        'metric',
+        'value',
+        'increase',
+        'createTime',
+        'updateTime',
+        'publishTime',
+        'startTime',
+        'endTime',
+        'url'
+    ];
+    const seen = new Set();
+    const available = new Set(records.flatMap((record) => Object.keys(record)));
+    const columns = preferred.filter((column) => available.has(column) && !seen.has(column) && seen.add(column));
+    for (const record of records) {
+        for (const key of Object.keys(record)) {
+            if (columns.length >= 8)
+                return columns;
+            if (!columns.includes(key) && isScalar(record[key]))
+                columns.push(key);
+        }
+    }
+    return columns;
+}
+function formatKeyValues(record) {
+    return Object.entries(record)
+        .filter(([, val]) => val !== undefined && val !== null && val !== '')
+        .map(([key, val]) => `${stdoutColor(humanizeKey(key), pc.cyan)}: ${displayValue(val)}`)
+        .join('\n') || stdoutColor('OK', pc.green);
+}
+function configLabels(record) {
+    return {
+        'API URL': record.apiUrl,
+        'API Key': 'hasApiKey' in record ? record.hasApiKey ? record.apiKey || 'configured' : 'not configured' : record.apiKey,
+        'API Key Source': record.apiKeySource,
+        'Config': record.configPath,
+        'Config Mode': record.configMode
+    };
+}
+function metricLabels(record) {
+    return {
+        Accounts: record.accountCount,
+        Followers: record.followers,
+        'Follower Increase': record.followerIncrease,
+        Posts: record.postCount,
+        Views: record.viewCount,
+        'View Increase': record.viewIncrease,
+        Likes: record.likeCount,
+        Comments: record.commentCount,
+        Shares: record.shareCount,
+        Interactions: record.totalInteractions
+    };
+}
+function displayValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint')
+        return String(value);
+    return JSON.stringify(value);
+}
+function displayCell(value, column, record) {
+    return truncate(displayValue(mapDisplayValue(value, column, record)), maxCellWidth(column));
+}
+function mapDisplayValue(value, column, record) {
+    if (isTimeColumn(column))
+        return formatDateTime(value) ?? value;
+    if (column === 'platform')
+        return platformLabel(value) ?? value;
+    if (column === 'taskType' || column === 'postType')
+        return postTypeLabel(value) ?? value;
+    if (column === 'type' && isMaterialLike(record))
+        return postTypeLabel(value) ?? value;
+    if (column === 'start')
+        return startLabel(value) ?? value;
+    if (column === 'triggerRule')
+        return triggerRuleLabel(value) ?? value;
+    if (column === 'sendRule')
+        return sendRuleLabel(value) ?? value;
+    if (column === 'enabled')
+        return enabledLabel(value) ?? value;
+    if (isYesNoColumn(column))
+        return yesNoLabel(value) ?? value;
+    return value;
+}
+function platformLabel(value) {
+    const labels = {
+        '1': 'tiktok',
+        '2': 'youtube',
+        '3': 'instagram',
+        '4': 'facebook'
+    };
+    return labels[String(value).trim()] ?? null;
+}
+function postTypeLabel(value) {
+    const labels = {
+        '1': 'video',
+        '2': 'image'
+    };
+    return labels[String(value).trim()] ?? null;
+}
+function startLabel(value) {
+    const labels = {
+        '1': 'now',
+        '2': 'scheduled'
+    };
+    return labels[String(value).trim()] ?? null;
+}
+function triggerRuleLabel(value) {
+    const labels = {
+        '1': 'keyword',
+        '2': 'instant'
+    };
+    return labels[String(value).trim()] ?? null;
+}
+function sendRuleLabel(value) {
+    const labels = {
+        '1': 'random',
+        '2': 'sequence'
+    };
+    return labels[String(value).trim()] ?? null;
+}
+function enabledLabel(value) {
+    const labels = {
+        '1': 'enabled',
+        '2': 'disabled',
+        true: 'enabled',
+        false: 'disabled'
+    };
+    return labels[String(value).trim()] ?? null;
+}
+function yesNoLabel(value) {
+    const labels = {
+        '0': 'no',
+        '1': 'yes',
+        '2': 'no',
+        true: 'yes',
+        false: 'no'
+    };
+    return labels[String(value).trim()] ?? null;
+}
+function formatDateTime(value) {
+    const date = parseDateTime(value);
+    if (!date)
+        return null;
+    const year = date.getFullYear();
+    const month = pad2(date.getMonth() + 1);
+    const day = pad2(date.getDate());
+    const hour = pad2(date.getHours());
+    const minute = pad2(date.getMinutes());
+    return `${year}-${month}-${day} ${hour}:${minute}`;
+}
+function parseDateTime(value) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 10000000000) {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed || /^\d{4}-\d{2}-\d{2}$/.test(trimmed))
+        return null;
+    const date = new Date(trimmed);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function isTimeColumn(column) {
+    return /(?:time|date)$/i.test(column);
+}
+function pad2(value) {
+    return String(value).padStart(2, '0');
+}
+function maxCellWidth(column) {
+    if (column === 'name' || column === 'title')
+        return 36;
+    if (column === 'text')
+        return 42;
+    if (column === 'url')
+        return 48;
+    if (isTimeColumn(column))
+        return 16;
+    return 28;
+}
+function truncate(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    if (maxLength <= 3)
+        return value.slice(0, maxLength);
+    return `${value.slice(0, maxLength - 3)}...`;
+}
+function humanizeKey(key) {
+    if (key.includes(' '))
+        return key;
+    return key
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/^./, (char) => char.toUpperCase());
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isScalar(value) {
+    return value === null
+        || value === undefined
+        || ['string', 'number', 'boolean', 'bigint'].includes(typeof value);
+}
+function isConfigLike(record) {
+    return 'configPath' in record && ('apiUrl' in record || 'hasApiKey' in record);
+}
+function isOverviewLike(record) {
+    return 'accountCount' in record || 'postCount' in record || 'viewCount' in record || 'totalInteractions' in record;
+}
+function isMaterialLike(record) {
+    return 'url' in record && ('title' in record || 'type' in record);
+}
+function isYesNoColumn(column) {
+    return column === 'isBusinessAccount'
+        || column === 'isVerified'
+        || column === 'oncePerUser'
+        || column === 'stopOnUserReply';
+}
+function stdoutColor(value, color) {
+    return process.stdout.isTTY ? color(value) : value;
+}
+function stderrColor(value, color) {
+    return process.stderr.isTTY ? color(value) : value;
+}

package/dist/cli/router.js

@@ -0,0 +1,82 @@
+import { has, positiveIntOption, value } from './args.js';
+import { defaultApiUrl, resolveConfig } from './config.js';
+import { CliError } from './output.js';
+import { HELP } from './help.js';
+import { SocialClient } from '../social/client.js';
+import { authUrl } from '../commands/auth.js';
+import { autoRepliesCommand } from '../commands/auto-replies.js';
+import { commentsCommand } from '../commands/comments.js';
+import { login, logout, status } from '../commands/session.js';
+import { listAccounts } from '../commands/accounts.js';
+import { materialsCommand } from '../commands/materials.js';
+import { postsCommand } from '../commands/posts.js';
+import { publishCommand } from '../commands/publish.js';
+import { statsCommand } from '../commands/stats.js';
+import { listTasks } from '../commands/tasks.js';
+import { packageMetadata, updateCommand } from '../commands/update.js';
+import { webhookCommand } from '../commands/webhook.js';
+import { youtubeSeriesCommand } from '../commands/youtube.js';
+export async function runCommand(parsed) {
+    const { positionals, options } = parsed;
+    if (has(options, 'version'))
+        return { data: (await packageMetadata()).version };
+    if (has(options, 'help') || positionals[0] === 'help' || positionals.length === 0)
+        return { data: HELP };
+    const [group, action, subaction] = positionals;
+    if (group === 'login')
+        return login(options);
+    if (group === 'logout')
+        return logout();
+    if (group === 'status')
+        return status(options);
+    const dryRun = Boolean(options['dry-run']);
+    if (group === 'update') {
+        const result = await updateCommand(action, options, dryRun);
+        if (result)
+            return result;
+    }
+    const timeout = positiveIntOption(options, 'timeout', 30000);
+    const resolved = dryRun ? { apiUrl: value(options, 'api-url') || defaultApiUrl(), apiKey: 'dry-run' } : await resolveConfig(options);
+    const client = new SocialClient({ apiUrl: resolved.apiUrl, apiKey: resolved.apiKey || 'dry-run' }, { timeout });
+    if (group === 'auth-url')
+        return authUrl(client, options);
+    if (group === 'accounts' && action === 'list')
+        return listAccounts(client, options);
+    if (group === 'youtube' && action === 'series') {
+        const result = youtubeSeriesCommand(client, subaction, options, dryRun);
+        if (result)
+            return result;
+    }
+    if (group === 'materials') {
+        const result = await materialsCommand(client, action, positionals[2], options, dryRun);
+        if (result)
+            return result;
+    }
+    if (group === 'publish')
+        return publishCommand(client, action, options, dryRun);
+    if (group === 'tasks' && action === 'list')
+        return listTasks(client, options);
+    if (group === 'posts') {
+        const result = postsCommand(client, action, options);
+        if (result)
+            return result;
+    }
+    if (group === 'comments') {
+        const result = commentsCommand(client, action, options, dryRun);
+        if (result)
+            return result;
+    }
+    if (group === 'webhook') {
+        const result = webhookCommand(client, action, options, dryRun);
+        if (result)
+            return result;
+    }
+    if (group === 'stats')
+        return statsCommand(client, action, subaction, options);
+    if (group === 'auto-replies') {
+        const result = await autoRepliesCommand(client, action, options, dryRun);
+        if (result)
+            return result;
+    }
+    throw new CliError('VALIDATION_INVALID_OPTION', `unknown command: ${positionals.join(' ')}`);
+}

package/dist/commands/accounts.js

@@ -0,0 +1,19 @@
+import { intOption, value } from '../cli/args.js';
+import { pageQuery } from '../utils/query.js';
+import { platformOption, timeOption } from '../utils/validation.js';
+export function listAccounts(client, options) {
+    return client.get('/api/bs/auth-account/page', pageQuery(options, 100, {
+        platform: platformOption(options),
+        openId: value(options, 'open-id'),
+        accountName: value(options, 'account-name'),
+        username: value(options, 'username'),
+        nickname: value(options, 'nickname'),
+        isBusinessAccount: intOption(options, 'is-business-account', [0, 1]),
+        isVerified: intOption(options, 'is-verified', [0, 1]),
+        status: intOption(options, 'status', [0, 1]),
+        authTimeBegin: timeOption(options, 'auth-time-begin'),
+        authTimeEnd: timeOption(options, 'auth-time-end'),
+        createTimeBegin: timeOption(options, 'create-time-begin'),
+        createTimeEnd: timeOption(options, 'create-time-end')
+    }));
+}

package/dist/commands/auth.js

@@ -0,0 +1,4 @@
+import { platformOption } from '../utils/validation.js';
+export function authUrl(client, options) {
+    return client.get('/api/bs/auth-link', { platform: platformOption(options, true) });
+}

package/dist/commands/auto-replies.js

@@ -0,0 +1,88 @@
+import { readFile } from 'node:fs/promises';
+import { intOption, requireOption, value, values } from '../cli/args.js';
+import { CliError } from '../cli/output.js';
+import { dryRunResult, pageQuery, pickDefined } from '../utils/query.js';
+import { platformOption } from '../utils/validation.js';
+export async function autoRepliesCommand(client, action, options, dryRun) {
+    if (action === 'list') {
+        return client.get('/api/bs/auto-reply/page', pageQuery(options, 100, {
+            name: value(options, 'name'),
+            creatorName: value(options, 'creator-name'),
+            triggerRule: triggerRuleOption(options),
+            platform: platformOption(options)
+        }));
+    }
+    if (action === 'detail')
+        return client.get('/api/bs/auto-reply/detail', { id: requireOption(options, 'id') });
+    if (action === 'delete') {
+        const body = { id: requireOption(options, 'id') };
+        return dryRunResult(dryRun, body) || client.post('/api/bs/auto-reply/delete', body);
+    }
+    if (action === 'enable' || action === 'disable') {
+        const body = { id: requireOption(options, 'id'), enabled: action === 'enable' ? 1 : 2 };
+        return dryRunResult(dryRun, body) || client.post('/api/bs/auto-reply/enabled', body);
+    }
+    if (action === 'create' || action === 'update') {
+        const body = await autoReplyBody(options, action === 'update');
+        return dryRunResult(dryRun, body) || client.post(`/api/bs/auto-reply/${action}`, body);
+    }
+    return null;
+}
+async function autoReplyBody(options, requireId) {
+    let body = {};
+    const fromFile = value(options, 'from-file');
+    if (fromFile)
+        body = JSON.parse(await readFile(fromFile, 'utf8'));
+    body = {
+        ...body,
+        id: requireId ? requireOption(options, 'id') : value(options, 'id') || body.id,
+        name: value(options, 'name') || body.name,
+        platform: platformOption(options) || body.platform,
+        accountIds: values(options, 'account-id').join(',') || body.accountIds,
+        triggerRule: triggerRuleOption(options) || body.triggerRule,
+        keywords: values(options, 'keyword').join('\n') || body.keywords,
+        sendRule: sendRuleOption(options) || body.sendRule,
+        contents: autoReplyContents(options) || body.contents,
+        oncePerUser: boolEnum(options, 'once-per-user') || body.oncePerUser,
+        repeatIntervalHours: intOption(options, 'repeat-interval-hours') || body.repeatIntervalHours,
+        stopOnUserReply: boolEnum(options, 'stop-on-user-reply') || body.stopOnUserReply,
+        enabled: boolEnum(options, 'enabled') || body.enabled
+    };
+    return pickDefined(body);
+}
+function autoReplyContents(options) {
+    const contents = values(options, 'content');
+    if (!contents.length)
+        return undefined;
+    return JSON.stringify(contents.map((contentText, index) => ({ contentText, delaySeconds: Number(values(options, 'content-delay')[index] || 0) })));
+}
+function triggerRuleOption(options) {
+    const raw = value(options, 'trigger-rule');
+    if (raw === undefined)
+        return undefined;
+    if (raw === 'keyword' || raw === '1')
+        return 1;
+    if (raw === 'instant' || raw === '2')
+        return 2;
+    throw new CliError('VALIDATION_INVALID_OPTION', '--trigger-rule must be keyword, instant, 1, or 2');
+}
+function sendRuleOption(options) {
+    const raw = value(options, 'send-rule');
+    if (raw === undefined)
+        return undefined;
+    if (raw === 'random' || raw === '1')
+        return 1;
+    if (raw === 'sequence' || raw === '2')
+        return 2;
+    throw new CliError('VALIDATION_INVALID_OPTION', '--send-rule must be random, sequence, 1, or 2');
+}
+function boolEnum(options, key) {
+    const raw = value(options, key);
+    if (raw === undefined)
+        return undefined;
+    if (raw === 'true' || raw === '1')
+        return 1;
+    if (raw === 'false' || raw === '2')
+        return 2;
+    throw new CliError('VALIDATION_INVALID_OPTION', `--${key} must be true, false, 1, or 2`);
+}

package/dist/commands/comments.js

@@ -0,0 +1,49 @@
+import { intOption, requireOption, value } from '../cli/args.js';
+import { CliError } from '../cli/output.js';
+import { dryRunResult, pageQuery, pickDefined } from '../utils/query.js';
+import { platformOption, timeOption } from '../utils/validation.js';
+export function commentsCommand(client, action, options, dryRun) {
+    if (action === 'list')
+        return client.get('/api/bs/comment/page', commentsQuery(options));
+    if (action === 'reply') {
+        const body = commentReplyBody(options);
+        return dryRunResult(dryRun, body) || client.post('/api/bs/comment/reply-create', body);
+    }
+    return null;
+}
+function commentsQuery(options) {
+    return pageQuery(options, 100, {
+        platform: platformOption(options),
+        openId: value(options, 'open-id'),
+        videoId: value(options, 'video-id'),
+        socialPostId: value(options, 'social-post-id'),
+        commentType: value(options, 'comment-type'),
+        commentAction: value(options, 'comment-action'),
+        status: value(options, 'status'),
+        visibilityStatus: value(options, 'visibility-status'),
+        commentUsername: value(options, 'comment-username'),
+        keyword: value(options, 'keyword'),
+        startTime: timeOption(options, 'start-time'),
+        endTime: timeOption(options, 'end-time')
+    });
+}
+function commentReplyBody(options) {
+    const body = pickDefined({
+        platform: platformOption(options, true),
+        openId: requireOption(options, 'open-id'),
+        videoId: requireOption(options, 'video-id'),
+        commentId: requireOption(options, 'comment-id'),
+        text: value(options, 'text'),
+        replyImageUrl: value(options, 'reply-image-url'),
+        imageUri: value(options, 'image-uri'),
+        imageWidth: intOption(options, 'image-width'),
+        imageHeight: intOption(options, 'image-height')
+    });
+    if (!body.text && !body.replyImageUrl && !body.imageUri) {
+        throw new CliError('VALIDATION_REQUIRED_OPTION', '--text, --reply-image-url, or --image-uri is required');
+    }
+    if (body.imageUri && (body.imageWidth === undefined || body.imageHeight === undefined)) {
+        throw new CliError('VALIDATION_REQUIRED_OPTION', '--image-width and --image-height are required with --image-uri');
+    }
+    return body;
+}

package/dist/commands/materials.js

@@ -0,0 +1,19 @@
+import { intOption, value } from '../cli/args.js';
+import { CliError } from '../cli/output.js';
+import { dryRunResult, pageQuery } from '../utils/query.js';
+import { validateUploadFile } from '../utils/validation.js';
+export async function materialsCommand(client, action, file, options, dryRun) {
+    if (action === 'list') {
+        return client.get('/api/bs/material/page', pageQuery(options, 200, {
+            type: intOption(options, 'type', [1, 2]),
+            title: value(options, 'title')
+        }));
+    }
+    if (action === 'upload') {
+        if (!file)
+            throw new CliError('VALIDATION_REQUIRED_OPTION', 'missing upload file path');
+        await validateUploadFile(file);
+        return dryRunResult(dryRun, { file }) || client.upload('/api/bs/material/upload', file);
+    }
+    return null;
+}