publishport-opencli 1.8.5-pp.2 → 1.8.5-pp.21

package/clis/_shared/article/auth.js

@@ -1,124 +1,16 @@
-/**
- * 登录检测 / whoami（共享基础设施）
- *
- * 移植自 Wechatsync 各平台适配器的 `checkAuth()`：在平台页面上下文里打一个「取当前用户」
- * 的接口，登录了就返回账号信息，没登录就返回 isAuthenticated:false。
- *
- * 两个用途共用同一份 profile.checkAuth：
- *   - `<site> whoami`         —— 展示当前登录账号（opencli 既有约定）
- *   - 发布前的登录前置检测     —— 没登录直接抛错，省得发布到一半才失败
- *
- * 同样走单次 evaluate（带 cookie、同源），不依赖任何 Node 侧凭据。
- *
- * @typedef {object} AuthProfile
- * @property {string} home  导航地址（取用户接口要在该源下才带 cookie）
- * @property {string} [originRe]
- * @property {Function} checkAuth  页面内执行 `async (PP) => ({ isAuthenticated, userId?, username?, avatar? })`
- */
-import { CommandExecutionError } from '@jackwener/opencli/errors';
-import { PAGE_RUNTIME } from './page-runtime.js';
-import { gotoWritePage } from './publish.js';
-
-/**
- * 拼出登录检测的单次 evaluate 源码。
- * @param {string} checkAuthFnSource
- * @returns {string}
- */
-export function buildCheckAuthJs(checkAuthFnSource) {
-    return (
-        '(async () => {\n' +
-        PAGE_RUNTIME + '\n' +
-        'const __checkAuth = (' + checkAuthFnSource + ');\n' +
-        'try {\n' +
-        '  const r = await __checkAuth(PP);\n' +
-        '  return {\n' +
-        '    isAuthenticated: !!(r && r.isAuthenticated),\n' +
-        '    userId: (r && r.userId != null) ? String(r.userId) : "",\n' +
-        '    username: (r && r.username) || "",\n' +
-        '    avatar: (r && r.avatar) || "",\n' +
-        '    error: (r && r.error) || "",\n' +
-        '  };\n' +
-        '} catch (e) {\n' +
-        '  return { isAuthenticated: false, userId: "", username: "", avatar: "", error: String((e && e.message) || e) };\n' +
-        '}\n' +
-        '})()'
-    );
+import{CommandExecutionError as Y}from"@jackwener/opencli/errors";import{PAGE_RUNTIME as Z}from"./page-runtime.js";import{gotoWritePage as $}from"./publish.js";export function buildCheckAuthJs(z){return`(async () => {
+`+Z+`
+const __checkAuth = (`+z+`);
+try {
+  const r = await __checkAuth(PP);
+  return {
+    isAuthenticated: !!(r && r.isAuthenticated),
+    userId: (r && r.userId != null) ? String(r.userId) : "",
+    username: (r && r.username) || "",
+    avatar: (r && r.avatar) || "",
+    error: (r && r.error) || "",
+  };
+} catch (e) {
+  return { isAuthenticated: false, userId: "", username: "", avatar: "", error: String((e && e.message) || e) };
 }
-
-/**
- * 在平台页面里检测登录态并取账号信息。
- *
- * @param {{ goto: Function, wait: Function, evaluate: Function }} page
- * @param {AuthProfile} profile
- * @returns {Promise<{ isAuthenticated: boolean, userId: string, username: string, avatar: string, error: string }>}
- */
-export async function checkLogin(page, profile) {
-    if (!profile || !profile.home) throw new Error('checkLogin: profile.home is required');
-    if (typeof profile.checkAuth !== 'function') throw new Error('checkLogin: profile.checkAuth must be a function');
-    // 未登录时鉴权页通常会被重定向到登录页，gotoWritePage 落不到目标源会抛错。
-    // 对「登录检测」而言这本身就是答案：到不了鉴权页 = 未登录。干净返回，别把导航异常
-    // 当成 whoami 的报错往外冒（否则用户看到的是「停在空白页」而非「未登录」）。
-    try {
-        await gotoWritePage(page, profile.home, profile.originRe);
-    } catch (e) {
-        return {
-            isAuthenticated: false, userId: '', username: '', avatar: '',
-            error: '未登录（无法进入需登录的页面，疑似被重定向到登录页）',
-        };
-    }
-    const js = buildCheckAuthJs(profile.checkAuth.toString());
-    const r = await page.evaluate(js);
-    return r || { isAuthenticated: false, userId: '', username: '', avatar: '', error: 'no result' };
-}
-
-/**
- * 发布前的登录前置：未登录直接抛 typed error。
- * @param {object} page
- * @param {AuthProfile} profile
- * @param {string} siteLabel  平台展示名（用于报错文案）
- */
-export async function requireLogin(page, profile, siteLabel) {
-    const r = await checkLogin(page, profile);
-    if (!r.isAuthenticated) {
-        throw new CommandExecutionError(
-            `未登录${siteLabel || ''}。请先在已连接 opencli 浏览器桥的 Chrome 里登录该平台。`
-            + (r.error ? `（${r.error}）` : ''),
-        );
-    }
-    return r;
-}
-
-/**
- * 构造「快速登录检测」（quickCheck）：只读 cookie、不导航，开销极小。
- *
- * 供 `auth status` 的 quick 模式用——桌面 GUI 正是靠它判断登录状态（基于 getCookies，
- * 能读到 HttpOnly，且不会驱动浏览器窗口、不和正在进行的登录抢自动化窗口）。
- * 文章平台原本只有 whoami（full probe，会导航+调接口），没有 quickCheck，于是
- * `auth status` 一律返回「quickCheck not implemented」，GUI 表现为「检测不到登录状态」。
- *
- * 命中任一登录态 cookie 即视为已登录。cookie 名必须实测确认（去掉它接口翻匿名），
- * 不能凭记忆猜。
- *
- * @param {string} url        读 cookie 的目标 URL（决定带哪些域的 cookie）
- * @param {string[]} names     登录态 cookie 名（精确匹配，命中任一且有值即已登录）
- * @param {string[]} [prefixes] 登录态 cookie 名前缀（如 WordPress 的
- *   `wordpress_logged_in_<hash>`，hash 随站固定，只能按前缀匹配）
- * @returns {(page: { getCookies: Function }) => Promise<{ logged_in: boolean }>}
- */
-export function cookieQuickCheck(url, names, prefixes = []) {
-    const want = new Set(names);
-    return async (page) => {
-        const cookies = await page.getCookies({ url });
-        const logged_in = cookies.some(
-            (c) => c.value && (want.has(c.name) || prefixes.some((p) => c.name.startsWith(p))),
-        );
-        return { logged_in };
-    };
-}
-
-export const __test__ = {
-    buildCheckAuthJs,
-    checkLogin,
-    requireLogin,
-    cookieQuickCheck,
-};
+})()`}export async function checkLogin(z,v){if(!v||!v.home)throw Error("checkLogin: profile.home is required");if(typeof v.checkAuth!=="function")throw Error("checkLogin: profile.checkAuth must be a function");try{await $(z,v.home,v.originRe)}catch(V){return{isAuthenticated:!1,userId:"",username:"",avatar:"",error:"未登录（无法进入需登录的页面，疑似被重定向到登录页）"}}const D=buildCheckAuthJs(v.checkAuth.toString());return await z.evaluate(D)||{isAuthenticated:!1,userId:"",username:"",avatar:"",error:"no result"}}export async function requireLogin(z,v,D){const B=await checkLogin(z,v);if(!B.isAuthenticated)throw new Y(`未登录${D||""}。请先在已连接 opencli 浏览器桥的 Chrome 里登录该平台。`+(B.error?`（${B.error}）`:""));return B}export function cookieQuickCheck(z,v,D=[]){const B=new Set(v);return async(V)=>{return{logged_in:(await V.getCookies({url:z})).some((K)=>K.value&&(B.has(K.name)||D.some((X)=>K.name.startsWith(X))))}}}export const __test__={buildCheckAuthJs,checkLogin,requireLogin,cookieQuickCheck};

package/clis/_shared/article/douban-md2draft.js

@@ -1,110 +1,4 @@
-/**
- * Markdown → Draft.js 转换（豆瓣专用）
- *
- * 直接移植自 Wechatsync v2 packages/core/src/lib/markdown-to-draft.ts（开源实现，
- * 基于 markdown-draft-js + remarkable），只做 TS→JS 去类型化。豆瓣新版「日记/note」
- * 编辑器（/topic/create）正文仍是 Draft.js ContentState，故此转换器照样适用。
- *
- * 图片：转换阶段先产出占位 IMAGE 实体（data.url = 外链原图），真正的转存（上传到豆瓣
- * 图床、回填 photo 数据 + image_ids）在页面内 evaluate 里完成。两种调用方式都支持：
- * 传入 imageDataMap 则直接填完整 photo 数据；不传则留外链占位，供页面内回填。
- */
-
-// markdown-draft-js 无类型定义
-import { markdownToDraft as mdToDraft } from 'markdown-draft-js';
-import { Remarkable } from 'remarkable';
-
-const ImageRegexp = /^!\[([^\]]*)]\s*\(([^)"]+)( "([^)"]+)")?\)/;
-
-/**
- * 豆瓣图片 Block 解析器 —— 把单独成行的 ![](url) 提升为块级 image token。
- * @param {Remarkable} remarkable
- */
-const imageBlockPlugin = (remarkable) => {
-    remarkable.block.ruler.before('paragraph', 'image', (state, startLine, _endLine, silent) => {
-        const pos = state.bMarks[startLine] + state.tShift[startLine];
-        const max = state.eMarks[startLine];
-
-        if (pos >= max) return false;
-        if (!state.src) return false;
-        if (state.src[pos] !== '!') return false;
-
-        const match = ImageRegexp.exec(state.src.slice(pos));
-        if (!match) return false;
-
-        if (!silent) {
-            state.tokens.push({ type: 'image_open', src: match[2], alt: match[1], lines: [startLine, state.line], level: state.level });
-            state.tokens.push({ type: 'image_close', level: state.level });
-        }
-
-        state.line = startLine + 1;
-        return true;
-    });
-};
-
-/**
- * 将 Markdown 转换为 Draft.js ContentState 对象。
- * @param {string} markdown
- * @param {Map<string, object>} [imageDataMap]  图片 URL → 完整 photo 数据（可选）
- * @returns {{ blocks: Array<object>, entityMap: Record<string, object> }}
- */
-export function markdownToDraftState(markdown, imageDataMap = new Map()) {
-    // 保证图片单独成行（![]( 前插换行），否则会被并进段落
-    const processedMarkdown = markdown.split('\n').map((line) => {
-        const imageBlocks = line.split('![]');
-        return imageBlocks.length > 1 ? imageBlocks.join('\n![]') : line;
-    }).join('\n');
-
-    let keyCounter = 0;
-    const generateUniqueKey = () => keyCounter++;
-
-    const buildImageData = (item) => {
-        const sourcePair = item.src ? item.src.split('?#') : ['', ''];
-        const rawSrc = sourcePair[0];
-        const sourceId = sourcePair[1] || '';
-        const imgData = imageDataMap.get(item.src) || imageDataMap.get(rawSrc);
-        if (imgData) {
-            return {
-                id: imgData.id, src: imgData.url, thumb: imgData.thumb, url: imgData.url,
-                width: imgData.width, height: imgData.height, file_name: imgData.file_name, file_size: imgData.file_size,
-            };
-        }
-        // 占位：data.url = 外链原图，供页面内转存后回填
-        return { id: sourceId, src: rawSrc, thumb: rawSrc, url: rawSrc };
-    };
-
-    const draftState = mdToDraft(processedMarkdown, {
-        remarkablePlugins: [imageBlockPlugin],
-        blockTypes: {
-            image_open: function (item) {
-                const key = generateUniqueKey();
-                const blockEntities = {};
-                blockEntities[key] = { type: 'IMAGE', mutability: 'IMMUTABLE', data: buildImageData(item) };
-                return {
-                    type: 'atomic',
-                    blockEntities,
-                    inlineStyleRanges: [],
-                    entityRanges: [{ offset: 0, length: 1, key }],
-                    text: ' ',
-                };
-            },
-        },
-        blockEntities: {
-            image: function (item) {
-                return { type: 'IMAGE', mutability: 'IMMUTABLE', data: buildImageData(item) };
-            },
-        },
-    });
-
-    // 把 block.blockEntities 合并进顶层 entityMap（参考 mtd.js）
-    if (draftState.blocks) {
-        for (const block of draftState.blocks) {
-            if (block.blockEntities) {
-                Object.assign(draftState.entityMap, block.blockEntities);
-                delete block.blockEntities;
-            }
-        }
-    }
-
-    return draftState;
-}
+import{markdownToDraft as X}from"markdown-draft-js";import{Remarkable as q}from"remarkable";const Y=/^!\[([^\]]*)]\s*\(([^)"]+)( "([^)"]+)")?\)/,Z=(O)=>{O.block.ruler.before("paragraph","image",(z,G,V,Q)=>{const J=z.bMarks[G]+z.tShift[G],N=z.eMarks[G];if(J>=N)return!1;if(!z.src)return!1;if(z.src[J]!=="!")return!1;const v=Y.exec(z.src.slice(J));if(!v)return!1;if(!Q){z.tokens.push({type:"image_open",src:v[2],alt:v[1],lines:[G,z.line],level:z.level});z.tokens.push({type:"image_close",level:z.level})}z.line=G+1;return!0})};export function markdownToDraftState(O,z=new Map){const G=O.split(`
+`).map((v)=>{const F=v.split("![]");return F.length>1?F.join(`
+![]`):v}).join(`
+`);let V=0;const Q=()=>V++,J=(v)=>{const F=v.src?v.src.split("?#"):["",""],H=F[0],W=F[1]||"",A=z.get(v.src)||z.get(H);if(A)return{id:A.id,src:A.url,thumb:A.thumb,url:A.url,width:A.width,height:A.height,file_name:A.file_name,file_size:A.file_size};return{id:W,src:H,thumb:H,url:H}},N=X(G,{remarkablePlugins:[Z],blockTypes:{image_open:function(v){const F=Q(),H={};H[F]={type:"IMAGE",mutability:"IMMUTABLE",data:J(v)};return{type:"atomic",blockEntities:H,inlineStyleRanges:[],entityRanges:[{offset:0,length:1,key:F}],text:" "}}},blockEntities:{image:function(v){return{type:"IMAGE",mutability:"IMMUTABLE",data:J(v)}}}});if(N.blocks){for(const v of N.blocks)if(v.blockEntities){Object.assign(N.entityMap,v.blockEntities);delete v.blockEntities}}return N}

package/clis/_shared/article/format.js

@@ -1,71 +1 @@
-/**
- * 文章格式转换 / 归一（共享基础设施）
- *
- * 思路参照 Wechatsync：一篇文章同时带 `markdown`（主）与 `html`，每个平台按自己的
- * 支持度挑用——原生吃 Markdown 的平台（掘金 / CSDN 等）直接发 markdown，只吃 HTML 的
- * 平台（知乎 / 微信等）发 html。AI 交进来的内容多半是 Markdown，所以这里负责把输入
- * 归一成 `{ markdown, html }` 两份，转换用成熟库 markdown-it（不手写造轮子）。
- *
- * 不同平台对 Markdown 的支持本就参差，所以「转还是不转」交给平台 profile 的
- * outputFormat 决定，这里只保证两份内容都备好。
- */
-import MarkdownIt from 'markdown-it';
-
-// html:true 允许 Markdown 里内嵌原始 HTML；linkify 自动识别裸链接；表格/删除线默认开。
-const md = new MarkdownIt({
-    html: true,
-    linkify: true,
-    breaks: false,
-});
-
-/**
- * Markdown → HTML。
- * @param {string} input Markdown 文本
- * @returns {string} HTML
- */
-export function markdownToHtml(input) {
-    if (typeof input !== 'string' || !input.trim()) return '';
-    return md.render(input).trim();
-}
-
-// 粗略判断一段文本「看起来是 HTML 还是 Markdown」。
-// 依据：出现块级/常见 HTML 标签的开合标签。Markdown 极少出现成对闭合标签，足够区分日常输入。
-const HTML_SIGNAL_RE =
-    /<\/(?:p|div|h[1-6]|ul|ol|li|table|tr|td|figure|section|article|span|strong|em|pre|code|blockquote)\s*>|<(?:p|div|h[1-6]|ul|ol|li|table|figure|section|article|img|br|hr)\b[^>]*>/i;
-
-/**
- * 输入大概率是 HTML 吗？纯启发式，仅用于「未显式指定格式」时兜底。
- * @param {string} s
- * @returns {boolean}
- */
-export function looksLikeHtml(s) {
-    if (typeof s !== 'string') return false;
-    return HTML_SIGNAL_RE.test(s);
-}
-
-/**
- * 把输入归一成 { format, markdown, html } 两份内容。
- *
- * @param {string} input 文章正文（Markdown 或 HTML）
- * @param {{ format?: 'markdown' | 'html' | 'auto' }} [opts]
- *   format: 显式指定输入格式；'auto'（默认）时用 looksLikeHtml 兜底判别。
- * @returns {{ format: 'markdown' | 'html', markdown: string, html: string }}
- */
-export function normalizeContent(input, opts = {}) {
-    const raw = typeof input === 'string' ? input : '';
-    const want = opts.format || 'auto';
-    const isHtml = want === 'html' || (want === 'auto' && looksLikeHtml(raw));
-
-    if (isHtml) {
-        // HTML 来源：html 直接用；markdown 字段退化为原文（MD-native 平台通常也能吃内嵌 HTML）。
-        return { format: 'html', markdown: raw, html: raw };
-    }
-    // Markdown 来源：两份都备好。
-    return { format: 'markdown', markdown: raw, html: markdownToHtml(raw) };
-}
-
-export const __test__ = {
-    markdownToHtml,
-    looksLikeHtml,
-    normalizeContent,
-};
+import h from"markdown-it";const j=new h({html:!0,linkify:!0,breaks:!1});export function markdownToHtml(b){if(typeof b!=="string"||!b.trim())return"";return j.render(b).trim()}const q=/<\/(?:p|div|h[1-6]|ul|ol|li|table|tr|td|figure|section|article|span|strong|em|pre|code|blockquote)\s*>|<(?:p|div|h[1-6]|ul|ol|li|table|figure|section|article|img|br|hr)\b[^>]*>/i;export function looksLikeHtml(b){if(typeof b!=="string")return!1;return q.test(b)}export function normalizeContent(b,g={}){const c=typeof b==="string"?b:"",f=g.format||"auto";if(f==="html"||f==="auto"&&looksLikeHtml(c))return{format:"html",markdown:c,html:c};return{format:"markdown",markdown:c,html:markdownToHtml(c)}}export const __test__={markdownToHtml,looksLikeHtml,normalizeContent};

package/clis/_shared/article/images.js

@@ -1,82 +1,4 @@
-/**
- * 文章图片转存（共享基础设施）
- *
- * 背景：把一篇文章发到某个平台时，正文里的图片几乎都指向「别处」（原站 CDN、图床、
- * data URI）。平台编辑器不允许外链热链，所以必须把每张图重新「转存」到该平台自己的
- * 图床，再把正文里的 src 换成平台返回的新地址——否则发出去的文章图全裂。这一步过去
- * 要 AI 自己摸索几十步，是最容易被忽略、又最影响成片率的坑。
- *
- * 这里把「转存」抽象成一条声明式流水线：
- *   - 扫描正文里所有图片引用（HTML <img> 与 Markdown ![]()）；
- *   - 跳过「已经在本平台」的图（skip 域名）和上传失败的图；
- *   - 对其余每张图，按平台声明的 `spec` 调一次上传接口，拿到新 URL；
- *   - 把正文里的旧 src 原地换成新 URL（保留 alt/属性不动）。
- *
- * 关键：真正的上传 fetch 必须跑在**平台页面上下文**里（带着用户登录 cookie、Origin/
- * Referer 自动正确），所以核心逻辑被编译成一段在 `page.evaluate` 里执行的脚本。
- * 接一个平台 = 写一份 `spec`，不用各写各的上传管道。
- *
- * 上传策略由 `spec.bodyType` 决定：
- *   - 'form'：表单提交。最省事的「传 URL」式——把远程图片 URL 交给平台，平台服务端
- *     自己去拉取转存（如知乎 /api/uploaded_images）。无需下载字节。
- *   - 'json'：同上，但 JSON body。
- *   - 'binary-multipart'：页面内先 fetch 拿到图片字节，再以 multipart 上传（用于没有
- *     「传 URL」接口、或处理 data URI 的平台）。
- *
- * `spec` 字段：
- *   url           上传接口地址，可含占位符 {src}
- *   method        默认 POST
- *   bodyType      'form' | 'json' | 'binary-multipart'，默认 'form'
- *   body          请求体模板（对象），值里的 '{src}' 会被替换成当前图片地址
- *   headers       附加请求头
- *   xsrf          true 时自动从 _xsrf cookie 注入 x-xsrftoken（知乎等需要）
- *   responsePath  从 JSON 响应里取新 URL 的路径，如 'src' 或 'data.url'
- *   fileField     binary-multipart 时图片字段名，默认 'file'
- *   fileName      binary-multipart 时文件名，默认 'image'
- *   throttleMs    每张图之间的间隔毫秒，默认 250
- */
-
-const HTML_IMG_RE = /<img\b[^>]*?\ssrc=("|')(.*?)\1[^>]*>/gi;
-// Markdown 图片：![alt](url "title")。只取 url 部分，title/尺寸后缀忽略。
-const MD_IMG_RE = /!\[[^\]]*\]\(\s*<?([^)\s>]+)>?[^)]*\)/g;
-
-/**
- * 从正文里抽取所有图片引用。返回 [{ full, src }]，full 是原始匹配片段，
- * 替换时用 full.replace(src, newUrl) 原地换 URL，保留其余属性。
- * 纯函数，可在 Node 直接测。
- */
-export function extractImageRefs(content) {
-    const refs = [];
-    if (typeof content !== 'string' || !content) return refs;
-    let m;
-    HTML_IMG_RE.lastIndex = 0;
-    while ((m = HTML_IMG_RE.exec(content)) !== null) {
-        refs.push({ full: m[0], src: m[2] });
-    }
-    MD_IMG_RE.lastIndex = 0;
-    while ((m = MD_IMG_RE.exec(content)) !== null) {
-        refs.push({ full: m[0], src: m[1] });
-    }
-    return refs;
-}
-
-/**
- * 从对象里按 'a.b.c' 路径取值。纯函数。
- */
-export function pickPath(obj, path) {
-    if (obj == null) return undefined;
-    const parts = String(path || '').split('.').filter(Boolean);
-    let cur = obj;
-    for (const p of parts) {
-        if (cur == null) return undefined;
-        cur = cur[p];
-    }
-    return cur;
-}
-
-// 在页面上下文里执行的转存脚本主体（无 ${} / 无反引号，便于以模板字符串包裹注入）。
-// 依赖注入的三个常量：content、spec、skip。
-const IN_PAGE_BODY = `
+import{readFile as S}from"node:fs/promises";import{fileURLToPath as j}from"node:url";const N=/<img\b[^>]*?\ssrc=("|')(.*?)\1[^>]*>/gi,O=/!\[[^\]]*\]\(\s*<?([^)\s>]+)>?[^)]*\)/g;export function extractImageRefs(q){const v=[];if(typeof q!=="string"||!q)return v;let w;N.lastIndex=0;while((w=N.exec(q))!==null)v.push({full:w[0],src:w[2]});O.lastIndex=0;while((w=O.exec(q))!==null)v.push({full:w[0],src:w[1]});return v}export function pickPath(q,v){if(q==null)return;const w=String(v||"").split(".").filter(Boolean);let z=q;for(const C of w){if(z==null)return;z=z[C]}return z}const k=`
   const htmlRe = /<img\\b[^>]*?\\ssrc=("|')(.*?)\\1[^>]*>/gi;
   const mdRe = /!\\[[^\\]]*\\]\\(\\s*<?([^)\\s>]+)>?[^)]*\\)/g;
   const refs = [];
