@jackwener/opencli 1.6.7 → 1.6.9

package/dist/clis/zhihu/like.js

@@ -0,0 +1,91 @@
+import { CliError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { assertAllowedKinds, parseTarget } from './target.js';
+import { buildResultRow, requireExecute } from './write-shared.js';
+cli({
+    site: 'zhihu',
+    name: 'like',
+    description: 'Like a Zhihu answer or article',
+    domain: 'zhihu.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'target', positional: true, required: true, help: 'Zhihu target URL or typed target' },
+        { name: 'execute', type: 'boolean', help: 'Actually perform the write action' },
+    ],
+    columns: ['status', 'outcome', 'message', 'target_type', 'target'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for zhihu like');
+        requireExecute(kwargs);
+        const rawTarget = String(kwargs.target);
+        const target = assertAllowedKinds('like', parseTarget(rawTarget));
+        await page.goto(target.url);
+        const result = await page.evaluate(`(async () => {
+      const targetKind = ${JSON.stringify(target.kind)};
+      const targetQuestionId = ${JSON.stringify(target.kind === 'answer' ? target.questionId : null)};
+      const targetAnswerId = ${JSON.stringify(target.kind === 'answer' ? target.id : null)};
+
+      let btn = null;
+      if (targetKind === 'answer') {
+        const block = Array.from(document.querySelectorAll('article, .AnswerItem, [data-zop-question-answer]')).find((node) => {
+          const dataAnswerId = node.getAttribute('data-answerid') || node.getAttribute('data-zop-question-answer') || '';
+          if (dataAnswerId && dataAnswerId.includes(targetAnswerId)) return true;
+          return Array.from(node.querySelectorAll('a[href*="/answer/"]')).some((link) => {
+            const href = link.getAttribute('href') || '';
+            return href.includes('/question/' + targetQuestionId + '/answer/' + targetAnswerId);
+          });
+        });
+        if (!block) return { state: 'wrong_answer' };
+        const candidates = Array.from(block?.querySelectorAll('button') || []).filter((node) => {
+          const text = (node.textContent || '').trim();
+          const inCommentItem = Boolean(node.closest('[data-comment-id], .CommentItem'));
+          return /赞同|赞/.test(text) && node.hasAttribute('aria-pressed') && !inCommentItem;
+        });
+        if (candidates.length !== 1) return { state: 'ambiguous_answer_like' };
+        btn = candidates[0];
+      } else {
+        const articleRoot =
+          document.querySelector('article')
+          || document.querySelector('.Post-Main')
+          || document.querySelector('[itemprop="articleBody"]')
+          || document;
+        const candidates = Array.from(articleRoot.querySelectorAll('button')).filter((node) => {
+          const text = (node.textContent || '').trim();
+          return /赞同|赞/.test(text) && node.hasAttribute('aria-pressed');
+        });
+        if (candidates.length !== 1) return { state: 'ambiguous_article_like' };
+        btn = candidates[0];
+      }
+
+      if (!btn) return { state: 'missing' };
+      if (btn.getAttribute('aria-pressed') === 'true') return { state: 'already_liked' };
+
+      btn.click();
+      await new Promise((resolve) => setTimeout(resolve, 1200));
+
+      return btn.getAttribute('aria-pressed') === 'true'
+        ? { state: 'liked' }
+        : { state: 'unknown' };
+    })()`);
+        if (result?.state === 'wrong_answer') {
+            throw new CliError('TARGET_NOT_FOUND', 'Resolved answer target no longer matches the requested answer:<questionId>:<answerId>');
+        }
+        if (result?.state === 'already_liked') {
+            return buildResultRow(`Already liked ${target.kind}`, target.kind, rawTarget, 'already_applied');
+        }
+        if (result?.state === 'ambiguous_answer_like') {
+            throw new CliError('ACTION_NOT_AVAILABLE', 'Answer like control was not uniquely anchored on the requested answer');
+        }
+        if (result?.state === 'ambiguous_article_like') {
+            throw new CliError('ACTION_NOT_AVAILABLE', 'Article like control was not uniquely anchored on the requested target');
+        }
+        if (result?.state === 'missing') {
+            throw new CliError('ACTION_FAILED', 'Zhihu like control was missing before any write was dispatched');
+        }
+        if (result?.state !== 'liked') {
+            throw new CliError('OUTCOME_UNKNOWN', 'Zhihu like click was dispatched, but the final state could not be verified safely');
+        }
+        return buildResultRow(`Liked ${target.kind}`, target.kind, rawTarget, 'applied');
+    },
+});

