@gobing-ai/knowledge-kit 0.0.32 → 0.0.33

package/plugins/publishings/infoq-pub/src/index.ts

@@ -11,7 +11,9 @@ import {
 import {
     type ChannelBrowserConfig,
     checkChannelSession,
+    DEFAULT_SIGNAL_CONTAINERS,
     expectOutcome,
+    kkBrowserLauncher,
     markdownToHtml,
     pasteHtml,
     readScopedSignal,
@@ -33,48 +35,105 @@ import type { Page } from 'playwright';
 export const CHANNEL = 'infoq';
 const TARGET = 'infoq';
 /**
- * InfoQ's write page. The wt seed tries `/write`, `/write/article/new` and `/article/create`
- * (`infoq-playwright.ts:545-547`); the operator dogfood re-measures this one.
+ * The live entry to the InfoQ editor (measured 2026-10-06, tasks 0201 + 0191): the home page's
+ * 写点什么 write button SPA-routes to `/draft/<id>`, where the draft already exists server-side.
+ * The former `https://xie.infoq.cn/write` constant is dead — it renders an empty shell even
+ * authenticated, with no editor and no login redirect.
  */
-export const EDITOR_URL = 'https://xie.infoq.cn/write';
-/** Login/SSO URLs that mean "not authenticated" — the editor never renders behind them. */
-export const LOGIN_URL_RE = /(account\.infoq\.cn|\/login)/;
+export const HOME_URL = 'https://xie.infoq.cn/';
+/** The editor URL the entry flow lands on; the captured group is the server-side draft id. */
+export const DRAFT_URL_RE = /\/draft\/(\d+)/;
+/**
+ * Login/SSO URLs that mean "not authenticated" — the editor never renders behind them. The SSO
+ * domain moved from account.infoq.cn to account.geekbang.org (measured, task 0201). The home page
+ * renders logged-out content without redirecting, so this regex is only the fast arm of the
+ * readiness predicate below.
+ */
+export const LOGIN_URL_RE = /(account\.infoq\.cn|account\.geekbang\.org|\/login)/;
 
 /**
- * Selectors measured against the InfoQ editor (wt seed `infoq-playwright.ts:26-62`); each list is
- * tried in order and the operator dogfood re-measures them. `live` is `提交`, InfoQ's submit for
- * editorial review — the site has no self-publish control.
+ * Selectors measured against the live authenticated console (2026-10-06, tasks 0201 + 0191);
+ * each list is tried in order. Measured absent and therefore removed: the summary field (the
+ * console has no 摘要 input, so `metadata.summary` is not representable on InfoQ) and the draft
+ * button (the editor autosaves — the save signal is the 已保存 indicator, not a click). `live`
+ * is the 发布 control, a `div`: InfoQ submit goes to editorial review, the site has no
+ * self-publish control.
  */
 export const SELECTORS = {
-    title: ['input[placeholder*="标题"]', 'textarea[placeholder*="标题"]'],
-    summary: ['input[placeholder*="摘要"]', 'textarea[placeholder*="摘要"]', 'input[name="summary"]'],
+    writeEntry: ['div.write-btn'],
+    noticeDismiss: ['text=知道了'],
+    title: ['input[placeholder="请输入标题"]', 'input[placeholder*="标题"]'],
     body: ['.ProseMirror[contenteditable="true"]', '[contenteditable="true"]'],
-    draft: ['button:has-text("保存草稿")'],
-    live: ['button:has-text("提交")'],
+    live: ['div.submit-btn'],
 } as const;
 
+/**
+ * Per-step wait. Lower bound: the measured autosave indicator appears within ~6 s of content
+ * entry (docs/design/infoq-ui-discovery.md:41, 0201 walk), so the window must cover the slow end
+ * of that latency plus hydration; 30 s is the 5× margin. Unit tests override this for fakes that
+ * resolve instantly.
+ */
 const STEP_TIMEOUT_MS = 30_000;
+
+/**
+ * Read-only session check budget, independent of {@link STEP_TIMEOUT_MS}: headed hydration of
+ * the logged-in home has a slow tail (2.5-35 s measured on the operator profile, 0191 dogfood),
+ * so one 30 s step window is not enough for the check.
+ */
+const CHECK_TIMEOUT_MS = 60_000;
 const LOGIN_TIMEOUT_MS = 180_000;
 /** Operator recovery command every session failure names — never a cookie, page HTML or stack. */
 const LOGIN_INSTRUCTION = 'bun plugins/publishings/infoq-pub/src/profile-check.ts login';
-/** A saved draft lands on a URL carrying its article id; a query-string move is not a signal. */
-const DRAFT_URL_ID_RE = /\/(\d{4,}|[0-9a-f]{16,})(?:\/|$|\?)/;
-const DRAFT_TOASTS = ['保存成功', '已保存'];
+/**
+ * The draft-saved signal (measured, task 0201; re-walked 0191): the editor autosaves and shows
+ * the 已保存 indicator — read only from the page's notification containers, never the article
+ * body (residual 0195).
+ */
+const DRAFT_SAVED_TEXTS = ['已保存'];
+
+/**
+ * Signal containers for this channel: the shared toast/notice defaults plus the editor header's
+ * persistent save indicator (`div.save-status`, measured 0191 re-dogfood — InfoQ now renders
+ * `已保存 <timestamp>` there instead of a toast). Class-scoped, so the 0195 body false-positive
+ * risk does not apply.
+ */
+const SIGNAL_CONTAINERS: readonly string[] = [...DEFAULT_SIGNAL_CONTAINERS, '[class*="save-status" i]'];
 const LIVE_TOASTS = ['提交成功', '审核'];
+/**
+ * Page-side scan behind {@link isAuthenticated}: is a control labelled exactly 登录 visible?
+ * Exact leaf text, because feed articles can carry the substring 登录 without the session being
+ * logged out.
+ */
+const LOGGED_OUT_MARKER_SCRIPT = `(() => {
+    for (const node of document.querySelectorAll('body *')) {
+        if (node.children.length > 0) continue;
+        if ((node.textContent ?? '').trim() !== '登录') continue;
+        if (typeof node.checkVisibility === 'function' ? !node.checkVisibility() : node.getClientRects().length === 0) continue;
+        return true;
+    }
+    return false;
+})()`;
 
 /**
- * InfoQ-owned readiness predicate: the editor is reachable (no SSO redirect) and the title field
- * is attached. Shared by the publish preflight and the profile-session CLI (R1, R5).
+ * InfoQ-owned readiness predicate: the home page has hydrated to the write entry and no 登录
+ * control is visible (the logged-out marker). Shared by the publish preflight and the
+ * profile-session CLI (R1, R5). Hydration gates the marker read: until the home chrome renders,
+ * the 登录 control has not attached yet and a logged-out page false-reads logged-in (0201).
  */
 export const isAuthenticated: IsAuthenticatedPredicate = async (page) =>
-    !LOGIN_URL_RE.test(page.url()) && (await trySelectors(page, SELECTORS.title, { visible: false })).found;
+    !LOGIN_URL_RE.test(page.url()) &&
+    (await trySelectors(page, SELECTORS.writeEntry, { visible: false })).found &&
+    !(await page.evaluate(LOGGED_OUT_MARKER_SCRIPT));
 
 /** Site-owned config for the shared session check and operator CLI (0183). */
 export const CONFIG: ChannelBrowserConfig = {
     channel: CHANNEL,
-    homeUrl: EDITOR_URL,
+    homeUrl: HOME_URL,
     isAuthenticated,
     loginTimeoutMs: LOGIN_TIMEOUT_MS,
+    // The WAF 451s every headless load, so the profile-check CLI must not waste its first
+    // pass headlessly either (measured 0201, re-confirmed 0191).
+    checkHeadedOnly: true,
 };
 
 function fail(error: string): Result {
@@ -124,25 +183,54 @@ async function findSelector(
  * a body containing `保存成功` reported a draft that was never saved.
  */
 async function readToast(page: Page, texts: readonly string[]): Promise<string | null> {
-    return readScopedSignal(page, texts);
+    return readScopedSignal(page, texts, SIGNAL_CONTAINERS);
+}
+
+/**
+ * Declared modes (ADR-029 dispatch; task 0205 R2): InfoQ's only console flow is the draft path; 提交 (editorial review) is live-only and not a mode. An unknown operation is refused by
+ * name before a profile is resolved or a browser opens.
+ */
+export const INFOQ_OPERATIONS = ['draft'] as const;
+export type InfoqOperation = (typeof INFOQ_OPERATIONS)[number];
+
+/** Exit-early resolution of the requested operation; a default Content without one resolves to `draft`. */
+export function resolveOperation(
+    options?: Record<string, unknown>,
+    content?: Content,
+): { operation: InfoqOperation; error?: undefined } | { operation?: undefined; error: string } {
+    const raw = options?.operation ?? content?.metadata?.operation;
+    if (raw === undefined) return { operation: 'draft' };
+    if (typeof raw !== 'string' || !(INFOQ_OPERATIONS as readonly string[]).includes(raw)) {
+        return {
+            error: `unsupported operation '${String(raw)}' for infoq: expected one of ${INFOQ_OPERATIONS.join(', ')}`,
+        };
+    }
+    return { operation: raw as InfoqOperation };
 }
 
 export class InfoqBrowserTransport implements PublishTransport {
     public readonly kind = 'browser';
     public readonly driver: BrowserDriver;
-    private readonly launcher?: BrowserLauncher;
+    private readonly launcher: BrowserLauncher;
     private readonly stepTimeoutMs: number;
+    private readonly checkTimeoutMs: number;
 
-    constructor(driver: BrowserDriver = 'script', deps: { launcher?: BrowserLauncher; stepTimeoutMs?: number } = {}) {
+    constructor(
+        driver: BrowserDriver = 'script',
+        deps: { launcher?: BrowserLauncher; stepTimeoutMs?: number; checkTimeoutMs?: number } = {},
+    ) {
         this.driver = driver;
-        this.launcher = deps.launcher;
+        this.launcher = deps.launcher ?? kkBrowserLauncher;
         this.stepTimeoutMs = deps.stepTimeoutMs ?? STEP_TIMEOUT_MS;
+        this.checkTimeoutMs = deps.checkTimeoutMs ?? CHECK_TIMEOUT_MS;
     }
 
     public async publish(payload: PublishTransportPayload): Promise<Result> {
         if (this.driver !== 'script') {
             return fail(`unsupported driver '${this.driver}' for ${TARGET}`);
         }
+        const mode = resolveOperation(payload.options, payload.content);
+        if (mode.error !== undefined) return fail(mode.error);
         const requested = payload.content.metadata?.publishStatus;
         if (requested !== undefined && requested !== 'draft' && requested !== 'public') {
             return fail(`unknown publishStatus '${String(requested)}' (expected absent, 'draft' or 'public')`);
@@ -151,13 +239,17 @@ export class InfoqBrowserTransport implements PublishTransport {
         const override = typeof payload.options?.profileDir === 'string' ? payload.options.profileDir : undefined;
         const profileDir = resolveChannelProfileDir(CHANNEL, override);
 
-        // ADR-025 preflight: an unauthenticated or absent profile must never produce a headed
-        // visit, so the read-only headless check runs first and a refusal stays a fast refusal.
+        // ADR-025 preflight: an unauthenticated or absent profile must never reach the editor
+        // flow, so the read-only session check runs first and a refusal stays a fast refusal.
         const session = await checkChannelSession(CONFIG, {
             profileDir,
             launcher: this.launcher,
-            headedFallback: false,
-            timeoutMs: this.stepTimeoutMs,
+            // InfoQ's WAF serves HTTP 451 to every headless page load (measured 0201, re-confirmed
+            // 0191), so the check runs headed only — a headless pass is a guaranteed 30 s burn
+            // that shortens the headed budget below the measured hydration tail. A
+            // missing/expired profile still refuses before any flow opens (ADR-025 shape).
+            headedOnly: true,
+            timeoutMs: this.checkTimeoutMs,
         });
         if (session.status !== 'verified') {
             return fail(`${CHANNEL} session preflight refused: ${session.detail} — run: ${LOGIN_INSTRUCTION}`);
@@ -167,10 +259,11 @@ export class InfoqBrowserTransport implements PublishTransport {
             return await withProfilePage(
                 {
                     profileDir,
-                    url: EDITOR_URL,
+                    url: HOME_URL,
                     isAuthenticated,
-                    // Headed by default (sites bot-wall headless loads); the headless preflight
-                    // above is the unattended pass, `options.headless === true` the opt-in.
+                    // Headed by default — InfoQ's WAF 451s every headless load (measured 0201,
+                    // re-confirmed 0191; see the preflight comment); `options.headless === true`
+                    // is an explicit opt-in that will fail loudly against that wall.
                     headless: payload.options?.headless === true,
                     launcher: this.launcher,
                     // The session is already preflight-verified, so the post-goto confirmation is
@@ -186,9 +279,12 @@ export class InfoqBrowserTransport implements PublishTransport {
     }
 
     /**
-     * The site-owned editor flow: title → optional summary → ProseMirror paste → draft control,
-     * plus the submit control only for `publishStatus === 'public'`. Every outcome comes from an
-     * `expectOutcome` probe, so a click without an observed signal is never a success (E91-D6).
+     * The site-owned editor flow (measured 0201 + 0191): home 写点什么 → the server-side draft
+     * `/draft/<id>` → title → ProseMirror paste → autosave indicator. There is no draft click:
+     * the entry itself created the draft, and the save is proven by the observed 已保存 signal.
+     * The submit control is touched only for `publishStatus === 'public'`. Every outcome comes
+     * from an `expectOutcome` probe, so a step without an observed signal is never a success
+     * (E91-D6).
      */
     private async runEditorFlow(
         page: Page,
@@ -198,33 +294,46 @@ export class InfoqBrowserTransport implements PublishTransport {
     ): Promise<Result> {
         const metadata = { driver: this.driver, publishStatus, profileDir };
 
+        const entrySelector = await findSelector(page, SELECTORS.writeEntry, 'write entry', this.stepTimeoutMs);
+        await page.locator(entrySelector).first().click();
+        const entered = await waitUntil(() => Promise.resolve(DRAFT_URL_RE.test(page.url())), this.stepTimeoutMs);
+        if (!entered) {
+            throw new Error(
+                `infoq editor entry: still on '${page.url()}' — no /draft/<id> within ${this.stepTimeoutMs}ms`,
+            );
+        }
+        // The draft id exists before any content is typed: the entry itself created the draft.
+        const id = DRAFT_URL_RE.exec(page.url())?.[1];
+        await dismissNoticeModal(page, this.stepTimeoutMs);
+
         const titleSelector = await findSelector(page, SELECTORS.title, 'title input', this.stepTimeoutMs);
         await page
             .locator(titleSelector)
             .first()
             .fill(content.title ?? '');
 
-        const summary = content.metadata?.summary;
-        if (typeof summary === 'string' && summary.length > 0) {
-            const summarySelector = await findSelector(page, SELECTORS.summary, 'summary input', this.stepTimeoutMs);
-            await page.locator(summarySelector).first().fill(summary);
-        }
+        // No summary step: the measured console has no summary field (see SELECTORS).
 
         const bodySelector = await findSelector(page, SELECTORS.body, 'body editor', this.stepTimeoutMs);
         await pasteHtml(page, bodySelector, markdownToHtml(content.body), { timeoutMs: this.stepTimeoutMs });
+        // pasteHtml sets innerHTML without an input event, so ProseMirror's autosave may not see
+        // the change; dispatch one so the 已保存 indicator actually fires (measured 0191 probe:
+        // the indicator appeared only after a real input event reached the editor).
+        // String script: this plugin's tsconfig has no DOM lib, so the callback must not be TS.
+        await page
+            .evaluate(
+                '(selector) => { const editor = document.querySelector(selector); editor && editor.dispatchEvent(new InputEvent("input", { bubbles: true })); }',
+                bodySelector,
+            )
+            .catch(() => {});
 
-        const urlBeforeSave = page.url();
-        const draftSelector = await findSelector(page, SELECTORS.draft, 'draft control', this.stepTimeoutMs);
-        await page.locator(draftSelector).first().click();
-
-        const draft = await expectOutcome(() => probeDraft(page, urlBeforeSave), {
+        // Signal = the autosave 已保存 indicator, measured within ~6 s of paste (0201 walk);
+        // the 30 s default window is the 5× margin (see STEP_TIMEOUT_MS).
+        const draft = await expectOutcome(() => readToast(page, DRAFT_SAVED_TEXTS), {
             timeoutMs: this.stepTimeoutMs,
-            label: `infoq draft save '${draftSelector}'`,
+            label: 'infoq draft autosave',
         });
         if (!draft.ok) return fail(draft.error);
-        // The probe only returns a URL that moved and carried an id, so a capture exists exactly
-        // for that branch; a toast text carries none.
-        const id = DRAFT_URL_ID_RE.exec(draft.evidence)?.[1];
 
         if (publishStatus === 'draft') {
             return ResultSchema.parse({
@@ -238,8 +347,8 @@ export class InfoqBrowserTransport implements PublishTransport {
         }
 
         const liveSelector = await findSelector(page, SELECTORS.live, 'submit control', this.stepTimeoutMs);
-        // Captured at the click, not at the draft: the draft run already moved the URL, and a
-        // pre-draft baseline would read that move as the submit's own outcome.
+        // Captured at the click, not at the entry: the entry already moved the URL to
+        // /draft/<id>, and an entry-time baseline would read that move as the submit's outcome.
         const urlBeforeSubmit = page.url();
         await page.locator(liveSelector).first().click();
         const live = await expectOutcome(() => probeLive(page, urlBeforeSubmit), {
@@ -260,13 +369,16 @@ export class InfoqBrowserTransport implements PublishTransport {
 }
 
 /**
- * Draft evidence (E91-D6): the editor URL moved onto an article id, or a visible save toast.
- * A URL that merely gained a query parameter is not evidence of a saved draft.
+ * The feature-notice modal overlays the editor and swallows click/fill events (measured 0201);
+ * it is not always shown, so dismissal is a guarded no-op when absent.
  */
-async function probeDraft(page: Page, urlBeforeSave: string): Promise<string | null> {
-    const url = page.url();
-    if (url !== urlBeforeSave && DRAFT_URL_ID_RE.test(url)) return url;
-    return readToast(page, DRAFT_TOASTS);
+async function dismissNoticeModal(page: Page, timeoutMs: number): Promise<void> {
+    const modal = page.locator(SELECTORS.noticeDismiss[0]).first();
+    try {
+        if ((await modal.count()) > 0) await modal.click({ timeout: Math.min(timeoutMs, 5_000) });
+    } catch {
+        // A modal that vanished between the count and the click needs no dismissal.
+    }
 }
 
 /** Live evidence: a visible submit toast, or a URL that moved off the URL the draft run left. */

package/plugins/publishings/infoq-pub/src/profile-check.ts

@@ -1,8 +1,10 @@
 /**
  * InfoQ profile-session capability (R5, AC3).
  *
- * `login` opens the editor in a headed browser and resolves only once InfoQ's readiness
- * predicate passes; `check` reopens the profile headlessly and reports `verified` or `refused`.
+ * `login` opens the InfoQ home in a headed browser and resolves only once the readiness
+ * predicate passes (hydrated write entry, no visible 登录 control); `check` reopens the profile
+ * headlessly and reports `verified` or `refused` — on InfoQ a headless pass always 451s at the
+ * WAF (measured 0201 + 0191), so a refusal is retried once headed.
  * Arg parsing, profile precedence (`--profile` > `INFOQ_PROFILE_DIR` > `KK_BROWSER_PROFILE_DIR` >
  * `~/.config/kk/browser-profiles/infoq`) and the exit codes (0 verified, 1 refused, 2 usage
  * error) all live in the shared `runProfileCli` (0183), so the publish preflight and this CLI