dsh-browser-playwright-codex 0.6.6 → 0.7.0

package/lib/settings-card.js

@@ -0,0 +1,268 @@
+/**
+ * Settings card host half, absorbed from dsh-browser-toggle 0.3.0 (2026-10-19).
+ * Same four /api/browser-playwright routes and CSRF rules; the only change is that the
+ * runtime state is now a sibling module instead of a package specifier.
+ *
+ * @module dsh-browser-playwright-codex/settings-card
+ */
+// @ts-nocheck — absorbed verbatim from the standalone package (plain JS), typed later.
+/**
+ * dsh-browser-toggle - Host half.
+ *
+ * HTTP API for the Settings → Plugins UI card that flips the runtime enable
+ * flag of dsh-browser-playwright-codex without restarting DSH.
+ *
+ *   GET  /api/browser-playwright/state             -> { enabled, engine, engineUserChosen, allowEvaluate, allowCdp }
+ *   POST /api/browser-playwright/toggle {enabled}   -> { enabled, changed }
+ *   POST /api/browser-playwright/engine {engine}    -> { engine, changed }
+ *   POST /api/browser-playwright/gates {allowEvaluate, allowCdp} -> { allowEvaluate, allowCdp, changed }
+ *   GET  /api/browser-playwright/logins             -> { logins: { source, capturedAt, cookies, total, sites } | null }
+ *
+ * `allowEvaluate` / `allowCdp` are the two power gates of the browser tool
+ * family: arbitrary page JavaScript and raw CDP. They are registration-time
+ * settings (an off gate means the tool is not registered at all, which is how
+ * the plugin keeps them out of the resident prompt), so this route cannot flip
+ * them in memory — it writes them into the home-level cordis.patch.yml, the
+ * layer with the highest priority among patch files, and lets the profile's
+ * `patchReload: live` re-apply the tree. The Settings page therefore reads the
+ * *effective* values published by the tool family (runtime-state.getGates),
+ * never a guess at the package default.
+ *
+ * The package itself ships both gates off: cordis.patch.yml travels inside the
+ * package, so anything it enabled would be enabled for every installer. This
+ * route is how a user opts in, in their own layer.
+ *
+ * `engine` is the page-reading mode: 'legacy' (the plugin's own DOM walk) or
+ * 'aria' (the browser's official accessibility tree). It is a user setting too,
+ * so it lives next to the enable flag and applies from the next operation on —
+ * no restart, no config edit. `engineUserChosen` says whether the current mode
+ * is the user's own pick or still the configured default.
+ *
+ * The enable flag lives in dsh-browser-playwright-codex's shared module
+ * (lib/runtime-state.js, persisted to ~/.dsh/dsh-browser-playwright.state.json —
+ * the file name is intentionally stable across package renames so the user's
+ * saved switch survives). Importing it through the package export
+ * gives this plugin the SAME module instance as the playwright provider, so
+ * flipping the flag here triggers the provider's disable-subscription (tears
+ * down any open window) in-process, and every future browser acquire is
+ * rejected while disabled.
+ *
+ * The specifier below must match the provider package's package.json#name.
+ * 2026-09-30: the provider was renamed to *-codex; the old specifier stopped
+ * resolving (MODULE_NOT_FOUND) and the toggle failed to load, so the import and
+ * the node_modules link have to move together with the rename.
+ *
+ * CSRF: POST requires the custom `x-dsh-plugin: browser-toggle` header, the
+ * same pattern as dsh-local-switch.
+ */
+// Namespace import on purpose: this host half and the provider package are
+// separate plugins, and a profile that is still running an older provider build
+// would otherwise fail at link time with "does not provide an export named".
+// Missing helpers degrade to "unknown" instead of breaking the Settings page.
+import * as runtimeState from "./runtime-state.js";
+// The patch writer lives in its own dependency-free module so it can be tested
+// without a DSH host (a half-written patch layer would break every plugin load).
+import { homePatchPath, parseGatesBlock, writeGates } from "./gates-patch.js";
+import { readFileSync } from 'node:fs';
+const { getEnabled, setEnabled, getEffectiveEngine, setSnapshotEngine, isEngineUserChosen } = runtimeState;
+export const name = 'browser-toggle';
+export const inject = ['webServer'];
+const PREFIX = '/api/browser-playwright';
+const HEADER = 'x-dsh-plugin';
+/** Read the gates the tool family published, or undefined while unknown. */
+function readGates() {
+    if (typeof runtimeState.getGates !== 'function')
+        return undefined;
+    try {
+        const gates = runtimeState.getGates();
+        if (gates && typeof gates.allowEvaluate === 'boolean' && typeof gates.allowCdp === 'boolean')
+            return gates;
+    }
+    catch {
+        /* fall through to unknown */
+    }
+    return undefined;
+}
+/**
+ * Report the current managed block (what the user's own layer says). The switch
+ * shows the *effective* gates from readGates(); this is the file-level view used
+ * for diagnostics when the two disagree (i.e. the reload has not landed yet).
+ */
+function managedBlockGates() {
+    try {
+        const text = readFileSync(homePatchPath(), 'utf8');
+        return parseGatesBlock(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function sendJson(res, status, payload) {
+    res.statusCode = status;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-store');
+    res.end(JSON.stringify(payload));
+}
+async function readBody(req) {
+    const chunks = [];
+    try {
+        for await (const chunk of req)
+            chunks.push(chunk);
+    }
+    catch (error) {
+        return { ok: false, error: String(error?.message ?? error) };
+    }
+    return { ok: true, text: Buffer.concat(chunks).toString('utf8') };
+}
+export function apply(ctx) {
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: `${PREFIX}/state`,
+        handler: async (req, res) => {
+            if (req.method !== 'GET')
+                return sendJson(res, 405, { error: { code: 'METHOD', message: 'GET only' } });
+            // Required even for a read: this exposes the deployment's switch state. A custom
+            // header forces a CORS preflight, which is what stops any other page in the
+            // browser from reading it off 127.0.0.1 (2026-10-16: only the POST routes had it).
+            if (req.headers[HEADER] !== 'browser-toggle')
+                return sendJson(res, 403, { error: { code: 'CSRF', message: 'missing plugin header' } });
+            const gates = readGates();
+            sendJson(res, 200, {
+                enabled: getEnabled(),
+                engine: getEffectiveEngine(),
+                engineUserChosen: isEngineUserChosen(),
+                // Effective values, published by the tool family itself. null = the
+                // provider build in this profile is too old to report them.
+                allowEvaluate: gates ? gates.allowEvaluate : null,
+                allowCdp: gates ? gates.allowCdp : null,
+                // What the user's own layer says right now. Differs from the above
+                // between a write and the live reload that applies it.
+                patchGates: managedBlockGates() ?? null,
+            });
+        },
+    }));
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: `${PREFIX}/toggle`,
+        handler: async (req, res) => {
+            if (req.method !== 'POST')
+                return sendJson(res, 405, { error: { code: 'METHOD', message: 'POST only' } });
+            if (req.headers[HEADER] !== 'browser-toggle')
+                return sendJson(res, 403, { error: { code: 'CSRF', message: 'missing plugin header' } });
+            const body = await readBody(req);
+            if (!body.ok)
+                return sendJson(res, 400, { error: { code: 'BODY_READ', message: body.error } });
+            let payload;
+            try {
+                payload = JSON.parse(body.text || '{}');
+            }
+            catch {
+                return sendJson(res, 400, { error: { code: 'INVALID_JSON', message: 'body must be JSON' } });
+            }
+            if (typeof payload.enabled !== 'boolean')
+                return sendJson(res, 400, { error: { code: 'INVALID_BODY', message: '`enabled` must be a boolean' } });
+            const changed = setEnabled(payload.enabled);
+            sendJson(res, 200, { enabled: getEnabled(), changed });
+        },
+    }));
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: `${PREFIX}/engine`,
+        handler: async (req, res) => {
+            if (req.method !== 'POST')
+                return sendJson(res, 405, { error: { code: 'METHOD', message: 'POST only' } });
+            if (req.headers[HEADER] !== 'browser-toggle')
+                return sendJson(res, 403, { error: { code: 'CSRF', message: 'missing plugin header' } });
+            const body = await readBody(req);
+            if (!body.ok)
+                return sendJson(res, 400, { error: { code: 'BODY_READ', message: body.error } });
+            let payload;
+            try {
+                payload = JSON.parse(body.text || '{}');
+            }
+            catch {
+                return sendJson(res, 400, { error: { code: 'INVALID_JSON', message: 'body must be JSON' } });
+            }
+            if (payload.engine !== 'legacy' && payload.engine !== 'aria')
+                return sendJson(res, 400, {
+                    error: { code: 'INVALID_BODY', message: '`engine` must be "legacy" or "aria"' },
+                });
+            const changed = setSnapshotEngine(payload.engine);
+            sendJson(res, 200, { engine: getEffectiveEngine(), changed });
+        },
+    }));
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: `${PREFIX}/gates`,
+        handler: async (req, res) => {
+            if (req.method !== 'POST')
+                return sendJson(res, 405, { error: { code: 'METHOD', message: 'POST only' } });
+            if (req.headers[HEADER] !== 'browser-toggle')
+                return sendJson(res, 403, { error: { code: 'CSRF', message: 'missing plugin header' } });
+            const body = await readBody(req);
+            if (!body.ok)
+                return sendJson(res, 400, { error: { code: 'BODY_READ', message: body.error } });
+            let payload;
+            try {
+                payload = JSON.parse(body.text || '{}');
+            }
+            catch {
+                return sendJson(res, 400, { error: { code: 'INVALID_JSON', message: 'body must be JSON' } });
+            }
+            if (typeof payload.allowEvaluate !== 'boolean' || typeof payload.allowCdp !== 'boolean')
+                return sendJson(res, 400, {
+                    error: {
+                        code: 'INVALID_BODY',
+                        message: '`allowEvaluate` and `allowCdp` must both be booleans',
+                    },
+                });
+            const before = readGates();
+            if (before && before.allowEvaluate === payload.allowEvaluate && before.allowCdp === payload.allowCdp)
+                return sendJson(res, 200, { ...before, changed: false, patch: null });
+            try {
+                const written = await writeGates(payload.allowEvaluate, payload.allowCdp);
+                // The effective values only move once the loader re-applies the tree
+                // (profile patchReload: live); report what was written, and let the
+                // panel's next /state poll show whether it took effect.
+                sendJson(res, 200, {
+                    allowEvaluate: written.allowEvaluate,
+                    allowCdp: written.allowCdp,
+                    changed: true,
+                    patch: written.patch,
+                });
+            }
+            catch (error) {
+                sendJson(res, 500, {
+                    error: { code: 'PATCH_WRITE', message: String(error?.message ?? error) },
+                });
+            }
+        },
+    }));
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: `${PREFIX}/logins`,
+        handler: async (req, res) => {
+            if (req.method !== 'GET')
+                return sendJson(res, 405, { error: { code: 'METHOD', message: 'GET only' } });
+            // The CSRF header is mandatory here, and this route is the reason the rule exists:
+            // the payload is a list of the sites this browser is signed in to. A custom header
+            // forces a preflight, so no other page in the browser can read it off 127.0.0.1.
+            if (req.headers[HEADER] !== 'browser-toggle')
+                return sendJson(res, 403, { error: { code: 'CSRF', message: 'missing plugin header' } });
+            // Read-only, display-only: the provider publishes this summary (counts and domain
+            // names, never cookie values or names). null = nothing published yet, or the
+            // provider build in this profile is too old to publish it.
+            let logins = null;
+            if (typeof runtimeState.getLoginSites === 'function') {
+                try {
+                    logins = runtimeState.getLoginSites() ?? null;
+                }
+                catch {
+                    logins = null;
+                }
+            }
+            sendJson(res, 200, { logins });
+        },
+    }));
+}
+export default { name, inject, apply };