package/dist/clis/zhihu/like.test.d.ts

@@ -0,0 +1 @@
+import './like.js';

package/dist/clis/zhihu/like.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './like.js';
+describe('zhihu like', () => {
+    it('rejects article pages where the like control is not uniquely anchored', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'ambiguous_article_like' }),
+        };
+        await expect(cmd.func(page, { target: 'article:9', execute: true })).rejects.toMatchObject({
+            code: 'ACTION_NOT_AVAILABLE',
+        });
+    });
+    it('returns already_applied for an already-liked article target', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'already_liked' }),
+        };
+        await expect(cmd.func(page, { target: 'article:9', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'already_applied', target_type: 'article', target: 'article:9' }),
+        ]);
+    });
+    it('anchors to the requested answer block before clicking like', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'liked' }),
+        };
+        await expect(cmd.func(page, { target: 'answer:123:456', execute: true })).resolves.toEqual([
+            expect.objectContaining({ outcome: 'applied', target_type: 'answer', target: 'answer:123:456' }),
+        ]);
+        expect(page.goto).toHaveBeenCalledWith('https://www.zhihu.com/question/123/answer/456');
+        expect(page.evaluate).toHaveBeenCalledTimes(1);
+        expect(page.evaluate.mock.calls[0][0]).toContain('targetQuestionId');
+        expect(page.evaluate.mock.calls[0][0]).toContain('"123"');
+        expect(page.evaluate.mock.calls[0][0]).toContain('"456"');
+        expect(page.evaluate.mock.calls[0][0]).toContain("node.getAttribute('data-answerid')");
+        expect(page.evaluate.mock.calls[0][0]).toContain("node.getAttribute('data-zop-question-answer')");
+    });
+    it('rejects answer targets when the answer-level like control is not unique', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'ambiguous_answer_like' }),
+        };
+        await expect(cmd.func(page, { target: 'answer:123:456', execute: true })).rejects.toMatchObject({
+            code: 'ACTION_NOT_AVAILABLE',
+        });
+    });
+    it('maps missing answer blocks to TARGET_NOT_FOUND', async () => {
+        const cmd = getRegistry().get('zhihu/like');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue({ state: 'wrong_answer' }),
+        };
+        await expect(cmd.func(page, { target: 'answer:123:456', execute: true })).rejects.toMatchObject({
+            code: 'TARGET_NOT_FOUND',
+        });
+        expect(page.evaluate.mock.calls[0][0]).toContain("if (!block) return { state: 'wrong_answer' }");
+    });
+});

package/dist/clis/zhihu/target.d.ts

@@ -0,0 +1,24 @@
+export type ZhihuTarget = {
+    kind: 'user';
+    slug: string;
+    url: string;
+} | {
+    kind: 'question';
+    id: string;
+    url: string;
+} | {
+    kind: 'answer';
+    questionId: string;
+    id: string;
+    url: string;
+} | {
+    kind: 'article';
+    id: string;
+    url: string;
+};
+export declare function parseTarget(input: string): ZhihuTarget;
+export declare function assertAllowedKinds(command: string, target: ZhihuTarget): ZhihuTarget;
+export declare const __test__: {
+    parseTarget: typeof parseTarget;
+    assertAllowedKinds: typeof assertAllowedKinds;
+};

package/dist/clis/zhihu/target.js

