@northmoon-labs/social-cli 0.1.0

package/dist/commands/posts.js

@@ -0,0 +1,40 @@
+import { intOption, value } from '../cli/args.js';
+import { pageQuery } from '../utils/query.js';
+import { platformOption, timeOption } from '../utils/validation.js';
+export function postsCommand(client, action, options) {
+    if (action === 'list')
+        return client.get('/api/bs/post/page', postsQuery(options));
+    if (action === 'stats')
+        return client.get('/api/bs/post/published-stats', postsStatsQuery(options));
+    return null;
+}
+function postsQuery(options) {
+    return pageQuery(options, 100, {
+        platform: platformOption(options),
+        openId: value(options, 'open-id'),
+        shareId: value(options, 'share-id'),
+        postId: value(options, 'post-id'),
+        postType: intOption(options, 'post-type', [1, 2]),
+        status: intOption(options, 'status'),
+        statusEvent: value(options, 'status-event'),
+        title: value(options, 'title'),
+        caption: value(options, 'caption'),
+        mainTaskId: value(options, 'main-task-id'),
+        createTimeBegin: timeOption(options, 'create-time-begin'),
+        createTimeEnd: timeOption(options, 'create-time-end'),
+        publishTimeBegin: timeOption(options, 'publish-time-begin'),
+        publishTimeEnd: timeOption(options, 'publish-time-end')
+    });
+}
+function postsStatsQuery(options) {
+    return pageQuery(options, 100, {
+        platform: platformOption(options),
+        mainTaskId: value(options, 'main-task-id'),
+        openId: value(options, 'open-id'),
+        postId: value(options, 'post-id'),
+        postType: intOption(options, 'post-type', [1, 2]),
+        title: value(options, 'title'),
+        publishTimeBegin: timeOption(options, 'publish-time-begin'),
+        publishTimeEnd: timeOption(options, 'publish-time-end')
+    });
+}

package/dist/commands/publish.js

@@ -0,0 +1,69 @@
+import { intOption, value, values } from '../cli/args.js';
+import { CliError } from '../cli/output.js';
+import { dryRunResult, pickDefined } from '../utils/query.js';
+import { parseDateTime, validateHttpUrl } from '../utils/validation.js';
+export function publishCommand(client, kind, options, dryRun) {
+    const body = publishBody(kind, options);
+    return dryRunResult(dryRun, body) || client.post('/api/bs/post-task/create', body);
+}
+function publishBody(kind, options) {
+    if (kind !== 'video' && kind !== 'image') {
+        throw new CliError('VALIDATION_INVALID_OPTION', 'publish command must be video or image');
+    }
+    const accounts = values(options, 'account');
+    const contents = values(options, 'content');
+    if (!accounts.length)
+        throw new CliError('VALIDATION_REQUIRED_OPTION', 'missing required option --account');
+    if (!contents.length)
+        throw new CliError('VALIDATION_REQUIRED_OPTION', 'missing required option --content');
+    for (const content of contents)
+        validateHttpUrl(content, '--content');
+    const at = value(options, 'at');
+    const start = intOption(options, 'start');
+    const runTime = timeOptionForPublish(options, 'run-time');
+    if (at && (start !== undefined || runTime !== undefined)) {
+        throw new CliError('VALIDATION_INVALID_OPTION', '--at cannot be used with --start or --run-time');
+    }
+    const body = {
+        taskType: kind === 'video' ? 1 : 2,
+        openIds: accounts.join(','),
+        postContents: contents.join(','),
+        videoAssignType: intOption(options, 'video-assign-type', [1, 2]),
+        title: value(options, 'title'),
+        caption: value(options, 'caption'),
+        thumbnailOffset: intOption(options, 'thumbnail-offset'),
+        customThumbnailUrl: value(options, 'custom-thumbnail-url'),
+        playlistIds: values(options, 'playlist-id').join(',') || undefined,
+        privacyStatus: privacyOption(options)
+    };
+    if (at) {
+        const ms = parseDateTime(at, '--at');
+        if (ms <= Date.now())
+            throw new CliError('VALIDATION_INVALID_OPTION', '--at must be a future time');
+        body.start = 2;
+        body.runTime = ms;
+    }
+    else {
+        body.start = start;
+        body.runTime = runTime;
+    }
+    return pickDefined(body);
+}
+function privacyOption(options) {
+    const raw = value(options, 'privacy');
+    if (raw === undefined)
+        return undefined;
+    if (raw === 'public' || raw === '1')
+        return '1';
+    if (raw === 'private' || raw === '0')
+        return '0';
+    throw new CliError('VALIDATION_INVALID_OPTION', '--privacy must be public, private, 1, or 0');
+}
+function timeOptionForPublish(options, key) {
+    const raw = value(options, key);
+    if (raw === undefined)
+        return undefined;
+    if (/^\d+$/.test(String(raw)))
+        return Number(raw);
+    return parseDateTime(raw, `--${key}`);
+}

