@zhin.js/adapter-juejin 0.0.0-stage → 0.1.1

package/lib/client.js

@@ -0,0 +1,192 @@
+/**
+ * 掘金 Web API client（非官方接口，Experimental）。
+ * 读：白名单文章的最新评论（`interact_api/v1/comment/list`）、登录账号（`user_api/v1/user/get`）；
+ * 写：`replyComment`（`interact_api/v1/reply/publish`），只在人工审批草稿后由 endpoint 调用。
+ * 永远不要记录 Cookie。
+ */
+import { JUEJIN_ARTICLE_ITEM_TYPE, JUEJIN_CLIENT_TYPE, JUEJIN_COMMENT_PAGE_SIZE, JUEJIN_LOGIN_REQUIRED_CODE, JUEJIN_NON_JSON_CODE, JUEJIN_RISK_HTTP_STATUSES, JUEJIN_RISK_MESSAGE, isJuejinId, } from './protocol.js';
+const REQUEST_TIMEOUT_MS = 15_000;
+const USER_AGENT = 'Mozilla/5.0 (zhin.js adapter-juejin; experimental)';
+const WEB_ORIGIN = 'https://juejin.cn';
+/**
+ * 平台返回非 0 `err_no`、非 2xx 或非 JSON。`risk` 为 true 时调用方必须熔断；
+ * `ambiguous` 为 true 表示写请求结果未知（可能已经发出），不能当成「没发」重试。
+ */
+export class JuejinApiError extends Error {
+    code;
+    risk;
+    ambiguous;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.code = code;
+        this.name = 'JuejinApiError';
+        this.httpStatus = options.httpStatus;
+        this.ambiguous = options.ambiguous === true;
+        this.risk = (options.httpStatus !== undefined && JUEJIN_RISK_HTTP_STATUSES.has(options.httpStatus))
+            || code === JUEJIN_NON_JSON_CODE || JUEJIN_RISK_MESSAGE.test(message);
+    }
+    httpStatus;
+    /** 平台判定未登录 / Cookie 失效。 */
+    get loginRequired() {
+        return this.code === JUEJIN_LOGIN_REQUIRED_CODE && this.httpStatus === undefined;
+    }
+}
+export class JuejinClient {
+    config;
+    #cookie;
+    fetch;
+    constructor(config, fetch, signal) {
+        this.config = config;
+        this.fetch = bindJuejinFetch(fetch, signal);
+        this.#cookie = config.cookie;
+    }
+    get hasCookie() {
+        return Boolean(this.#cookie);
+    }
+    /** 切换 Cookie（传 undefined 清空）。 */
+    setCookie(cookie) {
+        this.#cookie = cookie || undefined;
+    }
+    #headers(json) {
+        return {
+            'User-Agent': USER_AGENT,
+            Accept: 'application/json, text/plain, */*',
+            Referer: `${WEB_ORIGIN}/`,
+            Origin: WEB_ORIGIN,
+            ...(this.#cookie ? { Cookie: this.#cookie } : {}),
+            ...(json ? { 'Content-Type': 'application/json' } : {}),
+        };
+    }
+    /**
+     * 发请求并解出 `{ err_no, err_msg, data }` 信封。`write` 为 true 时，拿不到可解析的结果
+     * （网络中断、超时、空响应、非 JSON）都按「结果未知」抛出 `ambiguous` 错误。
+     */
+    async request(path, init = {}) {
+        const separator = path.includes('?') ? '&' : '?';
+        const url = `${this.config.apiBaseUrl}${path}${separator}aid=${JUEJIN_CLIENT_TYPE}`;
+        const write = init.write === true;
+        let response;
+        try {
+            response = await this.fetch(url, {
+                method: init.method ?? 'GET',
+                headers: this.#headers(init.body !== undefined),
+                ...(init.body === undefined ? {} : { body: JSON.stringify(init.body) }),
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+        }
+        catch (error) {
+            if (!write)
+                throw error;
+            throw new JuejinApiError(-1, `Juejin request outcome unknown: ${error instanceof Error ? error.message : String(error)}`, { ambiguous: true });
+        }
+        if (!response.ok) {
+            throw new JuejinApiError(-response.status, `Juejin HTTP ${response.status}`, { httpStatus: response.status });
+        }
+        const raw = await response.text().catch((error) => {
+            if (write)
+                throw new JuejinApiError(-1, 'Juejin response body was lost', { ambiguous: true });
+            throw error;
+        });
+        if (!raw.trim()) {
+            throw new JuejinApiError(-1, 'Juejin returned an empty response', { ambiguous: write });
+        }
+        let envelope;
+        try {
+            envelope = JSON.parse(raw);
+        }
+        catch {
+            // 非 JSON：多半被拦到验证页 / 登录页。写请求结果未知；同时当成风控熔断。
+            throw new JuejinApiError(JUEJIN_NON_JSON_CODE, 'Juejin returned a non-JSON response (possible verification page)', { ambiguous: write });
+        }
+        if (typeof envelope?.err_no !== 'number')
+            throw new JuejinApiError(-1, 'Malformed Juejin response', { ambiguous: write });
+        if (envelope.err_no !== 0) {
+            throw new JuejinApiError(envelope.err_no, `Juejin API ${envelope.err_no}: ${envelope.err_msg ?? ''}`.trim());
+        }
+        return envelope;
+    }
+    /** 登录态自检：当前账号（未登录 / Cookie 失效返回 undefined）。掘金未登录时返回 `data: null` 或 `err_no: 403`。 */
+    async getSelf() {
+        if (!this.hasCookie)
+            return undefined;
+        let envelope;
+        try {
+            envelope = await this.request('/user_api/v1/user/get');
+        }
+        catch (error) {
+            if (error instanceof JuejinApiError && error.loginRequired)
+                return undefined;
+            throw error;
+        }
+        const data = envelope.data;
+        if (!data || !isJuejinId(data.user_id))
+            return undefined;
+        return Object.freeze({
+            userId: data.user_id,
+            ...(typeof data.user_name === 'string' && data.user_name ? { userName: data.user_name } : {}),
+            ...(typeof data.avatar_large === 'string' && data.avatar_large ? { avatar: data.avatar_large } : {}),
+        });
+    }
+    /** 读取文章评论第一页（`sort=0` 最新在前），一级评论带内联的前几条回复。公开接口，不需要 Cookie。 */
+    async listLatestComments(articleId, limit = JUEJIN_COMMENT_PAGE_SIZE) {
+        const envelope = await this.request('/interact_api/v1/comment/list', {
+            method: 'POST',
+            body: {
+                item_id: articleId,
+                item_type: JUEJIN_ARTICLE_ITEM_TYPE,
+                cursor: '0',
+                limit,
+                sort: 0,
+                client_type: JUEJIN_CLIENT_TYPE,
+            },
+        });
+        return Object.freeze({
+            comments: Object.freeze([...(Array.isArray(envelope.data) ? envelope.data : [])]),
+            ...(typeof envelope.count === 'number' ? { count: envelope.count } : {}),
+            ...(typeof envelope.has_more === 'boolean' ? { hasMore: envelope.has_more } : {}),
+        });
+    }
+    /**
+     * 回复评论（`POST interact_api/v1/reply/publish`）。只回复已有评论楼：`reply_to_comment_id` = 楼根，
+     * 回复楼中楼时再带 `reply_to_reply_id`。字段取自社区实现（androidZzT/juejin-mcp `browser/comment.go`）；
+     * 纯 HTTP 调用可能被掘金的反爬签名拒绝，见 docs/adapters/juejin.md「手动验证清单」。
+     *
+     * 只由 `JuejinEndpoint.approveDraft()` 在人工审批后调用；`send()` 永远不直接调用。
+     * 返回新回复 id（平台没给时为 undefined，但 `err_no: 0` 仍视为已发出）。
+     */
+    async replyComment(input) {
+        if (!this.#cookie) {
+            throw new JuejinApiError(JUEJIN_LOGIN_REQUIRED_CODE, 'Juejin cookie is required to reply');
+        }
+        const envelope = await this.request('/interact_api/v1/reply/publish', {
+            method: 'POST',
+            write: true,
+            body: {
+                client_type: JUEJIN_CLIENT_TYPE,
+                item_id: input.articleId,
+                item_type: JUEJIN_ARTICLE_ITEM_TYPE,
+                reply_content: input.message,
+                reply_pics: [],
+                reply_to_comment_id: input.root,
+                ...(input.parent !== input.root ? { reply_to_reply_id: input.parent } : {}),
+            },
+        });
+        const id = envelope.data?.reply_id ?? envelope.data?.reply_info?.reply_id;
+        return isJuejinId(id) ? id : undefined;
+    }
+}
+/** Bind the actual account incarnation without changing existing request timeouts. */
+function bindJuejinFetch(fetch, signal) {
+    if (!signal)
+        return fetch;
+    return async (url, init) => {
+        signal.throwIfAborted();
+        const response = await fetch(url, { ...init, signal: init?.signal ? AbortSignal.any([signal, init.signal]) : signal });
+        signal.throwIfAborted();
+        return { ok: response.ok, status: response.status, async text() {
+                const body = await response.text();
+                signal.throwIfAborted();
+                return body;
+            } };
+    };
+}

package/lib/console.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Console「掘金评论审批」页的插件 RPC（`plugin.<pluginId>.status` / 动作）。
+ *
+ * - 只返回页面需要的字段：登录态（不含 Cookie）、白名单文章、待审草稿。
+ * - 动作都声明了 requiredPermissions：普通用户令牌只有持有对应权限才能操作（未声明 = 仅管理员）。
+ * - 配置（白名单、sendMode、Cookie 等）不在这里改：用 YAML / 环境变量 / config:patch。
+ */
+import { type PluginConsoleRpc } from 'zhin.js';
+export declare const JUEJIN_CONSOLE_PAGE = "index";
+/** 看页面与状态。 */
+export declare const JUEJIN_READ_PERMISSION = "juejin:read";
+/** 改写 / 丢弃 / 发送草稿。 */
+export declare const JUEJIN_REVIEW_PERMISSION = "juejin:review";
+/** 重新检查登录态。 */
+export declare const JUEJIN_LOGIN_PERMISSION = "juejin:login";
+export declare function createJuejinConsoleRpc(): PluginConsoleRpc;

package/lib/console.js

@@ -0,0 +1,172 @@
+/**
+ * Console「掘金评论审批」页的插件 RPC（`plugin.<pluginId>.status` / 动作）。
+ *
+ * - 只返回页面需要的字段：登录态（不含 Cookie）、白名单文章、待审草稿。
+ * - 动作都声明了 requiredPermissions：普通用户令牌只有持有对应权限才能操作（未声明 = 仅管理员）。
+ * - 配置（白名单、sendMode、Cookie 等）不在这里改：用 YAML / 环境变量 / config:patch。
+ */
+import { definePluginConsoleRpc, PluginConsoleRpcError } from 'zhin.js';
+import { isLocale } from 'zhin.js/i18n';
+import { juejinEndpoints } from './endpoint-directory.js';
+import { JuejinReviewError } from './endpoint.js';
+import { draftArticleUrl, findDraft, reviewErrorText } from './review.js';
+export const JUEJIN_CONSOLE_PAGE = 'index';
+/** 看页面与状态。 */
+export const JUEJIN_READ_PERMISSION = 'juejin:read';
+/** 改写 / 丢弃 / 发送草稿。 */
+export const JUEJIN_REVIEW_PERMISSION = 'juejin:review';
+/** 重新检查登录态。 */
+export const JUEJIN_LOGIN_PERMISSION = 'juejin:login';
+const DRAFTS_PER_ENDPOINT = 50;
+function localeOf(input) {
+    return typeof input.locale === 'string' && isLocale(input.locale) ? input.locale : undefined;
+}
+function requireString(input, key, label) {
+    const value = input[key];
+    if (typeof value !== 'string' || !value.trim())
+        throw new PluginConsoleRpcError('invalid_input', `缺少${label}`);
+    return value.trim();
+}
+function pickEndpoint(registry, input) {
+    const id = typeof input.endpoint === 'string' ? input.endpoint.trim() : '';
+    if (id) {
+        const endpoint = registry.get(id);
+        if (!endpoint)
+            throw new PluginConsoleRpcError('not_found', `找不到账号 ${id}`);
+        return endpoint;
+    }
+    const [first, second] = registry.values();
+    if (!first)
+        throw new PluginConsoleRpcError('unavailable', '掘金适配器还没有启动');
+    if (second)
+        throw new PluginConsoleRpcError('invalid_input', '有多个账号，请先选择一个');
+    return first;
+}
+function reviewFailure(id, error, locale) {
+    if (error instanceof PluginConsoleRpcError)
+        throw error;
+    const message = reviewErrorText(id, error, locale);
+    if (error instanceof JuejinReviewError) {
+        const code = error.code === 'not_found' ? 'not_found'
+            : error.code === 'busy' || error.code === 'rate_limited' || error.code === 'unknown_outcome' ? 'conflict'
+                : error.code === 'invalid_message' ? 'invalid_input' : 'unavailable';
+        throw new PluginConsoleRpcError(code, message);
+    }
+    throw new PluginConsoleRpcError('unavailable', message);
+}
+function endpointView(endpoint) {
+    const login = endpoint.login;
+    const circuit = endpoint.circuitBreaker;
+    const drafts = endpoint.drafts.list().slice(-DRAFTS_PER_ENDPOINT).reverse();
+    return {
+        id: endpoint.localId,
+        sendMode: endpoint.sendMode,
+        persistent: endpoint.persistent,
+        circuit: circuit ? { code: circuit.code } : null,
+        login: {
+            state: login.state,
+            ...(login.userId ? { userId: login.userId } : {}),
+            ...(login.userName ? { userName: login.userName } : {}),
+        },
+        articles: endpoint.articles.map(article => ({ id: article.id, url: article.url })),
+        pendingCount: endpoint.drafts.size,
+        drafts: drafts.map(draft => ({
+            id: draft.id,
+            url: draftArticleUrl(draft),
+            articleId: draft.articleId,
+            message: draft.message,
+            status: draft.status ?? 'pending',
+            interrupted: draft.interrupted === true,
+            createdAt: draft.createdAt,
+            ...(draft.updatedAt ? { updatedAt: draft.updatedAt } : {}),
+            ...(draft.context ? { author: draft.context.author, original: draft.context.text } : {}),
+        })),
+    };
+}
+function scopedRegistry(operation) {
+    return (input, call) => {
+        const runtime = call.runtime;
+        if (!runtime)
+            throw new PluginConsoleRpcError('unsupported', 'Juejin Adapter directory is unavailable');
+        const directory = juejinEndpoints({ owner: runtime.owner, signal: call.signal, project: feature => runtime.project(feature) });
+        return operation(directory, input);
+    };
+}
+export function createJuejinConsoleRpc() {
+    const page = JUEJIN_CONSOLE_PAGE;
+    const review = [JUEJIN_REVIEW_PERMISSION];
+    return definePluginConsoleRpc({
+        status: {
+            page,
+            requiredPermissions: [JUEJIN_READ_PERMISSION],
+            handler: scopedRegistry((registry) => ({
+                endpoints: [...registry.values()].map(endpointView),
+                updatedAt: Date.now(),
+            })),
+        },
+        actions: {
+            send: {
+                page, requiredPermissions: review,
+                handler: scopedRegistry(async (registry, input) => {
+                    const id = requireString(input, 'id', '草稿 ID');
+                    const found = findDraft(registry, id);
+                    if (!found)
+                        throw new PluginConsoleRpcError('not_found', reviewErrorText(id, new JuejinReviewError('not_found', id), localeOf(input)));
+                    try {
+                        const { draft, replyId } = await found.endpoint.approveDraft(id);
+                        return { id, url: draftArticleUrl(draft), ...(replyId ? { replyId } : {}) };
+                    }
+                    catch (error) {
+                        return reviewFailure(id, error, localeOf(input));
+                    }
+                }),
+            },
+            edit: {
+                page, requiredPermissions: review,
+                handler: scopedRegistry(async (registry, input) => {
+                    const id = requireString(input, 'id', '草稿 ID');
+                    const message = typeof input.message === 'string' ? input.message : '';
+                    const found = findDraft(registry, id);
+                    if (!found)
+                        throw new PluginConsoleRpcError('not_found', reviewErrorText(id, new JuejinReviewError('not_found', id), localeOf(input)));
+                    try {
+                        const draft = found.endpoint.editDraft(id, message);
+                        return { id, message: draft.message };
+                    }
+                    catch (error) {
+                        return reviewFailure(id, error, localeOf(input));
+                    }
+                }),
+            },
+            drop: {
+                page, requiredPermissions: review,
+                handler: scopedRegistry(async (registry, input) => {
+                    const id = requireString(input, 'id', '草稿 ID');
+                    const found = findDraft(registry, id);
+                    if (!found)
+                        throw new PluginConsoleRpcError('not_found', reviewErrorText(id, new JuejinReviewError('not_found', id), localeOf(input)));
+                    try {
+                        return { id, dropped: found.endpoint.discardDraft(id) };
+                    }
+                    catch (error) {
+                        return reviewFailure(id, error, localeOf(input));
+                    }
+                }),
+            },
+            'login-check': {
+                page, requiredPermissions: [JUEJIN_LOGIN_PERMISSION],
+                handler: scopedRegistry(async (registry, input) => {
+                    try {
+                        const login = await pickEndpoint(registry, input).recheckLogin();
+                        return { state: login.state, ...(login.userId ? { userId: login.userId } : {}), ...(login.userName ? { userName: login.userName } : {}) };
+                    }
+                    catch (error) {
+                        if (error instanceof PluginConsoleRpcError)
+                            throw error;
+                        throw new PluginConsoleRpcError('unavailable', '检查登录失败，请稍后再试');
+                    }
+                }),
+            },
+        },
+    });
+}

package/lib/drafts.d.ts

@@ -0,0 +1,50 @@
+export type JuejinDraftStatus = 'pending' | 'sending';
+export interface JuejinReplyDraft {
+    readonly id: string;
+    /** 本地 endpoint id（配置里的 endpoints[i].id）。 */
+    readonly endpointId?: string;
+    /** 评论楼会话 id：`article:<articleId>:<rootCommentId>`。 */
+    readonly target?: string;
+    readonly articleId: string;
+    /** 评论楼根（一级评论 id）。 */
+    readonly root: string;
+    /** 直接回复的对象（等于 root = 回复一级评论）。 */
+    readonly parent: string;
+    readonly message: string;
+    /** 被回复评论的摘要（作者 + 原文），供审批时对照。 */
+    readonly context?: {
+        readonly author: string;
+        readonly text: string;
+    };
+    readonly status?: JuejinDraftStatus;
+    /** 上次发送时进程退出或结果未知；再次发送前应先到掘金确认。 */
+    readonly interrupted?: boolean;
+    readonly createdAt: number;
+    readonly updatedAt?: number;
+}
+export type JuejinDraftInput = Omit<JuejinReplyDraft, 'id' | 'createdAt' | 'status' | 'updatedAt' | 'interrupted'>;
+export interface JuejinDraftQueueOptions {
+    readonly capacity?: number;
+    /** 持久化文件；省略则只存内存。 */
+    readonly file?: string;
+    /** 持久化失败时回调（不抛出，草稿仍保留在内存）。 */
+    readonly onPersistError?: (error: unknown) => void;
+}
+export declare class JuejinDraftQueue {
+    #private;
+    readonly capacity: number;
+    constructor(options?: number | JuejinDraftQueueOptions);
+    /** 是否落盘。 */
+    get persistent(): boolean;
+    add(input: JuejinDraftInput, now?: number): JuejinReplyDraft;
+    list(): readonly JuejinReplyDraft[];
+    get(id: string): JuejinReplyDraft | undefined;
+    /**
+     * 原地替换字段（id / createdAt 不变）。草稿不存在时返回 undefined。
+     * `interrupted: true` 用于「发送结果未知」；人工改写正文会清掉这个标记。
+     */
+    update(id: string, patch: Partial<Pick<JuejinReplyDraft, 'message' | 'status' | 'interrupted'>>, now?: number): JuejinReplyDraft | undefined;
+    discard(id: string): boolean;
+    clear(): void;
+    get size(): number;
+}

package/lib/drafts.js

@@ -0,0 +1,137 @@
+/**
+ * 草稿队列（review 模式）：AI 生成的回复先停在这里，等人确认后再发。
+ *
+ * 传入 `file` 时持久化到本地 JSON（默认 `data/juejin/<endpoint>/drafts.json`，权限 0600），进程重启后自动恢复。
+ * 重启时仍处于 `sending` 的草稿结果未知（可能已经发出），恢复为 `pending` 并标记 `interrupted`，
+ * 提醒审批人先去掘金确认，避免重复发送。
+ */
+import { isJuejinId } from './protocol.js';
+import { readJson, removeFile, writeJsonAtomic } from './storage.js';
+function isDraft(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const draft = value;
+    return typeof draft.id === 'string' && /^[a-z0-9]+$/u.test(draft.id)
+        && isJuejinId(draft.articleId) && isJuejinId(draft.root) && isJuejinId(draft.parent)
+        && typeof draft.message === 'string'
+        && typeof draft.createdAt === 'number';
+}
+export class JuejinDraftQueue {
+    #drafts = new Map();
+    #file;
+    #onPersistError;
+    capacity;
+    #seq = 0;
+    constructor(options = {}) {
+        const resolved = typeof options === 'number' ? { capacity: options } : options;
+        this.capacity = Math.max(1, resolved.capacity ?? 200);
+        this.#file = resolved.file;
+        this.#onPersistError = resolved.onPersistError;
+        this.#load();
+    }
+    /** 是否落盘。 */
+    get persistent() {
+        return this.#file !== undefined;
+    }
+    #load() {
+        if (!this.#file)
+            return;
+        const raw = readJson(this.#file);
+        if (!raw || !Array.isArray(raw.drafts))
+            return;
+        if (typeof raw.seq === 'number' && Number.isFinite(raw.seq))
+            this.#seq = Math.max(0, Math.floor(raw.seq));
+        for (const entry of raw.drafts) {
+            if (!isDraft(entry))
+                continue;
+            const { context, status, interrupted, ...rest } = entry;
+            const restored = Object.freeze({
+                ...rest,
+                ...(context && typeof context.author === 'string' && typeof context.text === 'string'
+                    ? { context: Object.freeze({ author: context.author, text: context.text }) } : {}),
+                status: 'pending',
+                ...(status === 'sending' || interrupted ? { interrupted: true } : {}),
+            });
+            this.#drafts.set(restored.id, restored);
+        }
+        this.#evict();
+    }
+    #persist() {
+        if (!this.#file)
+            return;
+        try {
+            if (this.#drafts.size === 0 && this.#seq === 0) {
+                removeFile(this.#file);
+                return;
+            }
+            const data = { version: 1, seq: this.#seq, drafts: [...this.#drafts.values()] };
+            writeJsonAtomic(this.#file, data, 0o600);
+        }
+        catch (error) {
+            this.#onPersistError?.(error);
+        }
+    }
+    #evict() {
+        while (this.#drafts.size > this.capacity) {
+            let removed = false;
+            // 优先挤掉最老的 pending 草稿，不动正在发送的。
+            for (const [id, draft] of this.#drafts) {
+                if (draft.status !== 'sending') {
+                    this.#drafts.delete(id);
+                    removed = true;
+                    break;
+                }
+            }
+            if (!removed)
+                break;
+        }
+    }
+    add(input, now = Date.now()) {
+        const draft = Object.freeze({
+            ...input,
+            id: `d${(++this.#seq).toString(36)}${(now % 1296).toString(36).padStart(2, '0')}`,
+            status: 'pending',
+            createdAt: now,
+        });
+        this.#drafts.set(draft.id, draft);
+        this.#evict();
+        this.#persist();
+        return draft;
+    }
+    list() {
+        return Object.freeze([...this.#drafts.values()]);
+    }
+    get(id) {
+        return this.#drafts.get(id);
+    }
+    /**
+     * 原地替换字段（id / createdAt 不变）。草稿不存在时返回 undefined。
+     * `interrupted: true` 用于「发送结果未知」；人工改写正文会清掉这个标记。
+     */
+    update(id, patch, now = Date.now()) {
+        const current = this.#drafts.get(id);
+        if (!current)
+            return undefined;
+        const { interrupted, ...rest } = current;
+        const { interrupted: markInterrupted, ...fields } = patch;
+        // 人工改写过正文后不再提示「可能已发出」——审批人已经看过了。
+        const keepInterrupted = markInterrupted === true || (interrupted && fields.message === undefined);
+        const next = Object.freeze({ ...rest, ...fields, ...(keepInterrupted ? { interrupted: true } : {}), updatedAt: now });
+        this.#drafts.set(id, next);
+        this.#persist();
+        return next;
+    }
+    discard(id) {
+        const removed = this.#drafts.delete(id);
+        if (removed)
+            this.#persist();
+        return removed;
+    }
+    clear() {
+        this.#drafts.clear();
+        this.#persist();
+    }
+    get size() {
+        return this.#drafts.size;
+    }
+}

package/lib/endpoint-directory.d.ts

@@ -0,0 +1,16 @@
+import type { FeatureId, PluginId } from 'zhin.js';
+import type { JuejinEndpoint } from './endpoint.js';
+/** Closed review/login view; no cookie, config, fetch or mutable account directory. */
+export type JuejinEndpointView = Pick<JuejinEndpoint, 'localId' | 'login' | 'persistent' | 'articles' | 'sendMode' | 'circuitBreaker' | 'approveDraft' | 'editDraft' | 'discardDraft' | 'recheckLogin'> & {
+    readonly drafts: Pick<JuejinEndpoint['drafts'], 'get' | 'list' | 'size'>;
+};
+export type JuejinEndpointDirectory = ReadonlyMap<string, JuejinEndpointView>;
+export interface JuejinDirectoryContext {
+    readonly owner: PluginId | Readonly<{
+        id: PluginId;
+    }>;
+    readonly signal: AbortSignal;
+    project(feature: FeatureId): unknown;
+}
+/** Resolve from the authenticated owner's Adapter; the returned Map is only a request-local projection. */
+export declare function juejinEndpoints(context: JuejinDirectoryContext): JuejinEndpointDirectory;

package/lib/endpoint-directory.js

@@ -0,0 +1,63 @@
+import { adapterFeatureId, isAdapterIndex, isOwnedAdapterDirectory, AdapterManagementError } from 'zhin.js/adapter';
+import { JuejinAdapter } from './adapter.js';
+/** Resolve from the authenticated owner's Adapter; the returned Map is only a request-local projection. */
+export function juejinEndpoints(context) {
+    context.signal.throwIfAborted();
+    const owner = typeof context.owner === 'string' ? context.owner : context.owner.id;
+    const projection = context.project(adapterFeatureId);
+    if (!isAdapterIndex(projection) && !isOwnedAdapterDirectory(projection))
+        throw new AdapterManagementError('unavailable', 'Juejin Adapter directory is unavailable');
+    if (isOwnedAdapterDirectory(projection) && projection.owner !== owner)
+        throw new AdapterManagementError('unavailable', 'Juejin directory owner mismatch');
+    const adapters = projection.adapters().filter((adapter) => adapter.descriptor.owner === owner && adapter instanceof JuejinAdapter);
+    if (adapters.length !== 1)
+        throw new AdapterManagementError('unavailable', 'Juejin Adapter cannot be uniquely selected');
+    const adapter = adapters[0];
+    const rows = new Map();
+    for (const child of adapter.runtimeEntries()) {
+        const endpoint = child.endpoint;
+        if (!endpoint || !child.started || child.stopped)
+            continue;
+        const canonicalId = child.desired.canonicalId;
+        const read = () => {
+            context.signal.throwIfAborted();
+            if (adapter.getEndpoint(child.desired.instanceId) !== endpoint)
+                throw new AdapterManagementError('closed', 'Juejin Endpoint has retired');
+            return endpoint;
+        };
+        const runSync = (operation) => {
+            const lease = adapter.acquire(canonicalId, context.signal, endpoint);
+            try {
+                lease.assertActive();
+                return operation(lease.endpoint);
+            }
+            finally {
+                lease.release();
+            }
+        };
+        const runAsync = async (operation) => {
+            const lease = adapter.acquire(canonicalId, context.signal, endpoint);
+            try {
+                return await lease.run(operation);
+            }
+            finally {
+                lease.release();
+            }
+        };
+        const view = Object.freeze({
+            get localId() { return read().localId; }, get login() { return read().login; },
+            get persistent() { return read().persistent; }, get articles() { return read().articles; },
+            get sendMode() { return read().sendMode; },
+            get circuitBreaker() { return read().circuitBreaker; },
+            drafts: Object.freeze({
+                get: id => read().drafts.get(id), list: () => read().drafts.list(), get size() { return read().drafts.size; },
+            }),
+            approveDraft: id => runAsync(endpoint => endpoint.approveDraft(id)),
+            editDraft: (id, message) => runSync(endpoint => endpoint.editDraft(id, message)),
+            discardDraft: id => runSync(endpoint => endpoint.discardDraft(id)),
+            recheckLogin: () => runAsync(endpoint => endpoint.recheckLogin()),
+        });
+        rows.set(child.desired.endpointId, view);
+    }
+    return rows;
+}