@@ -0,0 +1,91 @@
+import { CliError } from '@jackwener/opencli/errors';
+const USER_RE = /^user:([A-Za-z0-9_-]+)$/;
+const QUESTION_RE = /^question:(\d+)$/;
+const ANSWER_RE = /^answer:(\d+):(\d+)$/;
+const ARTICLE_RE = /^article:(\d+)$/;
+const USER_PATH_RE = /^\/people\/([A-Za-z0-9_-]+)\/?$/;
+const QUESTION_PATH_RE = /^\/question\/(\d+)\/?$/;
+const ANSWER_PATH_RE = /^\/question\/(\d+)\/answer\/(\d+)\/?$/;
+const ARTICLE_PATH_RE = /^\/p\/(\d+)\/?$/;
+const EMPTY_AUTHORITY_RE = /^https:\/\/(?::)?@/i;
+function isAllowedZhihuUrl(url) {
+    return url.protocol === 'https:' && url.username === '' && url.password === '' && url.port === '';
+}
+export function parseTarget(input) {
+    const value = String(input).trim();
+    if (EMPTY_AUTHORITY_RE.test(value)) {
+        throw new CliError('INVALID_INPUT', 'Zhihu write commands require a normal HTTPS Zhihu URL without malformed authority', 'Example: https://www.zhihu.com/question/123456');
+    }
+    if (value.startsWith('answer:') && !ANSWER_RE.test(value)) {
+        throw new CliError('INVALID_INPUT', 'Invalid answer target, expected answer:<questionId>:<answerId>', 'Example: opencli zhihu like answer:123:456 --execute');
+    }
+    let match = value.match(USER_RE);
+    if (match) {
+        return { kind: 'user', slug: match[1], url: `https://www.zhihu.com/people/${match[1]}` };
+    }
+    match = value.match(QUESTION_RE);
+    if (match) {
+        return { kind: 'question', id: match[1], url: `https://www.zhihu.com/question/${match[1]}` };
+    }
+    match = value.match(ANSWER_RE);
+    if (match) {
+        return {
+            kind: 'answer',
+            questionId: match[1],
+            id: match[2],
+            url: `https://www.zhihu.com/question/${match[1]}/answer/${match[2]}`,
+        };
+    }
+    match = value.match(ARTICLE_RE);
+    if (match) {
+        return { kind: 'article', id: match[1], url: `https://zhuanlan.zhihu.com/p/${match[1]}` };
+    }
+    try {
+        const url = new URL(value);
+        if (!isAllowedZhihuUrl(url)) {
+            throw new Error('unsupported zhihu url variant');
+        }
+        if (url.hostname === 'www.zhihu.com') {
+            const userMatch = url.pathname.match(USER_PATH_RE);
+            if (userMatch) {
+                const slug = userMatch[1];
+                return { kind: 'user', slug, url: `https://www.zhihu.com/people/${slug}` };
+            }
+            const questionMatch = url.pathname.match(QUESTION_PATH_RE);
+            if (questionMatch) {
+                return { kind: 'question', id: questionMatch[1], url: `https://www.zhihu.com/question/${questionMatch[1]}` };
+            }
+            const answerMatch = url.pathname.match(ANSWER_PATH_RE);
+            if (answerMatch) {
+                return {
+                    kind: 'answer',
+                    questionId: answerMatch[1],
+                    id: answerMatch[2],
+                    url: `https://www.zhihu.com/question/${answerMatch[1]}/answer/${answerMatch[2]}`,
+                };
+            }
+        }
+        if (url.hostname === 'zhuanlan.zhihu.com') {
+            const articleMatch = url.pathname.match(ARTICLE_PATH_RE);
+            if (articleMatch) {
+                return { kind: 'article', id: articleMatch[1], url: `https://zhuanlan.zhihu.com/p/${articleMatch[1]}` };
+            }
+        }
+    }
+    catch { }
+    throw new CliError('INVALID_INPUT', 'Zhihu write commands require a Zhihu URL or typed target like question:123 or answer:123:456', 'Example: opencli zhihu like answer:123:456 --execute');
+}
+export function assertAllowedKinds(command, target) {
+    const allowed = {
+        follow: ['user', 'question'],
+        like: ['answer', 'article'],
+        favorite: ['answer', 'article'],
+        comment: ['answer', 'article'],
+        answer: ['question'],
+    };
+    if (!allowed[command]?.includes(target.kind)) {
+        throw new CliError('UNSUPPORTED_TARGET', `zhihu ${command} does not support ${target.kind} targets`);
+    }
+    return target;
+}
+export const __test__ = { parseTarget, assertAllowedKinds };