package/dist/commands/session.js

@@ -0,0 +1,40 @@
+import { value } from '../cli/args.js';
+import { configFileMode, defaultApiUrl, deleteLocalConfig, getConfigPath, readLocalConfig, validateApiUrl, writeLocalConfig } from '../cli/config.js';
+import { CliError, maskSecret } from '../cli/output.js';
+import { readStdin } from '../utils/stdin.js';
+export async function login(options) {
+    const apiKeyFromOption = value(options, 'api-key');
+    const useStdin = Boolean(options['api-key-stdin']);
+    if (apiKeyFromOption && useStdin) {
+        throw new CliError('VALIDATION_INVALID_OPTION', 'use either --api-key or --api-key-stdin, not both');
+    }
+    if (!apiKeyFromOption && !useStdin) {
+        throw new CliError('VALIDATION_REQUIRED_OPTION', 'login requires --api-key or --api-key-stdin');
+    }
+    const apiKey = (apiKeyFromOption ?? await readStdin()).trim();
+    if (!apiKey)
+        throw new CliError('VALIDATION_REQUIRED_OPTION', 'api key is empty');
+    const apiUrl = value(options, 'api-url') || defaultApiUrl();
+    validateApiUrl(apiUrl);
+    await writeLocalConfig({ apiUrl, apiKey, updatedAt: new Date().toISOString() });
+    return { data: { apiUrl, apiKey: maskSecret(apiKey), configPath: getConfigPath() } };
+}
+export async function logout() {
+    await deleteLocalConfig();
+    return { data: { ok: true } };
+}
+export async function status(options) {
+    const local = await readLocalConfig();
+    const envApiKey = process.env.NMSOCIAL_API_KEY;
+    const apiUrl = value(options, 'api-url') || process.env.NMSOCIAL_API_URL || local.apiUrl || defaultApiUrl();
+    return {
+        data: {
+            apiUrl,
+            hasApiKey: Boolean(envApiKey || local.apiKey),
+            apiKeySource: envApiKey ? 'env' : local.apiKey ? 'config' : null,
+            apiKey: maskSecret(envApiKey || local.apiKey),
+            configPath: getConfigPath(),
+            configMode: await configFileMode()
+        }
+    };
+}

package/dist/commands/stats.js