package/lib/snapshot-render.d.ts

@@ -4,6 +4,18 @@
  * @module dsh-browser-playwright-codex/snapshot-render
  */
 import type { BrowserNode, BrowserSnapshot, SnapshotDiff } from './types.ts';
+/** Default cap for a rendered href, in characters. */
+export declare const MAX_HREF_LENGTH = 160;
+/**
+ * Trim a href for display: drop analytics parameters and clip the whole thing.
+ * The snapshot's refs remain the interaction handle, so this only affects what
+ * the model reads, never what a click does.
+ *
+ * @param href - the raw href from the accessibility tree
+ * @param maxLength - display budget in characters
+ * @returns the shortened href
+ */
+export declare function trimUrlForDisplay(href: string, maxLength?: number): string;
 /**
  * Render a node tree as indented lines, one element per line.
  * @param nodes - the snapshot's root nodes.

package/lib/snapshot-render.js

@@ -3,8 +3,106 @@
  * functions run on live calls and on session replay alike.
  * @module dsh-browser-playwright-codex/snapshot-render
  */
+/**
+ * Query parameters that only feed analytics or the site's own ranking pipeline.
+ * They make a rendered href several times longer than the link it names and the
+ * model never needs them: the ref (not the URL) is what clicks.
+ */
+const TRACKING_PARAMS = new Set([
+    'gclid',
+    'dclid',
+    'fbclid',
+    'msclkid',
+    'yclid',
+    'spm',
+    'scm',
+    'share_token',
+    'rsv_spt',
+    'rsv_iqid',
+    'rsv_bp',
+    'rsv_idx',
+    'rsv_enter',
+    'rsv_pq',
+    'rsv_t',
+    'rsv_dl',
+    'rsv_sug1',
+    'rsv_sug2',
+    'rsv_sug3',
+    'rsv_sug4',
+    'rsv_sug5',
+    'rsv_sug6',
+    'rsv_sug7',
+    'rsv_sug8',
+    'rsv_sug9',
+    'rsv_sug10',
+    'sa',
+    'usm',
+    'rqid',
+    'rsf',
+]);
+/** Default cap for a rendered href, in characters. */
+export const MAX_HREF_LENGTH = 160;
+/** Clip a string to a display budget, marking the cut. */
+function clip(value, maxLength) {
+    return value.length <= maxLength ? value : value.slice(0, maxLength - 1) + '…';
+}
+/**
+ * Trim a href for display: drop analytics parameters and clip the whole thing.
+ * The snapshot's refs remain the interaction handle, so this only affects what
+ * the model reads, never what a click does.
+ *
+ * @param href - the raw href from the accessibility tree
+ * @param maxLength - display budget in characters
+ * @returns the shortened href
+ */
+export function trimUrlForDisplay(href, maxLength = MAX_HREF_LENGTH) {
+    const hashAt = href.indexOf('#');
+    const hash = hashAt >= 0 ? href.slice(hashAt) : '';
+    const head = hashAt >= 0 ? href.slice(0, hashAt) : href;
+    const queryAt = head.indexOf('?');
+    if (queryAt < 0)
+        return clip(head + hash, maxLength);
+    const base = head.slice(0, queryAt);
+    const kept = head
+        .slice(queryAt + 1)
+        .split('&')
+        .filter((pair) => pair !== '')
+        .filter((pair) => {
+        let key = pair.split('=')[0] ?? '';
+        try {
+            key = decodeURIComponent(key);
+        }
+        catch {
+            /* keep the raw key: an undecodable one is not a known tracker */
+        }
+        key = key.toLowerCase();
+        return !key.startsWith('utm_') && !TRACKING_PARAMS.has(key);
+    });
+    return clip(base + (kept.length > 0 ? '?' + kept.join('&') : '') + hash, maxLength);
+}
+/**
+ * A wrapper element with no name, ref, state or link of its own. Keeping it
+ * would push every real element one level deeper and repeat the word "generic"
+ * for every <div> on the page; dropping it keeps the structure the model needs
+ * (nesting of things that have names) without the noise.
+ */
+function isTransparentWrapper(node) {
+    return (node.role === 'generic' &&
+        node.name === '' &&
+        node.ref === undefined &&
+        node.href === undefined &&
+        node.level === undefined &&
+        node.checked === undefined &&
+        node.selected === undefined &&
+        node.disabled === undefined);
+}
 /** Render one node line into the accumulating line list. */
 function renderNode(node, depth, lines) {
+    if (isTransparentWrapper(node)) {
+        for (const child of node.children)
+            renderNode(child, depth, lines);
+        return;
+    }
     const indent = '  '.repeat(depth);
     let line = indent + '- ' + node.role;
     if (node.name !== '')
@@ -23,7 +121,7 @@ function renderNode(node, depth, lines) {
     if (flags.length > 0)
         line += ' [' + flags.join(', ') + ']';
     if (node.href !== undefined)
-        line += ' -> ' + node.href;
+        line += ' -> ' + trimUrlForDisplay(node.href);
     lines.push(line);
     for (const child of node.children)
         renderNode(child, depth + 1, lines);

package/lib/tool.d.ts

@@ -31,6 +31,12 @@ export interface ToolConfig {
      * its schema would sit in the system prompt on every turn for nothing.
      */
     registerDisabledTools: boolean;
+    /**
+     * Register the two diagnostics tools (console messages, network requests).
+     * Defaults to false: they exist to debug a failed run, and their schemas
+     * would otherwise sit in the system prompt on every turn.
+     */
+    diagnostics: boolean;
     /** Upper bound for browser_wait in milliseconds. */
     maxWaitMs: number;
     /** Default value of the snapshot tool's interactiveOnly flag. */

package/lib/tool.js

@@ -21,6 +21,7 @@ export const Config = z.object({
     allowEvaluate: z.boolean().default(false),
     allowCdp: z.boolean().default(false),
     registerDisabledTools: z.boolean().default(false),
+    diagnostics: z.boolean().default(false),
     maxWaitMs: z.number().default(60000),
     interactiveOnlyDefault: z.boolean().default(false),
     extract: z.object({
@@ -50,6 +51,7 @@ export function apply(ctx, config) {
         allowEvaluate: config.allowEvaluate,
         allowCdp: config.allowCdp,
         extractConfigured: config.extract?.provider !== undefined && config.extract?.model !== undefined,
+        diagnostics: config.diagnostics,
         registerDisabledTools: config.registerDisabledTools,
     };
     const registered = new Set(registeredSuffixes(surface));
@@ -262,6 +264,8 @@ export function apply(ctx, config) {
         description: 'Replace the value of the input or select referenced by the latest snapshot. ' +
             '`value` is accepted as an alias of `text`. ' +
             'For <select> elements the text selects the matching option label. ' +
+            'Credential fields (password, one-time code, card number) are refused with CREDENTIAL_FIELD: ' +
+            'a human types secrets in the visible window, so ask them and re-snapshot instead. ' +
             'IRON RULE: after filling, verify in the returned snapshot that the field actually holds the value. ' +
             'Frameworks can silently reject or transform input (controlled components, contenteditable editors, ' +
             'input-mask/currency fields). If the value is wrong or missing, do NOT blindly re-fill or append — ' +
@@ -584,58 +588,62 @@ export function apply(ctx, config) {
             return (await session.cdp(args.method, args.params ?? {}, exec.signal));
         },
     }));
-    ctx.tools.register(defineTool({
-        name: p('console_messages'),
-        description: 'Return recent console messages and uncaught page errors from the tab this session is driving, newest last. ' +
-            'Use it right after an action that reported success but produced no visible change: a thrown page error or a failed ' +
-            'subresource is the usual reason a click or fill did not take effect. Read-only observation, it never acts on the page. ' +
-            'Capture starts when this session first drives a tab, so an empty list on a fresh tab is normal. ' +
-            'In persistent mode all sessions share one window, so entries describe that shared page.',
-        parameters: {
-            level: {
-                type: 'string',
-                description: "Filter by level: 'all' (default), 'error' (errors + uncaught page errors), 'warning', 'info', 'log', 'debug'.",
+    if (config.diagnostics || config.registerDisabledTools) {
+        ctx.tools.register(defineTool({
+            name: p('console_messages'),
+            description: 'Return recent console messages and uncaught page errors from the tab this session is driving, newest last. ' +
+                'Use it right after an action that reported success but produced no visible change: a thrown page error or a failed ' +
+                'subresource is the usual reason a click or fill did not take effect. Read-only observation, it never acts on the page. ' +
+                'Capture starts when this session first drives a tab, so an empty list on a fresh tab is normal. ' +
+                'In persistent mode all sessions share one window, so entries describe that shared page.',
+            parameters: {
+                level: {
+                    type: 'string',
+                    description: "Filter by level: 'all' (default), 'error' (errors + uncaught page errors), 'warning', 'info', 'log', 'debug'.",
+                },
+                limit: { type: 'number', description: 'Max entries to return, newest last. Default 50, cap 200.' },
             },
-            limit: { type: 'number', description: 'Max entries to return, newest last. Default 50, cap 200.' },
-        },
-        output: {
-            schema: { type: 'json' },
-            render: (_args, value) => [
-                { type: 'text', text: renderDiagnostics('console', value) },
-            ],
-        },
-        async execute(args, exec) {
-            const session = await acquire(exec);
-            // The canonical value is a wire value; the framework types tool outputs as JSON.
-            return session.consoleMessages(args ?? {});
-        },
-    }));
-    ctx.tools.register(defineTool({
-        name: p('network_requests'),
-        description: 'Return recent network requests from the tab this session is driving, newest last: method, URL, status, ' +
-            'resource type, duration, and the failure text for requests that never completed. Use it to tell "the page did not ' +
-            'react" apart from "the request behind it failed", and to find the API call an action triggered. ' +
-            'Read-only; response bodies are not captured. In persistent mode all sessions share one window, so entries describe that shared page.',
-        parameters: {
-            urlContains: {
-                type: 'string',
-                description: 'Only return requests whose URL contains this substring (case-insensitive).',
+            output: {
+                schema: { type: 'json' },
+                render: (_args, value) => [
+                    { type: 'text', text: renderDiagnostics('console', value) },
+                ],
             },
-            failedOnly: { type: 'boolean', description: 'Only return requests that failed or returned status >= 400.' },
-            limit: { type: 'number', description: 'Max entries to return, newest last. Default 50, cap 200.' },
-        },
-        output: {
-            schema: { type: 'json' },
-            render: (_args, value) => [
-                { type: 'text', text: renderDiagnostics('network', value) },
-            ],
-        },
-        async execute(args, exec) {
-            const session = await acquire(exec);
-            // The canonical value is a wire value; the framework types tool outputs as JSON.
-            return session.networkRequests(args ?? {});
-        },
-    }));
+            async execute(args, exec) {
+                const session = await acquire(exec);
+                // The canonical value is a wire value; the framework types tool outputs as JSON.
+                return session.consoleMessages(args ?? {});
+            },
+        }));
+    }
+    if (config.diagnostics || config.registerDisabledTools) {
+        ctx.tools.register(defineTool({
+            name: p('network_requests'),
+            description: 'Return recent network requests from the tab this session is driving, newest last: method, URL, status, ' +
+                'resource type, duration, and the failure text for requests that never completed. Use it to tell "the page did not ' +
+                'react" apart from "the request behind it failed", and to find the API call an action triggered. ' +
+                'Read-only; response bodies are not captured. In persistent mode all sessions share one window, so entries describe that shared page.',
+            parameters: {
+                urlContains: {
+                    type: 'string',
+                    description: 'Only return requests whose URL contains this substring (case-insensitive).',
+                },
+                failedOnly: { type: 'boolean', description: 'Only return requests that failed or returned status >= 400.' },
+                limit: { type: 'number', description: 'Max entries to return, newest last. Default 50, cap 200.' },
+            },
+            output: {
+                schema: { type: 'json' },
+                render: (_args, value) => [
+                    { type: 'text', text: renderDiagnostics('network', value) },
+                ],
+            },
+            async execute(args, exec) {
+                const session = await acquire(exec);
+                // The canonical value is a wire value; the framework types tool outputs as JSON.
+                return session.networkRequests(args ?? {});
+            },
+        }));
+    }
     ctx.tools.register(defineTool({
         name: p('close'),
         description: "Release this session's browser window. Persistent mode shares one window, so it closes only when the last session releases it; the profile keeps login state either way, so the next browser call reopens it still signed in (reset the profile to clear cookies).",

package/locale/en.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "Browser Automation",
-    "description": "Playwright-powered browser capability for DeepSeek Harness: accessibility-snapshot interaction with stable element refs, session-scoped browser sessions, screenshots as attachments."
+    "description": "Playwright-powered browser capability for DeepSeek Harness: accessibility-snapshot interaction with stable element refs, session-scoped browser sessions, screenshots as attachments — with the Settings card (on/off, page-reading mode, capability gates, signed-in sites) built in."
   }
 }

package/locale/zh.json

@@ -1,6 +1,6 @@
 {
   "meta": {
     "title": "浏览器自动化",
-    "description": "浏览器自动化（Playwright）：无障碍快照交互 + 稳定元素引用、会话级浏览器实例、截图作为附件。"
+    "description": "浏览器自动化（Playwright）：无障碍快照交互 + 稳定元素引用 + 会话级浏览器实例 + 截图附件；自带设置卡（总开关 / 页面识别方式 / 强力工具闸门 / 已登录站点名单）。"
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-browser-playwright-codex",
-  "version": "0.6.6",
-  "description": "Browser automation for DeepSeek Harness: fill in forms, scrape lists and work across tabs in real pages, using the logins you already have. Runs in a visible window that stays quiet when minimised, and stops for sign-ins, CAPTCHAs and native dialogs instead of confirming for you.",
+  "version": "0.7.0",
+  "description": "Browser automation for DeepSeek Harness, one plugin: fill in forms, scrape lists and work across tabs in real pages, using the logins you already have. Runs in a visible window that stays quiet when minimised; native dialogs are parked instead of confirmed, CAPTCHA pages are flagged with a note that says stop and hand the page back, password / one-time-code / card fields are refused by browser_fill, and the Settings card (enable/disable, page-reading mode, capability gates) now lives inside this package.",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",
@@ -28,7 +28,14 @@
     },
     "./cordis.patch.yml": "./cordis.patch.yml",
     "./package.json": "./package.json",
-    "./locale/*.json": "./locale/*.json"
+    "./locale/*.json": "./locale/*.json",
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./plugin": {
+      "types": "./lib/plugin.d.ts",
+      "default": "./lib/plugin.js"
+    }
   },
   "files": [
     "lib",
@@ -42,7 +49,7 @@
     "scripts/dsh-browser-verify.mjs"
   ],
   "scripts": {
-    "build": "node node_modules/typescript/bin/tsc -p tsconfig.json",
+    "build": "node node_modules/typescript/bin/tsc -p tsconfig.json && node scripts/build-client.mjs",
     "typecheck": "node node_modules/typescript/bin/tsc -p tsconfig.tests.json",
     "test": "node --test \"tests/*.test.ts\"",
     "test:scenarios": "node --test tests/scenarios.test.ts tests/tool-scenarios.test.ts",
@@ -82,8 +89,21 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": []
     }
   },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "packageManager": "pnpm@10.31.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/miqian-nomad/dsh-browser-playwright-codex.git"
+  },
+  "homepage": "https://github.com/miqian-nomad/dsh-browser-playwright-codex#readme",
   "keywords": [
     "deepseek-harness",
     "dsh",
@@ -98,15 +118,7 @@
     "form-filling",
     "deepseek",
     "ai-agent",
-    "rpa"
-  ],
-  "engines": {
-    "node": "^22.19.0 || >=24.0.0"
-  },
-  "packageManager": "pnpm@10.31.0",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/miqian-nomad/dsh-browser-playwright-codex.git"
-  },
-  "homepage": "https://github.com/miqian-nomad/dsh-browser-playwright-codex#readme"
+    "rpa",
+    "settings"
+  ]
 }