package/dist/clis/zhihu/target.test.d.ts

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

package/dist/clis/zhihu/target.test.js

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+import { CliError } from '@jackwener/opencli/errors';
+import { __test__ } from './target.js';
+describe('zhihu target parser', () => {
+    it('parses typed answer IDs into canonical targets', () => {
+        expect(__test__.parseTarget('answer:123:456')).toEqual({
+            kind: 'answer',
+            questionId: '123',
+            id: '456',
+            url: 'https://www.zhihu.com/question/123/answer/456',
+        });
+    });
+    it('parses question URLs into canonical targets', () => {
+        expect(__test__.parseTarget('https://www.zhihu.com/question/123456')).toEqual({
+            kind: 'question',
+            id: '123456',
+            url: 'https://www.zhihu.com/question/123456',
+        });
+    });
+    it('canonicalizes question URLs with query strings and fragments', () => {
+        expect(__test__.parseTarget('https://www.zhihu.com/question/123456/?utm_source=share#answer-1')).toEqual({
+            kind: 'question',
+            id: '123456',
+            url: 'https://www.zhihu.com/question/123456',
+        });
+    });
+    it('canonicalizes answer URLs with query strings and fragments', () => {
+        expect(__test__.parseTarget('https://www.zhihu.com/question/123456/answer/7890/?utm_psn=1#comment')).toEqual({
+            kind: 'answer',
+            questionId: '123456',
+            id: '7890',
+            url: 'https://www.zhihu.com/question/123456/answer/7890',
+        });
+    });
+    it('canonicalizes article URLs with query strings and fragments', () => {
+        expect(__test__.parseTarget('https://zhuanlan.zhihu.com/p/98765/?utm_id=1#heading')).toEqual({
+            kind: 'article',
+            id: '98765',
+            url: 'https://zhuanlan.zhihu.com/p/98765',
+        });
+    });
+    it('canonicalizes user URLs with trailing slash, query strings, and fragments', () => {
+        expect(__test__.parseTarget('https://www.zhihu.com/people/example-user/?utm_term=share#about')).toEqual({
+            kind: 'user',
+            slug: 'example-user',
+            url: 'https://www.zhihu.com/people/example-user',
+        });
+    });
+    it('rejects non-https Zhihu URLs', () => {
+        expect(() => __test__.parseTarget('http://www.zhihu.com/question/123456')).toThrowError(CliError);
+    });
+    it('rejects Zhihu URLs with embedded credentials', () => {
+        expect(() => __test__.parseTarget('https://user@www.zhihu.com/question/123456')).toThrowError(CliError);
+    });
+    it('rejects Zhihu URLs with explicit ports', () => {
+        expect(() => __test__.parseTarget('https://www.zhihu.com:8443/question/123456')).toThrowError(CliError);
+    });
+    it('rejects Zhihu URLs with empty authority usernames', () => {
+        expect(() => __test__.parseTarget('https://@www.zhihu.com/question/123456')).toThrowError(CliError);
+    });
+    it('rejects Zhihu URLs with empty authority username and password markers', () => {
+        expect(() => __test__.parseTarget('https://:@www.zhihu.com/question/123456')).toThrowError(CliError);
+    });
+    it('rejects ambiguous bare numeric IDs', () => {
+        expect(() => __test__.parseTarget('123456')).toThrowError(CliError);
+    });
+    it('rejects malformed typed IDs', () => {
+        expect(() => __test__.parseTarget('answer:123')).toThrowError(/answer:<questionId>:<answerId>/);
+    });
+    it('rejects unsupported target kinds per command', () => {
+        expect(() => __test__.assertAllowedKinds('follow', {
+            kind: 'article',
+            id: '1',
+            url: 'https://zhuanlan.zhihu.com/p/1',
+        })).toThrowError(/follow/);
+    });
+});

package/dist/clis/zhihu/write-shared.d.ts