@@ -0,0 +1,65 @@
+import { intOption, requireOption, value, values } from '../cli/args.js';
+import { CliError } from '../cli/output.js';
+import { ACCOUNT_METRICS, POST_METRICS } from '../social/types.js';
+import { pageQuery, pickQuery } from '../utils/query.js';
+import { dateOption, platformOption, validateMetric } from '../utils/validation.js';
+export function statsCommand(client, scope, action, options) {
+    if (scope === 'overview')
+        return client.get('/api/bs/stat/overview', statBaseQuery(options, { postId: value(options, 'post-id'), postType: intOption(options, 'post-type', [1, 2]) }));
+    if (scope === 'account' && action === 'trend') {
+        validateMetric(value(options, 'metric') || 'followers', ACCOUNT_METRICS);
+        return client.get('/api/bs/stat/account/trend', statBaseQuery(options, { metric: value(options, 'metric') }));
+    }
+    if (scope === 'account' && action === 'rank') {
+        validateMetric(value(options, 'metric') || 'followerIncrease', ACCOUNT_METRICS);
+        return client.get('/api/bs/stat/account/rank', pageQuery(options, 100, statBaseQuery(options, { metric: value(options, 'metric'), order: orderOption(options) })));
+    }
+    if (scope === 'post' && action === 'trend') {
+        validateMetric(value(options, 'metric') || 'viewCount', POST_METRICS);
+        return client.get('/api/bs/stat/post/trend', statBaseQuery(options, postFilterQuery(options, { metric: value(options, 'metric') })));
+    }
+    if (scope === 'post' && action === 'rank') {
+        validateMetric(value(options, 'metric') || 'viewIncrease', POST_METRICS);
+        return client.get('/api/bs/stat/post/rank', pageQuery(options, 100, statBaseQuery(options, postFilterQuery(options, { metric: value(options, 'metric'), order: orderOption(options) }))));
+    }
+    if (scope === 'post' && action === 'detail-trend') {
+        const metrics = values(options, 'metric');
+        for (const metric of metrics)
+            validateMetric(metric, POST_METRICS);
+        return client.get('/api/bs/stat/post/detailTrend', statBaseQuery(options, {
+            platform: platformOption(options),
+            postId: requireOption(options, 'post-id'),
+            metrics: metrics.length ? metrics.join(',') : undefined
+        }));
+    }
+    if (scope === 'platform' && action === 'summary') {
+        return client.get('/api/bs/stat/platform/summary', statDateQuery(options));
+    }
+    throw new CliError('VALIDATION_INVALID_OPTION', 'unknown stats command');
+}
+function statBaseQuery(options, extra = {}) {
+    return pickQuery({ platform: platformOption(options), openId: value(options, 'open-id'), ...statDateQuery(options), ...extra });
+}
+function statDateQuery(options) {
+    const startDate = dateOption(options, 'start-date');
+    const endDate = dateOption(options, 'end-date');
+    if (startDate && endDate && startDate > endDate)
+        throw new CliError('VALIDATION_INVALID_OPTION', '--start-date cannot be after --end-date');
+    return pickQuery({ startDate, endDate });
+}
+function postFilterQuery(options, extra = {}) {
+    return pickQuery({
+        openId: value(options, 'open-id'),
+        mainTaskId: value(options, 'main-task-id'),
+        postType: intOption(options, 'post-type', [1, 2]),
+        ...extra
+    });
+}
+function orderOption(options) {
+    const raw = value(options, 'order');
+    if (raw === undefined)
+        return undefined;
+    if (raw === 'asc' || raw === 'desc')
+        return raw;
+    throw new CliError('VALIDATION_INVALID_OPTION', '--order must be asc or desc');
+}

package/dist/commands/tasks.js

@@ -0,0 +1,17 @@
+import { intOption, value } from '../cli/args.js';
+import { pageQuery } from '../utils/query.js';
+import { platformOption, timeOption } from '../utils/validation.js';
+export function listTasks(client, options) {
+    return client.get('/api/bs/post-task/page', pageQuery(options, 200, {
+        taskName: value(options, 'task-name'),
+        platform: platformOption(options),
+        openId: value(options, 'open-id'),
+        videoAssignType: intOption(options, 'video-assign-type', [1, 2]),
+        taskType: intOption(options, 'task-type', [1, 2]),
+        start: intOption(options, 'start'),
+        createTimeBegin: timeOption(options, 'create-time-begin'),
+        createTimeEnd: timeOption(options, 'create-time-end'),
+        runTimeBegin: timeOption(options, 'run-time-begin'),
+        runTimeEnd: timeOption(options, 'run-time-end')
+    }));
+}

