@gobing-ai/knowledge-kit 0.0.34 → 0.0.36

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

@@ -126,8 +126,29 @@ export async function openWechatLogin(opts: { profileDir: string; timeoutMs?: nu
     }
 }
 
-/** Launch, inject the saved login cookies, and land on the console. Caller owns closing the context. */
-async function openWithState(profileDir: string, headless: boolean): Promise<{ page: Page; context: BrowserContext }> {
+/**
+ * Bot-mode open (0277): restore the durable storage state, land on the console (or `url`), and
+ * resolve once the operator closes the browser — no auth assertion, the `check` verb owns that.
+ */
+export async function openWechatSession(
+    profileDir: string,
+    opts: { headless?: boolean; url?: string } = {},
+): Promise<void> {
+    const { context } = await openWithState(profileDir, opts.headless ?? false, opts.url ?? CONSOLE_URL);
+    // Structural cast (this plugin's tsconfig resolves a playwright build whose context event map
+    // omits 'close'); the runtime context always emits it.
+    const closable = context as unknown as { once(event: 'close', listener: () => void): unknown };
+    await new Promise<void>((resolveClose) => {
+        closable.once('close', resolveClose);
+    });
+}
+
+/** Launch, inject the saved login cookies, and land on the console (or `url`). Caller owns closing the context. */
+async function openWithState(
+    profileDir: string,
+    headless: boolean,
+    url: string = CONSOLE_URL,
+): Promise<{ page: Page; context: BrowserContext }> {
     const context = await openPersistentBrowser({ profileDir, headless, launcher: kkBrowserLauncher });
     try {
         const stateFile = storageStatePath(profileDir);
@@ -164,7 +185,7 @@ async function openWithState(profileDir: string, headless: boolean): Promise<{ p
                 )
                 .catch(() => undefined);
         }
-        await page.goto(CONSOLE_URL);
+        await page.goto(url);
         return { page, context };
     } catch (error: unknown) {
         await context.close();

package/plugins/publishings/wechatmp-pub/src/page.ts

@@ -68,6 +68,22 @@ export interface OpenedConsole {
 
 export type OpenConsole = (profileDir: string) => Promise<OpenedConsole>;
 
+/**
+ * Modal state measured from the live DOM. A throwing or non-boolean probe is `unknown` — never
+ * `closed` (task 0260 R3: an unreadable overlay must not be treated as cleaned up, or a later step
+ * clicks through a footer it cannot see).
+ */
+export async function modalState(page: WechatPage): Promise<'closed' | 'open' | 'unknown'> {
+    try {
+        const raw = await page.evaluate(
+            `[...document.querySelectorAll('.weui-desktop-dialog__wrp, .weui-desktop-dialog')].some((d) => d.offsetWidth)`,
+        );
+        return raw === true ? 'open' : raw === false ? 'closed' : 'unknown';
+    } catch {
+        return 'unknown';
+    }
+}
+
 /** A selector with an ATTACHED match (hidden inputs included), or `undefined` at the deadline. */
 async function tryFindAttachedSelector(
     page: WechatPage,
@@ -258,3 +274,23 @@ export function wrapPlaywrightContext(raw: unknown, entryPage: unknown): OpenedC
         close: () => context.close(),
     };
 }
+
+/** Polls a selector list for visibility; optionally returns `undefined` instead of throwing. */
+export async function waitForVisible(
+    page: WechatPage,
+    selector: string,
+    timeoutMs: number,
+    opts: { required?: boolean } = {},
+): Promise<string | undefined> {
+    const visible = await waitUntil(
+        async () => {
+            const found = await trySelectors(page, [selector]).catch(() => ({ found: false, selector: null }));
+            return found.found;
+        },
+        timeoutMs,
+        POLL_MS,
+    );
+    if (visible) return selector;
+    if (opts.required === false) return undefined;
+    throw new Error(`${selector}: not visible within ${timeoutMs}ms`);
+}

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

@@ -5,16 +5,19 @@
  * captures the durable `storageState` file — mp.weixin.qq.com grant cookies do not survive a
  * Chromium restart, so the saved state (not the profile cookie store) is the session artifact.
  * `check` reopens the profile with that state re-injected and reports `verified` or `refused`
- * as the LAST line on stdout, one JSON object — `kk plugin check` parses it. Exit codes:
+ * as the LAST line on stdout, one JSON object — `kk plugin check` parses it. In bot mode (the
+ * `kk bot login` parent supplies `--url`) `login` emits the same shape plus the plugin-owned
+ * canonical `defaultUrl`, which is the only thing the parent persists. Exit codes:
  * 0 verified, 1 refused, 2 usage error. No cookie, token or storageState value is ever printed;
  * the profile directory is the only detail that leaves the process.
  */
 import { parseArgs } from 'node:util';
 import { resolveChannelProfileDir } from '@gobing-ai/publish-harness/browser';
 import { echo, echoError } from '@gobing-ai/ts-utils';
-import { CHANNEL, checkWechatSession, openWechatLogin } from './index';
+import { CHANNEL, CONSOLE_URL, checkWechatSession, openWechatLogin, openWechatSession } from './index';
 
-const USAGE = 'usage: wechatmp profile-check [login|check] [--profile <dir>] [--timeout <ms>] [--headed]';
+const USAGE =
+    'usage: wechatmp profile-check [login|check|open] [--profile <dir>] [--url <url>] [--timeout <ms>] [--headed]';
 const LOGIN_TIMEOUT_MS = 180_000;
 
 interface WechatVerdict {
@@ -28,6 +31,7 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<numb
     let profileDir: string;
     let timeoutMs: number | undefined;
     let headed = false;
+    let sessionUrl: string | undefined;
     try {
         const { positionals, values } = parseArgs({
             args: argv,
@@ -36,12 +40,17 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<numb
                 profile: { type: 'string' },
                 timeout: { type: 'string' },
                 headed: { type: 'boolean' },
+                url: { type: 'string' },
             },
         });
         command = positionals[0] ?? 'check';
-        if (command !== 'login' && command !== 'check') {
+        if (command !== 'login' && command !== 'check' && command !== 'open') {
             throw new Error(`unknown command '${command}'`);
         }
+        if (command === 'open' && (values.profile === undefined || values.url === undefined)) {
+            throw new Error('open requires an explicit --profile <dir> and --url <url>');
+        }
+        sessionUrl = values.url;
         headed = values.headed === true;
         if (values.timeout !== undefined) {
             timeoutMs = Number(values.timeout);
@@ -61,6 +70,12 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<numb
         try {
             await openWechatLogin({ profileDir, timeoutMs: timeoutMs ?? LOGIN_TIMEOUT_MS });
             echo(`wechatmp profile login verified: ${profileDir}`);
+            // Bot mode (`kk bot login` supplies --url): the parent persists a default URL only from
+            // this LAST-line verdict, and only the plugin-owned console home is canonical — never the
+            // operator's URL. Without --url the operator-mode output stands unchanged.
+            if (sessionUrl !== undefined) {
+                echo(JSON.stringify({ status: 'verified', profileDir, defaultUrl: CONSOLE_URL }));
+            }
             return 0;
         } catch (error) {
             echoError(`wechatmp profile login failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -68,6 +83,27 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<numb
         }
     }
 
+    if (command === 'open') {
+        // Bot-mode open (0277): restore the durable state and wait for the operator to close the
+        // browser — no readiness assertion. A missing state file refuses (nothing is fabricated).
+        try {
+            await openWechatSession(profileDir, { url: sessionUrl });
+            echo(
+                JSON.stringify({
+                    status: 'verified',
+                    profileDir,
+                    detail: `wechatmp profile session closed by the operator: ${profileDir}`,
+                }),
+            );
+            return 0;
+        } catch (error) {
+            const detail = `wechatmp profile open refused: ${error instanceof Error ? error.message : String(error)}`;
+            echoError(detail);
+            echo(JSON.stringify({ status: 'refused', profileDir, detail }));
+            return 1;
+        }
+    }
+
     let verdict: WechatVerdict;
     try {
         await checkWechatSession(profileDir, { headless: !headed, timeoutMs });