@dsh-cove/dsh-web-all 0.0.0-stage → 0.4.4

package/lib/types/host/services/playwright-sessions/manager.js

@@ -0,0 +1,203 @@
+/**
+ * Per-session browser registry.
+ *
+ * Lazily creates one {@link SessionBrowser} per conversation and keeps the
+ * mapping stable while the session stays active: a session's first playwright
+ * tool call spawns its browser, every later call reuses it, and no other
+ * session can ever see it. Failure to create a handle removes the entry so the
+ * next call retries instead of wedging the session.
+ *
+ * Lifecycle guards (both optional via config):
+ * - idle TTL — unused browsers are disposed after `idleTimeoutMs`
+ * - concurrency cap — creating a new browser may dispose the least-recently
+ *   used idle browser so at most `maxConcurrentBrowsers` stay alive
+ */
+export class SessionBrowserManager {
+    factory;
+    options;
+    sessions = new Map();
+    now;
+    setTimeoutFn;
+    clearTimeoutFn;
+    constructor(factory, options) {
+        this.factory = factory;
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.setTimeoutFn = options.setTimeout ?? setTimeout;
+        this.clearTimeoutFn = options.clearTimeout ?? clearTimeout;
+    }
+    /** Resolve the browser for one session, creating it on first use. */
+    async get(sessionId) {
+        let entry = this.sessions.get(sessionId);
+        if (entry === undefined) {
+            await this.ensureCapacity(sessionId);
+            const browser = this.factory(sessionId).catch((error) => {
+                this.sessions.delete(sessionId);
+                throw error;
+            });
+            entry = { browser, lastUsedAt: this.now(), busy: 0 };
+            this.sessions.set(sessionId, entry);
+            this.armIdleTimer(sessionId, entry);
+        }
+        else {
+            this.touch(sessionId);
+        }
+        return this.wrap(sessionId, await entry.browser);
+    }
+    /** Number of sessions that have (or are creating) a browser. */
+    get size() {
+        return this.sessions.size;
+    }
+    /** Every session id currently tracked. */
+    ids() {
+        return [...this.sessions.keys()];
+    }
+    /** Whether a session currently owns (or is creating) a browser connection. */
+    has(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+    /**
+     * The host-owned persistent context of a session browser, when one exists
+     * AND was created in liveView mode (dual-owner). Never creates a browser:
+     * the live-view upgrade must not spawn a browser just because a client
+     * opened the view.
+     */
+    contextOf(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (entry === undefined)
+            return Promise.resolve(null);
+        return entry.browser.then(browser => browser.context ?? null, () => null);
+    }
+    /** Dispose one session browser and drop it from the registry. */
+    async dispose(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (entry === undefined)
+            return;
+        this.clearIdleTimer(entry);
+        this.sessions.delete(sessionId);
+        try {
+            await (await entry.browser).dispose();
+        }
+        catch {
+            // A failed creation leaves no browser to dispose.
+        }
+        try {
+            await this.options.onDispose?.(sessionId);
+        }
+        catch {
+            // Disk GC failures must not block browser lifecycle.
+        }
+    }
+    /** Close and dispose every session browser; the registry empties. */
+    async disposeAll() {
+        const ids = [...this.sessions.keys()];
+        await Promise.allSettled(ids.map((id) => this.dispose(id)));
+    }
+    /**
+     * Wrap call so each use refreshes the idle timer and marks the entry busy
+     * (idle eviction will not steal a browser mid-call).
+     */
+    wrap(sessionId, browser) {
+        return {
+            sessionId: browser.sessionId,
+            profileDir: browser.profileDir,
+            outputDir: browser.outputDir,
+            call: async (rawName, args, signal) => {
+                this.beginUse(sessionId);
+                try {
+                    return await browser.call(rawName, args, signal);
+                }
+                finally {
+                    this.endUse(sessionId);
+                }
+            },
+            close: () => browser.close(),
+            dispose: () => browser.dispose(),
+        };
+    }
+    beginUse(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (entry === undefined)
+            return;
+        entry.busy += 1;
+        this.touch(sessionId);
+    }
+    endUse(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (entry === undefined)
+            return;
+        entry.busy = Math.max(0, entry.busy - 1);
+        this.touch(sessionId);
+    }
+    touch(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (entry === undefined)
+            return;
+        entry.lastUsedAt = this.now();
+        this.armIdleTimer(sessionId, entry);
+    }
+    armIdleTimer(sessionId, entry) {
+        this.clearIdleTimer(entry);
+        const idleTimeoutMs = this.options.idleTimeoutMs;
+        if (idleTimeoutMs <= 0)
+            return;
+        entry.idleTimer = this.setTimeoutFn(() => {
+            void this.disposeIdle(sessionId);
+        }, idleTimeoutMs);
+    }
+    clearIdleTimer(entry) {
+        if (entry.idleTimer === undefined)
+            return;
+        this.clearTimeoutFn(entry.idleTimer);
+        entry.idleTimer = undefined;
+    }
+    /** Idle timer fired: dispose only if still idle and not busy. */
+    async disposeIdle(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (entry === undefined)
+            return;
+        if (entry.busy > 0) {
+            this.armIdleTimer(sessionId, entry);
+            return;
+        }
+        const idleTimeoutMs = this.options.idleTimeoutMs;
+        if (idleTimeoutMs > 0 && this.now() - entry.lastUsedAt < idleTimeoutMs) {
+            this.armIdleTimer(sessionId, entry);
+            return;
+        }
+        await this.dispose(sessionId);
+    }
+    /**
+     * Before creating `incomingId`, dispose LRU idle browsers until under the
+     * concurrency cap. Busy browsers are skipped; if every other browser is
+     * busy and the cap is still reached, the absolute LRU (including busy) is
+     * force-disposed so a new session can start.
+     */
+    async ensureCapacity(incomingId) {
+        const max = this.options.maxConcurrentBrowsers;
+        if (max <= 0)
+            return;
+        while (this.sessions.size >= max) {
+            const victim = this.pickEvictionVictim(incomingId, /*preferIdle*/ true)
+                ?? this.pickEvictionVictim(incomingId, /*preferIdle*/ false);
+            if (victim === undefined)
+                return;
+            await this.dispose(victim);
+        }
+    }
+    pickEvictionVictim(incomingId, preferIdle) {
+        let bestId;
+        let bestUsed = Number.POSITIVE_INFINITY;
+        for (const [id, entry] of this.sessions) {
+            if (id === incomingId)
+                continue;
+            if (preferIdle && entry.busy > 0)
+                continue;
+            if (entry.lastUsedAt < bestUsed) {
+                bestUsed = entry.lastUsedAt;
+                bestId = id;
+            }
+        }
+        return bestId;
+    }
+}

package/lib/types/host/services/playwright-sessions/profile-gc.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Disk GC for per-session Playwright profiles under `sessionsRoot`.
+ *
+ * Process-level idle eviction already stops Chromium/MCP children; this module
+ * reclaims the leftover profile directories (cookies, cache, screenshots) that
+ * otherwise grow without bound under `$DSH_HOME/playwright-sessions/`.
+ */
+export interface PruneProfilesOptions {
+    /** Absolute root that holds one directory per session. */
+    sessionsRoot: string;
+    /**
+     * Delete a profile directory when its mtime is older than this many ms.
+     * `0` disables age-based pruning.
+     */
+    maxAgeMs: number;
+    /** Session ids whose live browsers must not be deleted. */
+    keepSessionIds?: Iterable<string>;
+    /** Optional clock for tests. */
+    now?: () => number;
+}
+export interface PruneProfilesResult {
+    removed: string[];
+    skippedLive: string[];
+    errors: string[];
+}
+/** Resolve the on-disk profile directory for one durable session id. */
+export declare function profileDirFor(sessionsRoot: string, sessionId: string): string;
+/** Best-effort recursive remove of one session profile directory. */
+export declare function removeProfileDir(sessionsRoot: string, sessionId: string): boolean;
+/**
+ * Delete stale profile directories under `sessionsRoot`.
+ *
+ * A directory is removed when:
+ * - it is a direct child of `sessionsRoot`, and
+ * - its mtime is older than `maxAgeMs` (when maxAgeMs > 0), and
+ * - its basename is not the sanitized key of any id in `keepSessionIds`.
+ */
+export declare function pruneStaleProfiles(options: PruneProfilesOptions): PruneProfilesResult;
+//# sourceMappingURL=profile-gc.d.ts.map

package/lib/types/host/services/playwright-sessions/profile-gc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-gc.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/playwright-sessions/profile-gc.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,YAAY,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB,2DAA2D;IAC3D,cAAc,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;IACjC,gCAAgC;IAChC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AAED,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAKjF;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,oBAAoB,GAAG,mBAAmB,CA2CrF"}

package/lib/types/host/services/playwright-sessions/profile-gc.js

@@ -0,0 +1,72 @@
+/**
+ * Disk GC for per-session Playwright profiles under `sessionsRoot`.
+ *
+ * Process-level idle eviction already stops Chromium/MCP children; this module
+ * reclaims the leftover profile directories (cookies, cache, screenshots) that
+ * otherwise grow without bound under `$DSH_HOME/playwright-sessions/`.
+ */
+import { existsSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { sanitizePlaywrightSessionKey } from "../../../core/playwright-sessions/names.js";
+/** Resolve the on-disk profile directory for one durable session id. */
+export function profileDirFor(sessionsRoot, sessionId) {
+    return join(sessionsRoot, sanitizePlaywrightSessionKey(sessionId));
+}
+/** Best-effort recursive remove of one session profile directory. */
+export function removeProfileDir(sessionsRoot, sessionId) {
+    const dir = profileDirFor(sessionsRoot, sessionId);
+    if (!existsSync(dir))
+        return false;
+    rmSync(dir, { recursive: true, force: true });
+    return true;
+}
+/**
+ * Delete stale profile directories under `sessionsRoot`.
+ *
+ * A directory is removed when:
+ * - it is a direct child of `sessionsRoot`, and
+ * - its mtime is older than `maxAgeMs` (when maxAgeMs > 0), and
+ * - its basename is not the sanitized key of any id in `keepSessionIds`.
+ */
+export function pruneStaleProfiles(options) {
+    const removed = [];
+    const skippedLive = [];
+    const errors = [];
+    const now = options.now ?? Date.now;
+    const keep = new Set([...(options.keepSessionIds ?? [])].map((id) => sanitizePlaywrightSessionKey(id)));
+    if (!existsSync(options.sessionsRoot)) {
+        return { removed, skippedLive, errors };
+    }
+    if (options.maxAgeMs <= 0) {
+        return { removed, skippedLive, errors };
+    }
+    const cutoff = now() - options.maxAgeMs;
+    let entries;
+    try {
+        entries = readdirSync(options.sessionsRoot);
+    }
+    catch (err) {
+        errors.push(String(err));
+        return { removed, skippedLive, errors };
+    }
+    for (const name of entries) {
+        if (keep.has(name)) {
+            skippedLive.push(name);
+            continue;
+        }
+        const full = join(options.sessionsRoot, name);
+        try {
+            const st = statSync(full);
+            if (!st.isDirectory())
+                continue;
+            if (st.mtimeMs >= cutoff)
+                continue;
+            rmSync(full, { recursive: true, force: true });
+            removed.push(name);
+        }
+        catch (err) {
+            errors.push(`${name}: ${String(err)}`);
+        }
+    }
+    return { removed, skippedLive, errors };
+}

package/lib/types/host/services/playwright-sessions/routes.d.ts

@@ -0,0 +1,18 @@
+/** Loopback and same-origin control plane for the attended Chrome lease. */
+import type { IncomingMessage } from 'node:http';
+import type { Context } from '@deepseek-ai/cordis';
+import type { WebRoute } from '@deepseek-ai/dsh-host-webserver';
+import type { PlaywrightSessionsController } from './controller.ts';
+/**
+ * The strict loopback core fence for this control plane: a loopback socket,
+ * a loopback Host, and same-origin browser markers. The route family is mounted
+ * with the shared host access fence (see `registerPlaywrightControlRoutes`), so
+ * the deployment's canonical browser entry reaches the host's Chrome through an
+ * authenticated session; this predicate stays available for the loopback-only
+ * callers and tests.
+ */
+declare function trusted(request: IncomingMessage): boolean;
+export declare function makePlaywrightControlRoutes(controller: PlaywrightSessionsController, isTrusted?: (request: IncomingMessage) => boolean): WebRoute[];
+export declare function registerPlaywrightControlRoutes(ctx: Context, controller: PlaywrightSessionsController): () => void;
+export { trusted as trustedPlaywrightControlRequest };
+//# sourceMappingURL=routes.d.ts.map

package/lib/types/host/services/playwright-sessions/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/playwright-sessions/routes.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAkB,MAAM,WAAW,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AAI/D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAA;AAEnE;;;;;;;GAOG;AACH,iBAAS,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAElD;AA2BD,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,4BAA4B,EACxC,SAAS,GAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAiB,GACzD,QAAQ,EAAE,CAgCZ;AAED,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,4BAA4B,GAAG,MAAM,IAAI,CAIlH;AAED,OAAO,EAAE,OAAO,IAAI,+BAA+B,EAAE,CAAA"}

package/lib/types/host/services/playwright-sessions/routes.js

@@ -0,0 +1,87 @@
+import { PLAYWRIGHT_CONTROL_API_PREFIX, PlaywrightControlError } from "../../../core/playwright-sessions/control.js";
+import { isLoopbackRequest } from "../access-trust/trust.js";
+import { accessTrustOf } from "../access-trust/index.js";
+/**
+ * The strict loopback core fence for this control plane: a loopback socket,
+ * a loopback Host, and same-origin browser markers. The route family is mounted
+ * with the shared host access fence (see `registerPlaywrightControlRoutes`), so
+ * the deployment's canonical browser entry reaches the host's Chrome through an
+ * authenticated session; this predicate stays available for the loopback-only
+ * callers and tests.
+ */
+function trusted(request) {
+    return isLoopbackRequest(request);
+}
+function json(response, status, body) {
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store',
+        'x-content-type-options': 'nosniff',
+        'referrer-policy': 'no-referrer',
+    });
+    response.end(JSON.stringify(body));
+}
+async function body(request, maxBytes = 16 * 1024) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += value.length;
+        if (size > maxBytes)
+            return null;
+        chunks.push(value);
+    }
+    try {
+        const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        return typeof parsed === 'object' && parsed !== null ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function makePlaywrightControlRoutes(controller, isTrusted = trusted) {
+    const handler = async (request, response) => {
+        if (!isTrusted(request)) {
+            json(response, 403, { ok: false, error: { code: 'forbidden', message: 'loopback same-origin access only' } });
+            return;
+        }
+        const url = new URL(request.url ?? '/', 'http://dsh.local');
+        try {
+            if (url.pathname === `${PLAYWRIGHT_CONTROL_API_PREFIX}/status` && request.method === 'GET') {
+                const sessionId = url.searchParams.get('sessionId');
+                if (!sessionId)
+                    throw new PlaywrightControlError('bad-request', 'sessionId is required');
+                json(response, 200, { ok: true, value: controller.status(sessionId) });
+                return;
+            }
+            if ((url.pathname === `${PLAYWRIGHT_CONTROL_API_PREFIX}/connect` || url.pathname === `${PLAYWRIGHT_CONTROL_API_PREFIX}/disconnect`) && request.method === 'POST') {
+                if (!String(request.headers['content-type'] ?? '').toLowerCase().startsWith('application/json')) {
+                    json(response, 415, { ok: false, error: { code: 'bad-request', message: 'application/json required' } });
+                    return;
+                }
+                const input = await body(request);
+                if (typeof input?.['sessionId'] !== 'string' || input['sessionId'] === '')
+                    throw new PlaywrightControlError('bad-request', 'sessionId is required');
+                const value = url.pathname.endsWith('/connect')
+                    ? await controller.connect(input['sessionId'])
+                    : await controller.disconnect(input['sessionId']);
+                json(response, 200, { ok: true, value });
+                return;
+            }
+            json(response, 404, { ok: false, error: { code: 'not-found', message: 'unknown route' } });
+        }
+        catch (error) {
+            const code = error instanceof PlaywrightControlError ? error.code : 'internal';
+            const status = code === 'forbidden' ? 403 : code === 'not-found' ? 404 : code === 'busy' || code === 'not-owner' || code === 'wrong-mode' ? 409 : code === 'bad-request' ? 400 : code === 'connect-failed' ? 502 : 500;
+            json(response, status, { ok: false, error: { code, message: error instanceof Error ? error.message : String(error) } });
+        }
+    };
+    return [{ kind: 'prefix', path: PLAYWRIGHT_CONTROL_API_PREFIX, handler }];
+}
+export function registerPlaywrightControlRoutes(ctx, controller) {
+    const isTrusted = accessTrustOf(ctx).isTrusted;
+    const disposers = makePlaywrightControlRoutes(controller, isTrusted).map(route => ctx.webServer.register(route));
+    return () => { for (const dispose of disposers.reverse())
+        dispose(); };
+}
+export { trusted as trustedPlaywrightControlRequest };

package/lib/types/host/services/remote-access/boot-scripts.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Index boot scripts and wire constants of the remote-access domain.
+ *
+ * The deployment's canonical entry (browser -> reverse proxy -> loopback
+ * `dsh web`) is a plain-HTTP origin. Two browser facts follow, and both are
+ * fixed here for every entry, whether or not the optional server-mode gateway
+ * is mounted:
+ *
+ * 1. `crypto.randomUUID` does not exist outside a secure context. The DSH
+ *    client mints RPC ids with it, so the polyfill is injected into every
+ *    served index document (issue #1024).
+ * 2. `navigator.clipboard` does not exist either, because the Clipboard API is
+ *    secure-context gated. Upstream DSH copy affordances call
+ *    `navigator.clipboard.writeText` without a fallback, so a copy button
+ *    throws on a remote page while working on the loopback page. The shim backs
+ *    `writeText` with the legacy `document.execCommand('copy')` path and never
+ *    replaces a real clipboard object.
+ *
+ * Host ownership is per request instead of a static row: the index document
+ * points at {@link HOST_ACCESS_BOOT_PATH} with a parser-blocking
+ * `<script src>`, whose handler decides from the request Host whether this page
+ * may claim the Host (`__DSH_TRANSPORT__.ownsHost`). Without the claim the DSH
+ * client keeps the whole settings plane in a process-local memory store and
+ * renders Settings -> Models as "settings are unavailable in this browser",
+ * while the provider directory, the account page and the config-file entry all
+ * stay empty.
+ * @module dsh-web-all/host/services/remote-access/boot-scripts
+ */
+/**
+ * Parser-blocking boot script path; the handler decides per request.
+ * Re-exported from `core/remote-access/paths.ts`, the single home the browser
+ * half reads too.
+ */
+export { HOST_ACCESS_BOOT_PATH, HOST_ACCESS_MARKER_COOKIE, HOST_ACCESS_MARKER_MAX_AGE_SECONDS, HOST_ACCESS_MARKER_VALUE, HOST_ACCESS_SESSION_PATH, } from '../../../core/remote-access/paths.ts';
+/**
+ * `crypto.randomUUID` polyfill for non-secure contexts. Kept byte-compatible
+ * with the script the server-mode gateway used to inject, so the two renderers
+ * cannot drift.
+ */
+export declare const UUID_POLYFILL_SCRIPT: string;
+/**
+ * `navigator.clipboard` shim for non-secure contexts. Only installed when the
+ * platform exposes no clipboard at all, so a secure-context page keeps the real
+ * API. `readText` cannot be polyfilled from a page (the paste event is the only
+ * read path), so it rejects instead of throwing synchronously; callers that
+ * already fall back on rejection keep working.
+ */
+export declare const CLIPBOARD_SHIM_SCRIPT: string;
+/**
+ * Boot script body served for one admission decision.
+ * @param admitted - whether the requesting Host passed the host access fence.
+ * @returns an inline script claiming Host ownership, or a no-op script.
+ */
+export declare function hostAccessBootScript(admitted: boolean): string;
+//# sourceMappingURL=boot-scripts.d.ts.map

package/lib/types/host/services/remote-access/boot-scripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boot-scripts.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/remote-access/boot-scripts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;GAIG;AACH,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,kCAAkC,EAClC,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,sCAAsC,CAAA;AAE7C;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAkBvB,CAAA;AAEV;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,QAyBxB,CAAA;AAEV;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,CAW9D"}

package/lib/types/host/services/remote-access/boot-scripts.js

@@ -0,0 +1,109 @@
+/**
+ * Index boot scripts and wire constants of the remote-access domain.
+ *
+ * The deployment's canonical entry (browser -> reverse proxy -> loopback
+ * `dsh web`) is a plain-HTTP origin. Two browser facts follow, and both are
+ * fixed here for every entry, whether or not the optional server-mode gateway
+ * is mounted:
+ *
+ * 1. `crypto.randomUUID` does not exist outside a secure context. The DSH
+ *    client mints RPC ids with it, so the polyfill is injected into every
+ *    served index document (issue #1024).
+ * 2. `navigator.clipboard` does not exist either, because the Clipboard API is
+ *    secure-context gated. Upstream DSH copy affordances call
+ *    `navigator.clipboard.writeText` without a fallback, so a copy button
+ *    throws on a remote page while working on the loopback page. The shim backs
+ *    `writeText` with the legacy `document.execCommand('copy')` path and never
+ *    replaces a real clipboard object.
+ *
+ * Host ownership is per request instead of a static row: the index document
+ * points at {@link HOST_ACCESS_BOOT_PATH} with a parser-blocking
+ * `<script src>`, whose handler decides from the request Host whether this page
+ * may claim the Host (`__DSH_TRANSPORT__.ownsHost`). Without the claim the DSH
+ * client keeps the whole settings plane in a process-local memory store and
+ * renders Settings -> Models as "settings are unavailable in this browser",
+ * while the provider directory, the account page and the config-file entry all
+ * stay empty.
+ * @module dsh-web-all/host/services/remote-access/boot-scripts
+ */
+/**
+ * Parser-blocking boot script path; the handler decides per request.
+ * Re-exported from `core/remote-access/paths.ts`, the single home the browser
+ * half reads too.
+ */
+export { HOST_ACCESS_BOOT_PATH, HOST_ACCESS_MARKER_COOKIE, HOST_ACCESS_MARKER_MAX_AGE_SECONDS, HOST_ACCESS_MARKER_VALUE, HOST_ACCESS_SESSION_PATH, } from "../../../core/remote-access/paths.js";
+/**
+ * `crypto.randomUUID` polyfill for non-secure contexts. Kept byte-compatible
+ * with the script the server-mode gateway used to inject, so the two renderers
+ * cannot drift.
+ */
+export const UUID_POLYFILL_SCRIPT = [
+    '(function(){',
+    'var g=typeof globalThis!=="undefined"?globalThis:typeof window!=="undefined"?window:self;',
+    'if(typeof g.crypto==="undefined"){g.crypto={};}',
+    'if(typeof g.crypto.randomUUID!=="function"){',
+    'g.crypto.randomUUID=function(){',
+    'var a=new Uint8Array(16);',
+    'if(g.crypto.getRandomValues){g.crypto.getRandomValues(a);}',
+    'else{for(var j=0;j<16;j++){a[j]=Math.random()*256|0;}}',
+    'a[6]=(a[6]&0x0f)|0x40;',
+    'a[8]=(a[8]&0x3f)|0x80;',
+    'var h="",x="0123456789abcdef";',
+    'for(var i=0;i<16;i++){h+=x[a[i]>>4]+x[a[i]&0x0f];',
+    'if(i===3||i===5||i===7||i===9)h+="-";}',
+    'return h;',
+    '};',
+    '}',
+    '})();',
+].join('');
+/**
+ * `navigator.clipboard` shim for non-secure contexts. Only installed when the
+ * platform exposes no clipboard at all, so a secure-context page keeps the real
+ * API. `readText` cannot be polyfilled from a page (the paste event is the only
+ * read path), so it rejects instead of throwing synchronously; callers that
+ * already fall back on rejection keep working.
+ */
+export const CLIPBOARD_SHIM_SCRIPT = [
+    '(function(){',
+    'try{',
+    'var n=typeof navigator!=="undefined"?navigator:undefined;',
+    'if(n===undefined||n.clipboard!==undefined)return;',
+    'var writeText=function(text){return new Promise(function(resolve,reject){',
+    'try{',
+    'var area=document.createElement("textarea");',
+    'area.value=String(text);',
+    'area.setAttribute("readonly","");',
+    'area.style.position="fixed";',
+    'area.style.top="-1000px";',
+    'document.body.appendChild(area);',
+    'area.select();',
+    'var ok=document.execCommand("copy");',
+    'document.body.removeChild(area);',
+    'if(ok){resolve();}else{reject(new Error("clipboard write is unavailable on this origin"));}',
+    '}catch(e){reject(e);}',
+    '});};',
+    'var readText=function(){return Promise.reject(new Error("clipboard read is unavailable on this origin"));};',
+    'var shim={writeText:writeText,readText:readText};',
+    'try{Object.defineProperty(Navigator.prototype,"clipboard",{get:function(){return shim;},configurable:true});}',
+    'catch(e){try{Object.defineProperty(n,"clipboard",{value:shim,configurable:true});}catch(e2){}}',
+    '}catch(e){}',
+    '})();',
+].join('');
+/**
+ * Boot script body served for one admission decision.
+ * @param admitted - whether the requesting Host passed the host access fence.
+ * @returns an inline script claiming Host ownership, or a no-op script.
+ */
+export function hostAccessBootScript(admitted) {
+    if (!admitted)
+        return '/* web-all: this host is not a declared browser entry; the page keeps the memory settings plane */\n';
+    return [
+        '(function(){',
+        'try{',
+        'var t=globalThis.__DSH_TRANSPORT__||{};',
+        't.ownsHost=true;',
+        'globalThis.__DSH_TRANSPORT__=t;',
+        '}catch(e){}',
+        '})();',
+    ].join('');
+}

package/lib/types/host/services/remote-access/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Remote-access service domain: the two pieces every reverse-proxied
+ * deployment needs regardless of whether the optional server-mode gateway is
+ * mounted.
+ *
+ * - the per-request Host-ownership boot script and the authority posture
+ *   readout (`./routes.ts`);
+ * - the index boot rows every entry shares: the parser-blocking ownership
+ *   script, the `crypto.randomUUID` polyfill and the `navigator.clipboard`
+ *   shim (`./boot-scripts.ts`).
+ *
+ * The ownership decision is the shared host access fence, so this domain can
+ * never claim more than the privileged panels already allow. Fail-closed: when
+ * the fence service is missing, `accessTrustOf` falls back to the strict
+ * loopback rule and only a loopback page (which already owns the Host) is
+ * admitted.
+ * @module dsh-web-all/host/services/remote-access
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export { CLIPBOARD_SHIM_SCRIPT, HOST_ACCESS_BOOT_PATH, HOST_ACCESS_MARKER_COOKIE, HOST_ACCESS_MARKER_MAX_AGE_SECONDS, HOST_ACCESS_MARKER_VALUE, HOST_ACCESS_SESSION_PATH, UUID_POLYFILL_SCRIPT, hostAccessBootScript, } from './boot-scripts.ts';
+export { makeRemoteAccessRoutes, type RemoteAccessDeps } from './routes.ts';
+/**
+ * Mount the service domain.
+ * @param ctx - host plugin context.
+ * @returns the disposer releasing the routes and the injection rows.
+ */
+export declare function register(ctx: Context): () => void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/host/services/remote-access/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/host/services/remote-access/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAQlD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,kCAAkC,EAClC,wBAAwB,EACxB,wBAAwB,EACxB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,sBAAsB,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE3E;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,IAAI,CAiBjD"}