package/dist/commands/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/update.js

@@ -0,0 +1,138 @@
+import { spawnSync } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { value } from '../cli/args.js';
+import { CliError } from '../cli/output.js';
+const UPDATE_CHECK_TIMEOUT_MS = 15000;
+const UPDATE_INSTALL_TIMEOUT_MS = 300000;
+export async function updateCommand(action, options, dryRun) {
+    if (action !== undefined && action !== 'check')
+        return null;
+    const metadata = await packageMetadata();
+    const latest = await latestVersion(metadata.name);
+    const updateAvailable = isVersionGreater(latest, metadata.version);
+    const manager = managerOption(options);
+    const command = updateCommandText(manager, metadata.name);
+    if (action === 'check' || dryRun || !updateAvailable) {
+        return {
+            data: {
+                package: metadata.name,
+                current: metadata.version,
+                latest,
+                updateAvailable,
+                command: updateAvailable ? command.join(' ') : undefined
+            }
+        };
+    }
+    const result = spawnSync(command[0], command.slice(1), {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: UPDATE_INSTALL_TIMEOUT_MS
+    });
+    if (result.error) {
+        throw new CliError('UPDATE_FAILED', result.error.message, {
+            payload: { command: command.join(' ') }
+        });
+    }
+    if (result.status !== 0) {
+        throw new CliError('UPDATE_FAILED', result.stderr || result.stdout || `update exited with code ${result.status}`, {
+            status: result.status,
+            payload: {
+                command: command.join(' '),
+                stdout: result.stdout,
+                stderr: result.stderr
+            }
+        });
+    }
+    return {
+        data: {
+            updated: true,
+            package: metadata.name,
+            previous: metadata.version,
+            current: latest,
+            command: command.join(' ')
+        }
+    };
+}
+export async function packageMetadata() {
+    const packagePath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+    const raw = await readFile(packagePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed.name || !parsed.version)
+        throw new CliError('PACKAGE_METADATA_INVALID', 'package metadata is missing name or version');
+    return { name: parsed.name, version: parsed.version };
+}
+async function latestVersion(packageName) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), UPDATE_CHECK_TIMEOUT_MS);
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, {
+            headers: { accept: 'application/json' },
+            signal: controller.signal
+        });
+        if (!response.ok)
+            throw new CliError('UPDATE_CHECK_FAILED', `npm registry returned HTTP ${response.status}`);
+        const metadata = await response.json();
+        const latest = metadata['dist-tags']?.latest;
+        if (!latest)
+            throw new CliError('UPDATE_CHECK_FAILED', 'npm registry response does not include dist-tags.latest');
+        return latest;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new CliError('UPDATE_CHECK_FAILED', 'npm registry request timed out');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function managerOption(options) {
+    const raw = value(options, 'manager');
+    if (raw === undefined)
+        return detectedPackageManager();
+    if (raw === 'npm' || raw === 'pnpm' || raw === 'bun')
+        return raw;
+    throw new CliError('VALIDATION_INVALID_OPTION', '--manager must be npm, pnpm, or bun');
+}
+function detectedPackageManager() {
+    const userAgent = process.env.npm_config_user_agent || '';
+    if (userAgent.startsWith('pnpm/'))
+        return 'pnpm';
+    if (userAgent.startsWith('bun/'))
+        return 'bun';
+    return 'npm';
+}
+function updateCommandText(manager, packageName) {
+    if (manager === 'pnpm')
+        return ['pnpm', 'add', '-g', `${packageName}@latest`];
+    if (manager === 'bun')
+        return ['bun', 'add', '-g', `${packageName}@latest`];
+    return ['npm', 'install', '-g', `${packageName}@latest`];
+}
+export function isVersionGreater(candidate, current) {
+    const left = parseVersion(candidate);
+    const right = parseVersion(current);
+    if (!left || !right)
+        return candidate !== current;
+    for (let i = 0; i < 3; i += 1) {
+        if (left.parts[i] > right.parts[i])
+            return true;
+        if (left.parts[i] < right.parts[i])
+            return false;
+    }
+    if (!left.prerelease && right.prerelease)
+        return true;
+    return false;
+}
+function parseVersion(version) {
+    const match = version.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!match)
+        return null;
+    return {
+        parts: [Number(match[1]), Number(match[2]), Number(match[3])],
+        prerelease: match[4] || null
+    };
+}