@@ -0,0 +1,32 @@
+import { readFile } from 'node:fs/promises';
+import type { IPage } from '@jackwener/opencli/types';
+type FileStatLike = {
+    isFile(): boolean;
+};
+type FileReaderDeps = {
+    readFile: typeof readFile;
+    stat: (path: string) => Promise<FileStatLike>;
+    decodeUtf8: (raw: Buffer) => string;
+};
+type IdentityRootLike = {
+    querySelectorAll(selector: string): ArrayLike<unknown>;
+};
+export declare function resolveCurrentUserSlugFromDom(state: unknown, documentRoot: IdentityRootLike): string | null;
+export declare function requireExecute(kwargs: Record<string, unknown>): void;
+export declare function resolvePayload(kwargs: Record<string, unknown>, deps?: FileReaderDeps): Promise<string>;
+export declare function resolveCurrentUserIdentity(page: Pick<IPage, 'evaluate'>): Promise<string>;
+export declare function buildResultRow(message: string, targetType: string, target: string, outcome: 'applied' | 'already_applied' | 'created', extra?: Record<string, unknown>): {
+    status: string;
+    outcome: "created" | "applied" | "already_applied";
+    message: string;
+    target_type: string;
+    target: string;
+}[];
+export declare const __test__: {
+    requireExecute: typeof requireExecute;
+    resolvePayload: typeof resolvePayload;
+    resolveCurrentUserIdentity: typeof resolveCurrentUserIdentity;
+    resolveCurrentUserSlugFromDom: typeof resolveCurrentUserSlugFromDom;
+    buildResultRow: typeof buildResultRow;
+};
+export {};

package/dist/clis/zhihu/write-shared.js

