@jacobbubu/md-to-lark 1.0.0

package/dist/publish/stage-cache.js

@@ -0,0 +1,56 @@
+import { createHash } from 'node:crypto';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+function buildPrepareDirForSource(prepareRootDir, sourcePath) {
+    const sourceHash = createHash('sha1').update(path.resolve(sourcePath)).digest('hex').slice(0, 12);
+    const baseName = path.basename(sourcePath, path.extname(sourcePath)).replace(/[^a-zA-Z0-9._-]+/g, '-');
+    return path.join(prepareRootDir, `${baseName || 'md'}-${sourceHash}`);
+}
+export function buildPipelineStagePaths(cacheRootDir, sourcePath) {
+    const rootDir = buildPrepareDirForSource(cacheRootDir, sourcePath);
+    return {
+        rootDir,
+        sourceDir: path.join(rootDir, '00-source'),
+        prepareDir: path.join(rootDir, '01-prepare'),
+        hastDir: path.join(rootDir, '02-hast'),
+        lastDir: path.join(rootDir, '03-last'),
+        bttDir: path.join(rootDir, '04-btt'),
+        publishDir: path.join(rootDir, '05-publish'),
+    };
+}
+export async function ensureDir(dirPath) {
+    await mkdir(dirPath, { recursive: true });
+}
+export async function writeJson(filePath, value) {
+    await ensureDir(path.dirname(filePath));
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+export async function writeSourceStage(stagePaths, originalMarkdown, presetMarkdown, meta) {
+    await ensureDir(stagePaths.sourceDir);
+    await writeFile(path.join(stagePaths.sourceDir, 'original.md'), originalMarkdown, 'utf8');
+    await writeFile(path.join(stagePaths.sourceDir, 'preset.md'), presetMarkdown, 'utf8');
+    await writeJson(path.join(stagePaths.sourceDir, 'meta.json'), meta);
+}
+export async function writePrepareStage(stagePaths, preparedMarkdown, prepareResult) {
+    await ensureDir(stagePaths.prepareDir);
+    await writeFile(path.join(stagePaths.prepareDir, 'prepared.md'), preparedMarkdown, 'utf8');
+    const { preparedContent: _ignoredPreparedContent, logFileContent: _ignoredLogFileContent, ...prepareMeta } = prepareResult;
+    await writeJson(path.join(stagePaths.prepareDir, 'result.json'), prepareMeta);
+    await writePrepareLogFile(path.join(stagePaths.prepareDir, 'download.log.json'), prepareResult.logFileContent);
+}
+export async function writePrepareLogFile(filePath, value) {
+    await writeJson(filePath, value);
+}
+export async function writeHastStage(stagePaths, hast) {
+    await writeJson(path.join(stagePaths.hastDir, 'hast.json'), hast);
+}
+export async function writeLastStage(stagePaths, last) {
+    await writeJson(path.join(stagePaths.lastDir, 'last.json'), last);
+}
+export async function writeBttStage(stagePaths, btt, meta) {
+    await writeJson(path.join(stagePaths.bttDir, 'btt.json'), btt);
+    await writeJson(path.join(stagePaths.bttDir, 'meta.json'), meta);
+}
+export async function writePublishStageArtifact(stagePaths, artifact) {
+    await writeJson(path.join(stagePaths.publishDir, 'result.json'), artifact);
+}

package/dist/shared/rate-limiter.js

@@ -0,0 +1,18 @@
+export class RateLimiter {
+    nextAllowedAt = 0;
+    minIntervalMs;
+    constructor(minIntervalMs) {
+        this.minIntervalMs = minIntervalMs;
+    }
+    async wait() {
+        const now = Date.now();
+        const delay = this.nextAllowedAt - now;
+        if (delay > 0) {
+            await sleep(delay);
+        }
+        this.nextAllowedAt = Date.now() + this.minIntervalMs;
+    }
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/shared/retry.js

@@ -0,0 +1,141 @@
+import { sleep } from './rate-limiter.js';
+function toObjectRecord(value) {
+    return value && typeof value === 'object' ? value : null;
+}
+function getString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : '';
+}
+function collectErrorRecords(error) {
+    const queue = [error];
+    const seen = new Set();
+    const records = [];
+    while (queue.length > 0 && records.length < 20) {
+        const current = queue.shift();
+        if (current == null)
+            continue;
+        if (typeof current === 'object') {
+            if (seen.has(current))
+                continue;
+            seen.add(current);
+        }
+        if (Array.isArray(current)) {
+            for (const item of current) {
+                queue.push(item);
+            }
+            continue;
+        }
+        const row = toObjectRecord(current);
+        if (!row)
+            continue;
+        records.push(row);
+        queue.push(row.response, row.data, row.error, row.cause);
+    }
+    return records;
+}
+function toNumberFromUnknown(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && /^\d+$/.test(value.trim()))
+        return Number(value.trim());
+    return undefined;
+}
+function getErrorHttpStatus(error) {
+    const records = collectErrorRecords(error);
+    for (const row of records) {
+        const status = toNumberFromUnknown(row.status);
+        if (status)
+            return status;
+    }
+    return undefined;
+}
+function getErrorApiCode(error) {
+    const records = collectErrorRecords(error);
+    for (const row of records) {
+        const code = row.code;
+        if (typeof code === 'number' || typeof code === 'string')
+            return code;
+    }
+    return undefined;
+}
+function getRetryAfterMs(error) {
+    const records = collectErrorRecords(error);
+    for (const row of records) {
+        const headers = toObjectRecord(row.headers);
+        if (!headers)
+            continue;
+        const rawRetryAfter = headers['retry-after'] ?? headers['Retry-After'];
+        let value = rawRetryAfter;
+        if (Array.isArray(value)) {
+            value = value[0];
+        }
+        const asNumber = toNumberFromUnknown(value);
+        if (asNumber && asNumber > 0) {
+            return asNumber * 1000;
+        }
+    }
+    return undefined;
+}
+function getErrorText(error) {
+    const textParts = [];
+    if (error instanceof Error && error.message) {
+        textParts.push(error.message);
+    }
+    const records = collectErrorRecords(error);
+    for (const row of records) {
+        const message = getString(row, 'message');
+        const msg = getString(row, 'msg');
+        if (message)
+            textParts.push(message);
+        if (msg)
+            textParts.push(msg);
+    }
+    return textParts.join(' | ');
+}
+function isRetryableError(error) {
+    const status = getErrorHttpStatus(error);
+    if (status && [429, 502, 503, 504].includes(status)) {
+        return true;
+    }
+    const apiCode = getErrorApiCode(error);
+    if (String(apiCode) === '99991400') {
+        return true;
+    }
+    const text = getErrorText(error).toLowerCase();
+    return /429|too many requests|rate|frequency|request trigger frequency limit|timeout|timed out|econnreset|eai_again|502|503|504/.test(text);
+}
+function formatErrorForLog(error) {
+    const status = getErrorHttpStatus(error);
+    const apiCode = getErrorApiCode(error);
+    const text = getErrorText(error) || String(error);
+    const prefixes = [];
+    if (status)
+        prefixes.push(`status=${status}`);
+    if (apiCode != null)
+        prefixes.push(`code=${String(apiCode)}`);
+    const prefix = prefixes.length > 0 ? `${prefixes.join(' ')} ` : '';
+    return `${prefix}${text}`;
+}
+export async function withRetry(label, run, attempts = 7) {
+    let lastError;
+    let usedAttempts = 0;
+    for (let i = 0; i < attempts; i += 1) {
+        usedAttempts = i + 1;
+        try {
+            return await run();
+        }
+        catch (error) {
+            lastError = error;
+            if (!isRetryableError(error) || i === attempts - 1) {
+                break;
+            }
+            const retryAfterMs = getRetryAfterMs(error);
+            const backoffMs = retryAfterMs ?? Math.min(30_000, 800 * 2 ** i);
+            const jitterMs = Math.floor(Math.random() * 300);
+            const delayMs = backoffMs + jitterMs;
+            console.warn(`[retry] ${label} attempt ${i + 1}/${attempts} failed: ${formatErrorForLog(error)}; retrying in ${delayMs}ms`);
+            await sleep(delayMs);
+        }
+    }
+    throw new Error(`${label} failed after ${usedAttempts} attempt(s): ${formatErrorForLog(lastError)}`);
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@jacobbubu/md-to-lark",
+  "version": "1.0.0",
+  "description": "Publish Markdown to Feishu docs with a stable pipeline.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "publish-md-to-lark": "dist/cli/publish-md-to-lark.js"
+  },
+  "scripts": {
+    "test": "node --test --import tsx \"tests/**/*.test.ts\"",
+    "test:e2e": "node --test --test-concurrency=1 --import tsx \"tests-e2e/**/*.test.ts\"",
+    "test:e2e:watch": "node --test --test-concurrency=1 --watch --import tsx \"tests-e2e/**/*.test.ts\"",
+    "test:watch": "node --test --watch --import tsx \"tests/**/*.test.ts\"",
+    "clean": "node scripts/clean-dist.mjs",
+    "build": "npm run clean && tsc -p tsconfig.json && node scripts/ensure-cli-executable.mjs",
+    "release": "semantic-release",
+    "dev": "tsx src/cli/publish-md-to-lark.ts",
+    "dev:playground": "tsx devserver/jquery-playground.ts",
+    "publish:md": "tsx src/cli/publish-md-to-lark.ts",
+    "fetch:board-data": "tsx scripts/print-board-content.ts",
+    "example:module": "tsx examples/module-usage.ts",
+    "start": "node dist/cli/publish-md-to-lark.js",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check"
+  },
+  "keywords": [],
+  "author": "jacobbubu <rong.shen@gmail.com>",
+  "license": "ISC",
+  "type": "module",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jacobbubu/md-to-lark.git"
+  },
+  "homepage": "https://github.com/jacobbubu/md-to-lark#readme",
+  "bugs": {
+    "url": "https://github.com/jacobbubu/md-to-lark/issues"
+  },
+  "dependencies": {
+    "@jacobbubu/md-zh-format": "^1.0.1",
+    "dotenv": "^17.2.2",
+    "hast-util-to-string": "^3.0.1",
+    "rehype-parse": "^9.0.1",
+    "rehype-stringify": "^10.0.1",
+    "remark-gfm": "^4.0.1",
+    "remark-math": "^6.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.1.0",
+    "yaml": "^2.8.2"
+  },
+  "devDependencies": {
+    "@larksuiteoapi/node-sdk": "^1.59.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.6",
+    "@semantic-release/npm": "^12.0.2",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@types/node": "^25.3.3",
+    "playwright": "^1.58.2",
+    "prettier": "^3.8.1",
+    "semantic-release": "^24.2.9",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}