dsh-browser-playwright-codex 0.7.1 → 0.7.4

package/lib/runtime-state.d.ts

@@ -33,6 +33,26 @@ export declare function getEnabled(): boolean;
 export declare function setEnabled(next: boolean): boolean;
 /** Subscribe to enable-state transitions. Returns an unsubscribe function. */
 export declare function subscribe(fn: (enabled: boolean) => void): () => void;
+/**
+ * The window mode the user picked (true = headless), or undefined when they
+ * never picked one — the configured default then applies.
+ */
+export declare function getHeadless(): boolean | undefined;
+/** Persist the window-mode choice. Returns true when the value changed. */
+export declare function setHeadless(next: boolean): boolean;
+/** Publish the configured default (launch.headless) for display. */
+export declare function publishConfiguredHeadless(value: boolean): void;
+/** The configured default, when the provider has published it. */
+export declare function getConfiguredHeadless(): boolean | undefined;
+/**
+ * Effective window mode: the user's choice, else the configured default, else
+ * the shipped default (headful).
+ *
+ * @param configuredFallback - config default when the provider has not published one
+ */
+export declare function getEffectiveHeadless(configuredFallback?: boolean): boolean;
+/** Did the user pick the window mode themselves? (The card shows "你选的".) */
+export declare function isHeadlessUserChosen(): boolean;
 /**
  * The page-reading mode the user picked, or undefined when they never picked
  * one — the configured default then applies.

package/lib/runtime-state.js

@@ -12,6 +12,10 @@ function stateFile() {
 }
 let _enabled = true;
 let _engine = undefined;
+/** User's window-mode choice: true = headless, undefined = follow the config. */
+let _headless = undefined;
+/** Config default pushed in by the provider (display only). */
+let _configuredHeadless = undefined;
 /** Default pushed in by the provider that is actually loaded (display only). */
 let _configuredEngine = undefined;
 /** Effective tool gates, pushed in by the tool family when it is applied (display only). */
@@ -33,6 +37,9 @@ function load() {
             // unknown value means "follow the configured default" (undefined here).
             // Files written before this setting existed therefore stay valid.
             _engine = obj.engine === 'legacy' || obj.engine === 'aria' ? obj.engine : undefined;
+            // Same contract as engine: absent/unknown means "follow the configured
+            // default", so files written before this setting existed stay valid.
+            _headless = typeof obj.headless === 'boolean' ? obj.headless : undefined;
         }
     }
     catch {
@@ -60,6 +67,8 @@ function persist() {
         // Keep the historical shape until the user actually picks a page-reading
         // mode: an absent `engine` means "use the configured default".
         const payload = _engine === undefined ? { enabled: _enabled } : { enabled: _enabled, engine: _engine };
+        if (_headless !== undefined)
+            payload.headless = _headless;
         fs.writeFileSync(tmp, JSON.stringify(payload, null, 2));
         fs.renameSync(tmp, target);
     }
@@ -99,6 +108,50 @@ export function subscribe(fn) {
         _subscribers.delete(fn);
     };
 }