@@ -0,0 +1,221 @@
+import { readFile, stat } from 'node:fs/promises';
+import { CliError } from '@jackwener/opencli/errors';
+const RESULT_ROW_RESERVED_KEYS = new Set(['status', 'outcome', 'message', 'target_type', 'target']);
+const NAV_SCOPE_SELECTOR = 'header, nav, [role="banner"], [role="navigation"]';
+const PROFILE_LINK_SELECTOR = 'a[href^="/people/"]';
+const AVATAR_SELECTOR = 'img, [class*="Avatar"], [data-testid*="avatar" i], [aria-label*="头像"]';
+const SELF_LABEL_TOKENS = ['我', '我的', '个人主页'];
+const EXPLICIT_IDENTITY_META_TOKEN_GROUPS = [
+    ['self'],
+    ['current', 'user'],
+    ['account', 'profile'],
+    ['my', 'profile'],
+    ['my', 'account'],
+];
+const IN_PAGE_EXPLICIT_IDENTITY_META_TOKEN_GROUPS = JSON.stringify(EXPLICIT_IDENTITY_META_TOKEN_GROUPS);
+function defaultFileReaderDeps() {
+    return {
+        readFile,
+        stat: (path) => stat(path),
+        decodeUtf8: (raw) => new TextDecoder('utf-8', { fatal: true }).decode(raw),
+    };
+}
+function hasExplicitIdentityLabel(text) {
+    const normalized = text.toLowerCase();
+    return SELF_LABEL_TOKENS.some((token) => text.includes(token)) || normalized.includes('my profile') || normalized.includes('my account');
+}
+function tokenizeIdentityMeta(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(Boolean);
+}
+function hasExplicitIdentityMeta(text) {
+    const tokens = new Set(tokenizeIdentityMeta(text));
+    return EXPLICIT_IDENTITY_META_TOKEN_GROUPS.some((group) => group.every((token) => tokens.has(token)));
+}
+function isIdentityRootLike(value) {
+    return typeof value === 'object' && value !== null && 'querySelectorAll' in value
+        && typeof value.querySelectorAll === 'function';
+}
+function isIdentityNodeLike(value) {
+    return typeof value === 'object' && value !== null
+        && 'getAttribute' in value
+        && 'querySelector' in value
+        && typeof value.getAttribute === 'function'
+        && typeof value.querySelector === 'function';
+}
+function resolveSlugFromState(state) {
+    const slugFromState = state?.topstory?.me?.slug
+        || state?.me?.slug
+        || state?.initialState?.me?.slug;
+    return typeof slugFromState === 'string' && slugFromState ? slugFromState : null;
+}
+function getSlugFromIdentityLink(node, allowAvatarOnly) {
+    const href = node.getAttribute('href') || '';
+    const match = href.match(/^\/people\/([A-Za-z0-9_-]+)/);
+    if (!match)
+        return null;
+    const aria = node.getAttribute('aria-label') || '';
+    const title = node.getAttribute('title') || '';
+    const testid = node.getAttribute('data-testid') || '';
+    const className = node.getAttribute('class') || '';
+    const rel = node.getAttribute('rel') || '';
+    const identityLabel = `${aria} ${title} ${node.textContent || ''}`;
+    const identityMeta = `${testid} ${className} ${rel}`;
+    const hasAvatar = Boolean(node.querySelector(AVATAR_SELECTOR));
+    const isExplicitIdentityLabel = hasExplicitIdentityLabel(identityLabel);
+    const isExplicitIdentityMeta = hasExplicitIdentityMeta(identityMeta);
+    if (isExplicitIdentityLabel || isExplicitIdentityMeta)
+        return match[1];
+    if (allowAvatarOnly && hasAvatar)
+        return match[1];
+    return null;
+}
+function findCurrentUserSlugFromRoots(roots, allowAvatarOnly) {
+    for (const root of roots) {
+        for (const node of Array.from(root.querySelectorAll(PROFILE_LINK_SELECTOR)).filter(isIdentityNodeLike)) {
+            const slug = getSlugFromIdentityLink(node, allowAvatarOnly);
+            if (slug)
+                return slug;
+        }
+    }
+    return null;
+}
+export function resolveCurrentUserSlugFromDom(state, documentRoot) {
+    const slugFromState = resolveSlugFromState(state);
+    if (slugFromState)
+        return slugFromState;
+    const navScopes = Array.from(documentRoot.querySelectorAll(NAV_SCOPE_SELECTOR)).filter(isIdentityRootLike);
+    return findCurrentUserSlugFromRoots(navScopes, true) || findCurrentUserSlugFromRoots([documentRoot], false);
+}
+export function requireExecute(kwargs) {
+    if (!kwargs.execute) {
+        throw new CliError('INVALID_INPUT', 'This Zhihu write command requires --execute');
+    }
+}
+export async function resolvePayload(kwargs, deps = defaultFileReaderDeps()) {
+    const text = typeof kwargs.text === 'string' ? kwargs.text : undefined;
+    const file = typeof kwargs.file === 'string' ? kwargs.file : undefined;
+    if (text && file) {
+        throw new CliError('INVALID_INPUT', 'Use either <text> or --file, not both');
+    }
+    let resolved = text ?? '';
+    if (file) {
+        let fileStat;
+        try {
+            fileStat = await deps.stat(file);
+        }
+        catch {
+            throw new CliError('INVALID_INPUT', `File not found: ${file}`);
+        }
+        if (!fileStat.isFile()) {
+            throw new CliError('INVALID_INPUT', `File must be a readable text file: ${file}`);
+        }
+        let raw;
+        try {
+            raw = await deps.readFile(file);
+        }
+        catch {
+            throw new CliError('INVALID_INPUT', `File could not be read: ${file}`);
+        }
+        try {
+            resolved = deps.decodeUtf8(raw);
+        }
+        catch {
+            throw new CliError('INVALID_INPUT', `File could not be decoded as UTF-8 text: ${file}`);
+        }
+    }
+    if (!resolved.trim()) {
+        throw new CliError('INVALID_INPUT', 'Payload cannot be empty or whitespace only');
+    }
+    return resolved;
+}
+function buildResolveCurrentUserIdentityJs() {
+    return `(() => {
+    const selfLabelTokens = ${JSON.stringify(SELF_LABEL_TOKENS)};
+    const explicitIdentityMetaTokenGroups = ${IN_PAGE_EXPLICIT_IDENTITY_META_TOKEN_GROUPS};
+    const navScopeSelector = ${JSON.stringify(NAV_SCOPE_SELECTOR)};
+    const profileLinkSelector = ${JSON.stringify(PROFILE_LINK_SELECTOR)};
+    const avatarSelector = ${JSON.stringify(AVATAR_SELECTOR)};
+
+    const hasExplicitIdentityLabel = (text) => {
+      const normalized = String(text || '').toLowerCase();
+      return selfLabelTokens.some((token) => String(text || '').includes(token))
+        || normalized.includes('my profile')
+        || normalized.includes('my account');
+    };
+
+    const tokenizeIdentityMeta = (text) => String(text || '')
+      .toLowerCase()
+      .split(/[^a-z0-9]+/)
+      .filter(Boolean);
+
+    const hasExplicitIdentityMeta = (text) => {
+      const tokens = new Set(tokenizeIdentityMeta(text));
+      return explicitIdentityMetaTokenGroups.some((group) => group.every((token) => tokens.has(token)));
+    };
+
+    const getSlugFromIdentityLink = (node, allowAvatarOnly) => {
+      const href = node.getAttribute('href') || '';
+      const match = href.match(/^\\/people\\/([A-Za-z0-9_-]+)/);
+      if (!match) return null;
+
+      const aria = node.getAttribute('aria-label') || '';
+      const title = node.getAttribute('title') || '';
+      const testid = node.getAttribute('data-testid') || '';
+      const className = node.getAttribute('class') || '';
+      const rel = node.getAttribute('rel') || '';
+      const identityLabel = \`\${aria} \${title} \${node.textContent || ''}\`;
+      const identityMeta = \`\${testid} \${className} \${rel}\`;
+      const hasAvatar = Boolean(node.querySelector(avatarSelector));
+
+      if (hasExplicitIdentityLabel(identityLabel) || hasExplicitIdentityMeta(identityMeta)) return match[1];
+      if (allowAvatarOnly && hasAvatar) return match[1];
+      return null;
+    };
+
+    const findCurrentUserSlugFromRoots = (roots, allowAvatarOnly) => {
+      for (const root of roots) {
+        for (const node of Array.from(root.querySelectorAll(profileLinkSelector))) {
+          const slug = getSlugFromIdentityLink(node, allowAvatarOnly);
+          if (slug) return slug;
+        }
+      }
+      return null;
+    };
+
+    const scopedGlobal = globalThis;
+    const state = scopedGlobal.__INITIAL_STATE__ || (scopedGlobal.window && scopedGlobal.window.__INITIAL_STATE__) || null;
+    const slugFromState = state && (state.topstory && state.topstory.me && state.topstory.me.slug)
+      || (state && state.me && state.me.slug)
+      || (state && state.initialState && state.initialState.me && state.initialState.me.slug);
+    if (typeof slugFromState === 'string' && slugFromState) return { slug: slugFromState };
+
+    const navScopes = Array.from(document.querySelectorAll(navScopeSelector));
+    const slug = findCurrentUserSlugFromRoots(navScopes, true) || findCurrentUserSlugFromRoots([document], false);
+    return slug ? { slug } : null;
+  })()`;
+}
+export async function resolveCurrentUserIdentity(page) {
+    const identity = await page.evaluate(buildResolveCurrentUserIdentityJs());
+    if (!identity?.slug) {
+        throw new CliError('ACTION_NOT_AVAILABLE', 'Could not resolve the logged-in Zhihu user identity before write');
+    }
+    return identity.slug;
+}
+export function buildResultRow(message, targetType, target, outcome, extra = {}) {
+    for (const key of Object.keys(extra)) {
+        if (RESULT_ROW_RESERVED_KEYS.has(key)) {
+            throw new CliError('INVALID_INPUT', `Result extra field cannot overwrite reserved key: ${key}`);
+        }
+    }
+    return [{ status: 'success', outcome, message, target_type: targetType, target, ...extra }];
+}
+export const __test__ = {
+    requireExecute,
+    resolvePayload,
+    resolveCurrentUserIdentity,
+    resolveCurrentUserSlugFromDom,
+    buildResultRow,
+};

package/dist/clis/zhihu/write-shared.test.d.ts

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