@@ -165,49 +87,9 @@ const IN_PAGE_BODY = `
   }
 
   return { content: out, uploaded: uploaded, failed: failed };
-`;
-
-/**
- * 构造在 page.evaluate 里执行的转存脚本（async IIFE 字符串）。
- * content / spec / skip 以 JSON 注入，避免任何转义/注入问题。
- */
-export function buildTransferImagesJs(content, spec, skip) {
-    return (
-        '(async () => {\n' +
-        'const content = ' + JSON.stringify(content) + ';\n' +
-        'const spec = ' + JSON.stringify(spec || {}) + ';\n' +
-        'const skip = ' + JSON.stringify(skip || []) + ';\n' +
-        IN_PAGE_BODY +
-        '\n})()'
-    );
-}
-
-/**
- * 在平台页面里把正文图片全部转存到本平台图床，返回改写后的正文 + 转存报告。
- * 调用前 page 必须已经导航到该平台的写作 origin（cookie / Origin 才正确）。
- *
- * @param {{ evaluate: (js: string) => Promise<any> }} page  opencli 的 page 句柄
- * @param {string} content  文章正文（HTML 或 Markdown）
- * @param {{ spec: object, skip?: string[] }} options  平台上传声明
- * @returns {Promise<{ content: string, uploaded: Array, failed: Array }>}
- */
-export async function transferImages(page, content, options = {}) {
-    const { spec, skip = [] } = options;
-    if (!spec || !spec.url) {
-        // 没声明上传 spec：原样返回，不报错（有些平台正文不带图）。
-        return { content, uploaded: [], failed: [] };
-    }
-    if (extractImageRefs(content).length === 0) {
-        return { content, uploaded: [], failed: [] };
-    }
-    const result = await page.evaluate(buildTransferImagesJs(content, spec, skip));
-    return result || { content, uploaded: [], failed: [] };
-}
-
-export const __test__ = {
-    extractImageRefs,
-    pickPath,
-    buildTransferImagesJs,
-    HTML_IMG_RE,
-    MD_IMG_RE,
-};
+`;export function buildTransferImagesJs(q,v,w){return`(async () => {
+const content = `+JSON.stringify(q)+`;
+const spec = `+JSON.stringify(v||{})+`;
+const skip = `+JSON.stringify(w||[])+`;
+`+k+`
+})()`}const U={png:"image/png",jpg:"image/jpeg",jpeg:"image/jpeg",gif:"image/gif",webp:"image/webp",svg:"image/svg+xml",bmp:"image/bmp",ico:"image/x-icon",avif:"image/avif",tif:"image/tiff",tiff:"image/tiff"};export function isLocalImagePath(q){if(typeof q!=="string"||!q)return!1;if(q.startsWith("file://"))return!0;if(/^[a-zA-Z]:[\\/]/.test(q))return!0;if(q.startsWith("//"))return!1;if(/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(q))return!1;if(q.startsWith("/"))return!0;return!1}function X(q){if(q.startsWith("file://"))try{return j(q)}catch{return q.slice(7)}return q}export async function localImageToDataUri(q,v={}){const w=v.readFile||S,z=X(q),C=await w(z),Z=C.byteLength!=null?C.byteLength:C.length,Q=(z.split(/[\\/]/).pop().split(".").pop()||"").toLowerCase().split("?")[0],V=U[Q]||"image/png";return{dataUri:`data:${V};base64,${Buffer.from(C).toString("base64")}`,bytes:Z,mime:V}}export async function inlineLocalImages(q,v={}){const w=v.readFile||S,z=[],C=[];if(typeof q!=="string"||!q)return{content:q||"",inlined:z,missing:C};const Z=extractImageRefs(q),Q={};let V=q;for(const A of Z){const K=A.src;if(!isLocalImagePath(K))continue;if(!(K in Q))try{const W=X(K),$=await w(W),B=$.byteLength!=null?$.byteLength:$.length,H=(W.split(/[\\/]/).pop().split(".").pop()||"").toLowerCase().split("?")[0],J=U[H]||"image/png",Y=Buffer.from($).toString("base64");Q[K]=`data:${J};base64,${Y}`;z.push({src:K,bytes:B,mime:J})}catch(W){Q[K]=null;C.push({src:K,error:String(W&&W.message||W)})}const y=Q[K];if(y)V=V.split(A.full).join(A.full.replace(K,y))}return{content:V,inlined:z,missing:C}}export async function transferImages(q,v,w={}){const{spec:z,skip:C=[]}=w;if(!z||!z.url)return{content:v,uploaded:[],failed:[]};if(extractImageRefs(v).length===0)return{content:v,uploaded:[],failed:[]};return await q.evaluate(buildTransferImagesJs(v,z,C))||{content:v,uploaded:[],failed:[]}}export const __test__={extractImageRefs,pickPath,buildTransferImagesJs,isLocalImagePath,inlineLocalImages,localImageToDataUri,HTML_IMG_RE:N,MD_IMG_RE:O};

package/clis/_shared/article/login.js

@@ -1,90 +1 @@
-import { cli, Strategy } from '@jackwener/opencli/registry';
-import { TimeoutError } from '@jackwener/opencli/errors';
-import { checkLogin } from './auth.js';
-
-// ── 文章平台「login」命令共享注册器 ──────────────────────────────────────────
-// 走文章共享基建（profile + whoami.js）的平台（juejin / csdn / oschina …）已自带
-// whoami（进 `auth status`），但没有 `login` 命令——桌面客户端的「登录」按钮靠
-// `opencli <site> login --window foreground` 开登录窗口，缺了它绿点永远不亮。
-//
-// 这里只注册 `login` 一个命令（不碰各站已有的 whoami，避免重复注册）。登录态判定
-// 复用 profile.checkAuth（与 whoami 同源），打开登录页让用户手动完成登录后轮询。
-//
-// 注意：与 site-auth.js 的 registerSiteAuthCommands 互补——后者同时注册 whoami+login，
-// 适用于「auth.js 一把梭」的平台（zhihu/douban/xueqiu）；本注册器适用于「whoami.js +
-// 文章 profile」的平台，只补 login。两者别同时用在一个站点上。
-
-const DEFAULT_TIMEOUT_SECONDS = 300;
-const POLL_INTERVAL_MS = 3000;
-
-/**
- * 给走文章共享基建的平台注册一个 `login` 命令。
- *
- * @param {object} config
- * @param {string} config.site                 站点 id（如 'juejin'）
- * @param {string} config.domain               主域名（如 'juejin.cn'）
- * @param {{ home: string, checkAuth: Function, originRe?: RegExp }} config.profile
- *        与 whoami 同源的 article profile（必须含 home + checkAuth）
- * @param {string} [config.loginUrl]           登录页地址（默认用 profile.home，未登录通常会被重定向到登录页）
- * @param {string} [config.loginDescription]   命令描述覆盖
- */
-export function registerArticleLogin(config) {
-    if (!config?.site || !config?.domain || !config?.profile || typeof config.profile.checkAuth !== 'function') {
-        throw new Error('registerArticleLogin 需要 site、domain 和 profile.checkAuth');
-    }
-    const loginUrl = config.loginUrl ?? config.profile.home;
-
-    cli({
-        site: config.site,
-        name: 'login',
-        access: 'write',
-        description: config.loginDescription ?? `打开${config.site}登录页并等待浏览器会话完成登录`,
-        domain: config.domain,
-        strategy: Strategy.COOKIE,
-        browser: true,
-        navigateBefore: false,
-        defaultWindowMode: 'foreground',
-        siteSession: 'persistent',
-        args: [
-            { name: 'timeout', type: 'int', default: DEFAULT_TIMEOUT_SECONDS, help: '等待用户完成登录的最长秒数' },
-        ],
-        columns: ['status', 'logged_in', 'user_id', 'username'],
-        func: async (page, kwargs) => {
-            // 已登录直接返回（checkLogin 内部会导航到 home 并探鉴权）。
-            const first = await checkLogin(page, config.profile);
-            if (first.isAuthenticated) {
-                return {
-                    status: 'already_logged_in',
-                    logged_in: true,
-                    user_id: first.userId || '',
-                    username: first.username || '',
-                };
-            }
-
-            // 未登录：打开登录页，让用户手动完成登录，再轮询登录态。
-            await page.goto(loginUrl);
-            const timeoutSeconds = Number(kwargs.timeout ?? DEFAULT_TIMEOUT_SECONDS);
-            const deadline = Date.now() + timeoutSeconds * 1000;
-
-            while (Date.now() < deadline) {
-                const remainMs = deadline - Date.now();
-                await page.wait(Math.min(POLL_INTERVAL_MS / 1000, Math.max(0.2, remainMs / 1000)));
-                const r = await checkLogin(page, config.profile);
-                if (r.isAuthenticated) {
-                    return {
-                        status: 'login_complete',
-                        logged_in: true,
-                        user_id: r.userId || '',
-                        username: r.username || '',
-                    };
-                }
-            }
-
-            throw new TimeoutError(
-                `${config.site} login`,
-                timeoutSeconds,
-                `请在打开的窗口里完成${config.site}登录后重试。`,
-            );
-        },
-    });
-}
+import{cli as Z,Strategy as $}from"@jackwener/opencli/registry";import{TimeoutError as P}from"@jackwener/opencli/errors";import{checkLogin as H}from"./auth.js";const J=300,R=3000;async function K(b){if(typeof b?.closeWindow==="function")try{await b.closeWindow()}catch{}}export function registerArticleLogin(b){if(!b?.site||!b?.domain||!b?.profile||typeof b.profile.checkAuth!=="function")throw Error("registerArticleLogin 需要 site、domain 和 profile.checkAuth");const Q=b.loginUrl??b.profile.home;Z({site:b.site,name:"login",access:"write",description:b.loginDescription??`打开${b.site}登录页并等待浏览器会话完成登录`,domain:b.domain,strategy:$.COOKIE,browser:!0,navigateBefore:!1,defaultWindowMode:"foreground",siteSession:"persistent",args:[{name:"timeout",type:"int",default:J,help:"等待用户完成登录的最长秒数"}],columns:["status","logged_in","user_id","username"],func:async(q,X)=>{const v=await H(q,b.profile);if(v.isAuthenticated){const x={status:"already_logged_in",logged_in:!0,user_id:v.userId||"",username:v.username||""};await K(q);return x}await q.goto(Q);const B=Number(X.timeout??J),G=Date.now()+B*1000;while(Date.now()<G){const x=G-Date.now();await q.wait(Math.min(R/1000,Math.max(0.2,x/1000)));const z=await H(q,b.profile);if(z.isAuthenticated){const Y={status:"login_complete",logged_in:!0,user_id:z.userId||"",username:z.username||""};await K(q);return Y}}throw new P(`${b.site} login`,B,`请在打开的窗口里完成${b.site}登录后重试。`)}})}