+/**
+ * The window mode the user picked (true = headless), or undefined when they
+ * never picked one — the configured default then applies.
+ */
+export function getHeadless() {
+    load();
+    return _headless;
+}
+/** Persist the window-mode choice. Returns true when the value changed. */
+export function setHeadless(next) {
+    load();
+    if (typeof next !== 'boolean')
+        return false;
+    if (_headless === next)
+        return false;
+    _headless = next;
+    persist();
+    return true;
+}
+/** Publish the configured default (launch.headless) for display. */
+export function publishConfiguredHeadless(value) {
+    _configuredHeadless = value === true;
+}
+/** The configured default, when the provider has published it. */
+export function getConfiguredHeadless() {
+    return _configuredHeadless;
+}
+/**
+ * Effective window mode: the user's choice, else the configured default, else
+ * the shipped default (headful).
+ *
+ * @param configuredFallback - config default when the provider has not published one
+ */
+export function getEffectiveHeadless(configuredFallback = false) {
+    load();
+    if (_headless !== undefined)
+        return _headless;
+    return _configuredHeadless !== undefined ? _configuredHeadless : configuredFallback === true;
+}
+/** Did the user pick the window mode themselves? (The card shows "你选的".) */
+export function isHeadlessUserChosen() {
+    load();
+    return _headless !== undefined;
+}
 /**
  * The page-reading mode the user picked, or undefined when they never picked
  * one — the configured default then applies.

package/lib/settings-card.js

@@ -64,6 +64,7 @@ import * as runtimeState from "./runtime-state.js";
 // 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';
+import { clean, isTargetId, resolvePaths, scan } from "./cache-clean.js";
 const { getEnabled, setEnabled, getEffectiveEngine, setSnapshotEngine, isEngineUserChosen } = runtimeState;
 export const name = 'browser-toggle';
 export const inject = ['webServer'];
@@ -114,7 +115,121 @@ async function readBody(req) {
     }
     return { ok: true, text: Buffer.concat(chunks).toString('utf8') };
 }
+/** The plugin's own version, used to refuse other versions' installers. */
+function installedVersion() {
+    try {
+        const raw = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        return typeof raw.version === 'string' ? raw.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Resolved disk locations; never taken from the request body. */
+function diskPaths() {
+    return resolvePaths(process.env, installedVersion());
+}
+/**
+ * GET /disk/stat — sizes per bucket; POST /disk/clean — preview or execute.
+ * Both require the CSRF header, both answer with per-target detail so partial
+ * failures are visible instead of being folded into one number.
+ */
+function registerDiskRoutes(ctx) {
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: PREFIX + '/disk/stat',
+        handler: async (req, res) => {
+            if (req.method !== 'GET')
+                return sendJson(res, 405, { error: { code: 'METHOD', message: 'GET only' } });
+            if (req.headers[HEADER] !== 'browser-toggle')
+                return sendJson(res, 403, { error: { code: 'CSRF', message: 'missing plugin header' } });
+            try {
+                const report = await scan(diskPaths());
+                sendJson(res, 200, { ...report, browserActive: getEnabled() === true });
+            }
+            catch (error) {
+                sendJson(res, 500, { error: { code: 'DISK_SCAN', message: String(error && error.message ? error.message : error) } });
+            }
+        },
+    }));
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: PREFIX + '/disk/clean',
+        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.dryRun !== 'boolean')
+                return sendJson(res, 400, { error: { code: 'INVALID_BODY', message: '`dryRun` must be a boolean' } });
+            if (!Array.isArray(payload.targets) || payload.targets.length === 0)
+                return sendJson(res, 400, { error: { code: 'INVALID_BODY', message: '`targets` must be a non-empty array' } });
+            const targets = [];
+            for (const value of payload.targets) {
+                if (!isTargetId(value))
+                    return sendJson(res, 400, { error: { code: 'UNKNOWN_TARGET', message: 'unknown target: ' + String(value) } });
+                targets.push(value);
+            }
+            try {
+                const report = await clean({ ...diskPaths(), targets, dryRun: payload.dryRun, browserActive: getEnabled() === true });
+                sendJson(res, 200, report);
+            }
+            catch (error) {
+                sendJson(res, 500, { error: { code: 'DISK_CLEAN', message: String(error && error.message ? error.message : error) } });
+            }
+        },
+    }));
+}
+/**
+ * POST /window { headless } — the user's window-mode switch.
+ *
+ * The change is persisted immediately and applied by the provider on its next
+ * acquire (it compares the mode it launched with against the desired one and
+ * relaunches, exporting login state first). Nothing is killed mid-operation.
+ */
+function registerWindowRoute(ctx) {
+    ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: PREFIX + '/window',
+        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.headless !== 'boolean')
+                return sendJson(res, 400, { error: { code: 'INVALID_BODY', message: '`headless` must be a boolean' } });
+            const changed = runtimeState.setHeadless(payload.headless);
+            sendJson(res, 200, {
+                headless: runtimeState.getEffectiveHeadless(),
+                changed,
+                appliedOn: 'next-operation',
+            });
+        },
+    }));
+}
 export function apply(ctx) {
+    registerDiskRoutes(ctx);
+    registerWindowRoute(ctx);
     ctx.effect(() => ctx.webServer.register({
         kind: 'exact',
         path: `${PREFIX}/state`,
@@ -136,6 +251,9 @@ export function apply(ctx) {
                 allowEvaluate: gates ? gates.allowEvaluate : null,
                 allowCdp: gates ? gates.allowCdp : null,
                 diagnostics: gates ? gates.diagnostics : null,
+                headless: runtimeState.getEffectiveHeadless(),
+                headlessUserChosen: runtimeState.isHeadlessUserChosen(),
+                headlessConfigured: runtimeState.getConfiguredHeadless(),
                 // 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,

package/lib/tool-render.js

@@ -1,5 +1,6 @@
-import { CHALLENGE_NOTE, detectChallenge, detectSilentPage } from "./challenge.js";
+import { challengeNote, detectChallenge, detectSilentPage } from "./challenge.js";
 import { renderSnapshot, renderSnapshotDiff } from "./snapshot-render.js";
+import * as runtimeState from "./runtime-state.js";
 /**
  * Render one diagnostics payload as one line per entry. Diagnostics are read when
  * something already looks wrong, so the compact form matters more than the rich
@@ -134,7 +135,7 @@ export function snapshotValue(snapshot) {
                     ']: ' +
                     challenge.hint +
                     '.\n' +
-                    CHALLENGE_NOTE +
+                    challengeNote(runtimeState.getEffectiveHeadless(true)) +
                     '\n\n' +
                     tree) +
             diffBlock,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-browser-playwright-codex",
-  "version": "0.7.1",
+  "version": "0.7.4",
   "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",