package/dist/commands/webhook.js

@@ -0,0 +1,16 @@
+import { requireOption } from '../cli/args.js';
+import { dryRunResult } from '../utils/query.js';
+import { validateHttpUrl } from '../utils/validation.js';
+export function webhookCommand(client, action, options, dryRun) {
+    if (action === 'set') {
+        const url = requireOption(options, 'url');
+        validateHttpUrl(url, '--url');
+        const body = { webhookUrl: url };
+        return dryRunResult(dryRun, body) || client.post('/api/bs/webhook-url/update', body);
+    }
+    if (action === 'disable') {
+        const body = { webhookUrl: '' };
+        return dryRunResult(dryRun, body) || client.post('/api/bs/webhook-url/update', body);
+    }
+    return null;
+}

package/dist/commands/youtube.js

@@ -0,0 +1,16 @@
+import { requireOption, value } from '../cli/args.js';
+import { dryRunResult, pickDefined } from '../utils/query.js';
+export function youtubeSeriesCommand(client, action, options, dryRun) {
+    if (action === 'list') {
+        return client.get('/api/bs/youtube/series/list', { openId: requireOption(options, 'open-id') });
+    }
+    if (action === 'create') {
+        const body = pickDefined({
+            openId: requireOption(options, 'open-id'),
+            title: requireOption(options, 'title'),
+            description: value(options, 'description')
+        });
+        return dryRunResult(dryRun, body) || client.post('/api/bs/youtube/series/create', body);
+    }
+    return null;
+}

package/dist/social/client.js

@@ -0,0 +1,95 @@
+import { basename } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { CliError } from '../cli/output.js';
+const MAX_BUFFERED_UPLOAD_BYTES = 100 * 1024 * 1024;
+export class SocialClient {
+    apiUrl;
+    apiKey;
+    timeout;
+    constructor(config, options = {}) {
+        this.apiUrl = config.apiUrl.replace(/\/+$/, '');
+        this.apiKey = config.apiKey;
+        this.timeout = options.timeout || 30000;
+    }
+    async get(path, query = {}) {
+        const url = new URL(`${this.apiUrl}${path}`);
+        for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined && value !== null && value !== '') {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return this.request(url, { method: 'GET' });
+    }
+    async post(path, body = {}) {
+        return this.request(new URL(`${this.apiUrl}${path}`), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+            body: JSON.stringify(body)
+        });
+    }
+    async upload(path, filePath) {
+        const fileInfo = await stat(filePath);
+        if (fileInfo.size > MAX_BUFFERED_UPLOAD_BYTES) {
+            throw new CliError('FILE_TOO_LARGE', 'file is too large for the current uploader; please upload a file smaller than 100MB');
+        }
+        const form = new FormData();
+        const file = await import('node:fs/promises').then(({ readFile }) => readFile(filePath));
+        form.set('file', new Blob([file]), basename(filePath));
+        return this.request(new URL(`${this.apiUrl}${path}`), {
+            method: 'POST',
+            body: form
+        });
+    }
+    async request(url, init) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(url, {
+                ...init,
+                headers: {
+                    apiKey: this.apiKey,
+                    ...(init.headers || {})
+                },
+                signal: controller.signal
+            });
+            const text = await response.text();
+            let payload;
+            try {
+                payload = text ? JSON.parse(text) : { c: response.status, d: null };
+            }
+            catch {
+                throw new CliError('RESPONSE_INVALID_JSON', 'server returned invalid JSON', { status: response.status, payload: text });
+            }
+            if (!response.ok) {
+                throw new CliError('NETWORK_ERROR', payload?.m || `HTTP ${response.status}`, { status: response.status, payload });
+            }
+            if (payload.c !== 200) {
+                throw new CliError('SOCIAL_API_ERROR', payload.m || 'Social API returned an error', {
+                    status: payload.c,
+                    payload,
+                    meta: providerMeta(payload)
+                });
+            }
+            return { data: payload.d, provider: payload };
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new CliError('NETWORK_TIMEOUT', 'request timed out');
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+export function providerMeta(payload) {
+    if (!payload)
+        return null;
+    return {
+        providerCode: payload.c,
+        providerMessage: payload.m,
+        providerTimestamp: payload.t,
+        requestId: payload.lb
+    };
+}

package/dist/social/types.js

@@ -0,0 +1,47 @@
+export const PLATFORM_MAP = {
+    tiktok: 1,
+    youtube: 2,
+    instagram: 3,
+    facebook: 4
+};
+export const ACCOUNT_METRICS = [
+    'followers',
+    'followerIncrease',
+    'following',
+    'totalLikes',
+    'totalLikesIncrease',
+    'videosCount',
+    'videosIncrease'
+];
+export const POST_METRICS = [
+    'viewCount',
+    'viewIncrease',
+    'likeCount',
+    'commentCount',
+    'shareCount',
+    'favoriteCount',
+    'reachCount',
+    'impressionCount',
+    'totalInteractions'
+];
+export const MATERIAL_EXTENSIONS = new Set([
+    'mp4',
+    'mov',
+    'avi',
+    'mkv',
+    'webm',
+    'flv',
+    'wmv',
+    'm4v',
+    '3gp',
+    'jpg',
+    'jpeg',
+    'png',
+    'gif',
+    'bmp',
+    'webp',
+    'heic',
+    'heif',
+    'tif',
+    'tiff'
+]);

package/dist/utils/query.js

@@ -0,0 +1,30 @@
+import { intOption } from '../cli/args.js';
+import { CliError } from '../cli/output.js';
+export function pageQuery(options, maxPageSize, extra = {}) {
+    const pageNum = intOption(options, 'page') ?? 1;
+    const pageSize = intOption(options, 'page-size') ?? 20;
+    if (pageNum < 1)
+        throw new CliError('VALIDATION_INVALID_OPTION', '--page must be greater than 0');
+    if (pageSize < 1 || pageSize > maxPageSize)
+        throw new CliError('VALIDATION_INVALID_OPTION', `--page-size must be between 1 and ${maxPageSize}`);
+    return pickQuery({ pageNum, pageSize, ...extra });
+}
+export function pickDefined(input) {
+    const output = {};
+    for (const [key, val] of Object.entries(input)) {
+        if (val !== undefined && val !== null && val !== '')
+            output[key] = val;
+    }
+    return output;
+}
+export function pickQuery(input) {
+    const output = {};
+    for (const [key, val] of Object.entries(input)) {
+        if (val !== undefined && val !== null && val !== '')
+            output[key] = val;
+    }
+    return output;
+}
+export function dryRunResult(dryRun, body) {
+    return dryRun ? { data: { dryRun: true, body } } : null;
+}

package/dist/utils/stdin.js

@@ -0,0 +1,17 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stderr as output } from 'node:process';
+export async function readStdin() {
+    if (process.stdin.isTTY) {
+        const rl = createInterface({ input, output });
+        try {
+            return await rl.question('API Key: ');
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf8');
+}