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

package/lib/types/core/notify/feed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feed.d.ts","sourceRoot":"","sources":["../../../../src/core/notify/feed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,cAAc,EACpB,MAAM,eAAe,CAAA;AAEtB;;;;;;;GAOG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,GAAG,CAAI;IACf,OAAO,CAAC,OAAO,CAAkB;IAEjC;;;OAGG;gBACS,KAAK,GAAE,MAA6B;IAIhD,+DAA+D;IAC/D,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,+CAA+C;IAC/C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS;IAgBxC;;;;;OAKG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE;IAYpD,mDAAmD;IACnD,QAAQ,IAAI,SAAS,SAAS,EAAE;IAIhC,kGAAkG;IAClG,KAAK,IAAI,IAAI;CAGd;AAUD;;;;;;;;;GASG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IAExD;;OAEG;gBACS,QAAQ,GAAE,MAA4B;IAIlD,wCAAwC;IACxC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,OAAO,CAAC,KAAK;IAkBb;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAMhD;;;;;OAKG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAOrD;;;;OAIG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAMlC,mCAAmC;IACnC,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI/B,4BAA4B;IAC5B,KAAK,IAAI,IAAI;CAGd;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAKzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAUtD"}

package/lib/types/core/notify/feed.js

@@ -0,0 +1,214 @@
+/**
+ * The two bounded pieces of state the notification host keeps: the recent
+ * notice log a client polls, and the session titles a notice quotes.
+ *
+ * Both are deliberately in memory only. A notice answers "did my work finish"
+ * for a window of a few minutes; persisting it would create a second durable
+ * record of the session log that DSH already owns, and would have to answer
+ * questions about retention, migration and conflicting truth. A restart
+ * therefore forgets the feed, and a client's watermark simply replays from a
+ * fresh, empty log.
+ *
+ * @module dsh-web-all/notify-feed
+ */
+import { NOTIFY_DEFAULT_LIMIT, NOTIFY_TITLE_MEMORY, outcomeOf, } from "./contract.js";
+/**
+ * A bounded log of finished turns, oldest first.
+ *
+ * Ids are assigned from a counter that never resets while the host lives, so a
+ * client watermark stays meaningful even after older entries have been evicted:
+ * "newer than 40" keeps working when the log has already dropped everything
+ * below 35.
+ */
+export class NoticeLog {
+    limit;
+    seq = 0;
+    entries = [];
+    /**
+     * @param limit - how many notices to retain; clamped to at least one so a
+     *   misconfigured host still answers with something.
+     */
+    constructor(limit = NOTIFY_DEFAULT_LIMIT) {
+        this.limit = Number.isFinite(limit) && limit >= 1 ? Math.trunc(limit) : NOTIFY_DEFAULT_LIMIT;
+    }
+    /** Newest assigned id, or 0 when nothing has been recorded. */
+    get latest() {
+        return this.seq;
+    }
+    /** How many notices are currently retained. */
+    get size() {
+        return this.entries.length;
+    }
+    /**
+     * Record one finished turn.
+     * @param input - the turn facts; an absent outcome is derived from the reason.
+     * @returns the stored notice, including its assigned id.
+     */
+    append(input) {
+        this.seq += 1;
+        const notice = {
+            id: this.seq,
+            at: input.at,
+            sessionId: input.sessionId,
+            title: input.title,
+            turn: input.turn,
+            reason: input.reason,
+            outcome: input.outcome ?? outcomeOf(input.reason),
+        };
+        this.entries.push(notice);
+        if (this.entries.length > this.limit)
+            this.entries.splice(0, this.entries.length - this.limit);
+        return notice;
+    }
+    /**
+     * Notices newer than a client's watermark, oldest first.
+     * @param watermark - the client's last seen id; 0 (or anything unparsable) replays what is held.
+     * @param limit - maximum notices to return; at least one.
+     * @returns a fresh array of notices.
+     */
+    since(watermark, limit) {
+        const floor = Number.isFinite(watermark) && watermark > 0 ? Math.trunc(watermark) : 0;
+        const cap = Number.isFinite(limit) && limit >= 1 ? Math.trunc(limit) : 1;
+        const out = [];
+        for (const notice of this.entries) {
+            if (notice.id <= floor)
+                continue;
+            out.push(notice);
+            if (out.length >= cap)
+                break;
+        }
+        return out;
+    }
+    /** Everything currently retained, oldest first. */
+    snapshot() {
+        return [...this.entries];
+    }
+    /** Drop every retained notice. Ids keep counting, so a stale watermark still orders correctly. */
+    clear() {
+        this.entries = [];
+    }
+}
+/**
+ * Remembers how each session is named, so a notice can say which conversation
+ * finished instead of quoting an opaque `session-7`.
+ *
+ * A session's own title event is preferred, because `dsh-session-title` already
+ * decided which messages are eligible input and normalized the result. Until
+ * one exists, the first human prompt stands in. Both maps are bounded by last
+ * write, so a host that runs for weeks does not accumulate one entry per
+ * conversation it has ever seen.
+ */
+export class TitleBook {
+    capacity;
+    entries = new Map();
+    /**
+     * @param capacity - sessions to remember; clamped to at least one.
+     */
+    constructor(capacity = NOTIFY_TITLE_MEMORY) {
+        this.capacity = Number.isFinite(capacity) && capacity >= 1 ? Math.trunc(capacity) : NOTIFY_TITLE_MEMORY;
+    }
+    /** How many sessions are remembered. */
+    get size() {
+        return this.entries.size;
+    }
+    entry(sessionId) {
+        const existing = this.entries.get(sessionId);
+        if (existing !== undefined) {
+            // Re-insert so the most recently written session is the last evicted.
+            this.entries.delete(sessionId);
+            this.entries.set(sessionId, existing);
+            return existing;
+        }
+        const created = { title: '', prompt: '' };
+        this.entries.set(sessionId, created);
+        while (this.entries.size > this.capacity) {
+            const oldest = this.entries.keys().next();
+            if (oldest.done === true)
+                break;
+            this.entries.delete(oldest.value);
+        }
+        return created;
+    }
+    /**
+     * Record a session title, which outranks any prompt excerpt.
+     * @param sessionId - the titled session.
+     * @param title - the title text; blank is ignored so a nameless update cannot erase a name.
+     */
+    setTitle(sessionId, title) {
+        const text = title.trim();
+        if (sessionId === '' || text === '')
+            return;
+        this.entry(sessionId).title = excerpt(text, 60);
+    }
+    /**
+     * Record a candidate prompt excerpt. The first one wins, because a session is
+     * recognized by what it was opened to do, not by its most recent follow-up.
+     * @param sessionId - the session the prompt belongs to.
+     * @param text - the human prompt text.
+     */
+    rememberPrompt(sessionId, text) {
+        const text2 = text.trim();
+        if (sessionId === '' || text2 === '')
+            return;
+        const entry = this.entry(sessionId);
+        if (entry.prompt === '')
+            entry.prompt = excerpt(text2, 60);
+    }
+    /**
+     * How to name one session in a notice.
+     * @param sessionId - the session to name.
+     * @returns the title, else the prompt excerpt, else '' when nothing is known.
+     */
+    titleOf(sessionId) {
+        const entry = this.entries.get(sessionId);
+        if (entry === undefined)
+            return '';
+        return entry.title !== '' ? entry.title : entry.prompt;
+    }
+    /** Forget one disposed session. */
+    forget(sessionId) {
+        this.entries.delete(sessionId);
+    }
+    /** Forget every session. */
+    clear() {
+        this.entries.clear();
+    }
+}
+/**
+ * One-line excerpt safe to put in a notification.
+ * @param text - any text, possibly multi-line.
+ * @param max - maximum code points to keep.
+ * @returns whitespace-collapsed text, truncated with an ellipsis when it was longer.
+ */
+export function excerpt(text, max) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    const points = [...collapsed];
+    if (points.length <= max)
+        return collapsed;
+    return `${points.slice(0, Math.max(1, max - 1)).join('')}…`;
+}
+/**
+ * Pull the plain text out of one message's content blocks.
+ *
+ * Only text blocks carry quotable prose; every other block kind (an image, a
+ * file reference) is skipped rather than stringified, because a title made of a
+ * serialized block would be worse than no title.
+ *
+ * @param content - the message's `content` field, of unknown quality.
+ * @returns the concatenated text, space separated.
+ */
+export function textOfContent(content) {
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (typeof block !== 'object' || block === null)
+            continue;
+        const record = block;
+        if (record.type !== 'text')
+            continue;
+        if (typeof record.text === 'string' && record.text.trim() !== '')
+            parts.push(record.text);
+    }
+    return parts.join(' ');
+}

package/lib/types/core/playwright-sessions/contracts.d.ts

@@ -0,0 +1,98 @@
+/** Pure contracts and defaults for the per-session Playwright capability. */
+export type PlaywrightConnectionMode = 'launch' | 'extension';
+export type PlaywrightApprovalPolicy = 'never' | 'unsafe' | 'mutations';
+export interface PlaywrightSessionsConfig {
+    /** Start an isolated browser, or attach to selected tabs in the user's Chrome through the official extension. */
+    mode?: PlaywrightConnectionMode;
+    headless?: boolean;
+    /** Chrome/Edge channel used by extension mode. */
+    browserChannel?: 'chrome' | 'msedge';
+    /** Optional browser executable override used by extension mode. */
+    executablePath?: string;
+    allowedHosts?: string[];
+    /** Browser request allowlist passed to Playwright MCP (defense in depth, not an authorization boundary). */
+    allowedOrigins?: string[];
+    /** Browser request blocklist, evaluated before allowedOrigins. */
+    blockedOrigins?: string[];
+    /** Ask through the DSH approval seam before risky browser tools. */
+    approvalPolicy?: PlaywrightApprovalPolicy;
+    /** Expose browser_run_code_unsafe. Defaults off in extension mode and on in launch mode. */
+    unsafeTools?: boolean;
+    sessionsRoot?: string;
+    toolCallTimeoutMs?: number;
+    idleTimeoutMs?: number;
+    maxConcurrentBrowsers?: number;
+    pruneProfileOnDispose?: boolean;
+    profileTtlMs?: number;
+    profileSweepIntervalMs?: number;
+    /**
+     * Enable the agent-browser live view for launch mode: the host starts the
+     * persistent Chromium (dual-owner; the MCP child connects over
+     * --cdp-endpoint) and serves the screencast. Extension mode uses the visible
+     * Chrome window itself and therefore does not expose a duplicate screencast.
+     */
+    liveView?: boolean;
+}
+export interface ResolvedPlaywrightSessionsConfig {
+    mode: PlaywrightConnectionMode;
+    headless: boolean;
+    browserChannel: 'chrome' | 'msedge';
+    executablePath: string;
+    allowedHosts: string[];
+    allowedOrigins: string[];
+    blockedOrigins: string[];
+    approvalPolicy: PlaywrightApprovalPolicy;
+    unsafeTools: boolean;
+    sessionsRoot?: string;
+    toolCallTimeoutMs: number;
+    idleTimeoutMs: number;
+    maxConcurrentBrowsers: number;
+    pruneProfileOnDispose: boolean;
+    profileTtlMs: number;
+    profileSweepIntervalMs: number;
+    liveView: boolean;
+}
+export interface PlaywrightToolContract {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: unknown;
+    type?: string;
+}
+export interface PlaywrightCallResult {
+    content: unknown[];
+    isError: boolean;
+}
+export declare const PLAYWRIGHT_SERVER_NAME = "playwright";
+export declare const PLAYWRIGHT_CLOSE_TOOL = "browser_close";
+export declare const UNSCOPED_PLAYWRIGHT_SESSION = "unscoped";
+export declare const PLAYWRIGHT_SESSIONS_DEFAULTS: Readonly<{
+    mode: PlaywrightConnectionMode;
+    headless: true;
+    browserChannel: "chrome";
+    executablePath: "";
+    allowedHosts: string[];
+    allowedOrigins: string[];
+    blockedOrigins: string[];
+    approvalPolicy: PlaywrightApprovalPolicy;
+    toolCallTimeoutMs: 120000;
+    idleTimeoutMs: 900000;
+    maxConcurrentBrowsers: 2;
+    pruneProfileOnDispose: true;
+    profileTtlMs: 86400000;
+    profileSweepIntervalMs: 3600000;
+    liveView: false;
+}>;
+/** Apply compatibility defaults while keeping caller arrays isolated. */
+export declare function resolvePlaywrightSessionsConfig(config?: PlaywrightSessionsConfig): ResolvedPlaywrightSessionsConfig;
+export declare function playwrightToolRisk(rawName: string): 'read' | 'mutation' | 'unsafe';
+export declare function playwrightToolNeedsApproval(rawName: string, policy: PlaywrightApprovalPolicy): boolean;
+/** Extract the durable DSH session identity without depending on host SDK types. */
+export declare function playwrightSessionId(exec: {
+    agent?: {
+        session?: {
+            id?: unknown;
+        };
+    };
+}): string;
+//# sourceMappingURL=contracts.d.ts.map

package/lib/types/core/playwright-sessions/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../src/core/playwright-sessions/contracts.ts"],"names":[],"mappings":"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"}

package/lib/types/core/playwright-sessions/contracts.js

@@ -0,0 +1,68 @@
+/** Pure contracts and defaults for the per-session Playwright capability. */
+export const PLAYWRIGHT_SERVER_NAME = 'playwright';
+export const PLAYWRIGHT_CLOSE_TOOL = 'browser_close';
+export const UNSCOPED_PLAYWRIGHT_SESSION = 'unscoped';
+export const PLAYWRIGHT_SESSIONS_DEFAULTS = Object.freeze({
+    mode: 'launch',
+    headless: true,
+    browserChannel: 'chrome',
+    executablePath: '',
+    allowedHosts: ['*'],
+    allowedOrigins: [],
+    blockedOrigins: [],
+    approvalPolicy: 'unsafe',
+    toolCallTimeoutMs: 120_000,
+    idleTimeoutMs: 900_000,
+    maxConcurrentBrowsers: 2,
+    pruneProfileOnDispose: true,
+    profileTtlMs: 86_400_000,
+    profileSweepIntervalMs: 3_600_000,
+    liveView: false,
+});
+/** Apply compatibility defaults while keeping caller arrays isolated. */
+export function resolvePlaywrightSessionsConfig(config = {}) {
+    const mode = config.mode ?? PLAYWRIGHT_SESSIONS_DEFAULTS.mode;
+    const liveView = mode === 'launch' && (config.liveView ?? PLAYWRIGHT_SESSIONS_DEFAULTS.liveView);
+    return {
+        mode,
+        headless: config.headless ?? PLAYWRIGHT_SESSIONS_DEFAULTS.headless,
+        browserChannel: config.browserChannel ?? PLAYWRIGHT_SESSIONS_DEFAULTS.browserChannel,
+        executablePath: config.executablePath ?? PLAYWRIGHT_SESSIONS_DEFAULTS.executablePath,
+        allowedHosts: [...(config.allowedHosts ?? PLAYWRIGHT_SESSIONS_DEFAULTS.allowedHosts)],
+        allowedOrigins: [...(config.allowedOrigins ?? PLAYWRIGHT_SESSIONS_DEFAULTS.allowedOrigins)],
+        blockedOrigins: [...(config.blockedOrigins ?? PLAYWRIGHT_SESSIONS_DEFAULTS.blockedOrigins)],
+        approvalPolicy: config.approvalPolicy ?? (mode === 'extension' ? 'mutations' : PLAYWRIGHT_SESSIONS_DEFAULTS.approvalPolicy),
+        unsafeTools: config.unsafeTools ?? mode === 'launch',
+        sessionsRoot: config.sessionsRoot,
+        toolCallTimeoutMs: config.toolCallTimeoutMs ?? PLAYWRIGHT_SESSIONS_DEFAULTS.toolCallTimeoutMs,
+        idleTimeoutMs: config.idleTimeoutMs ?? PLAYWRIGHT_SESSIONS_DEFAULTS.idleTimeoutMs,
+        maxConcurrentBrowsers: mode === 'extension' ? 1 : config.maxConcurrentBrowsers ?? PLAYWRIGHT_SESSIONS_DEFAULTS.maxConcurrentBrowsers,
+        pruneProfileOnDispose: config.pruneProfileOnDispose ?? PLAYWRIGHT_SESSIONS_DEFAULTS.pruneProfileOnDispose,
+        profileTtlMs: config.profileTtlMs ?? PLAYWRIGHT_SESSIONS_DEFAULTS.profileTtlMs,
+        profileSweepIntervalMs: config.profileSweepIntervalMs ?? PLAYWRIGHT_SESSIONS_DEFAULTS.profileSweepIntervalMs,
+        liveView,
+    };
+}
+const READ_ONLY_PLAYWRIGHT_TOOLS = new Set([
+    'browser_console_messages', 'browser_find', 'browser_network_request',
+    'browser_network_requests', 'browser_snapshot', 'browser_take_screenshot',
+]);
+const UNSAFE_PLAYWRIGHT_TOOLS = new Set(['browser_evaluate', 'browser_run_code_unsafe']);
+export function playwrightToolRisk(rawName) {
+    if (UNSAFE_PLAYWRIGHT_TOOLS.has(rawName))
+        return 'unsafe';
+    if (READ_ONLY_PLAYWRIGHT_TOOLS.has(rawName))
+        return 'read';
+    return 'mutation';
+}
+export function playwrightToolNeedsApproval(rawName, policy) {
+    if (policy === 'never')
+        return false;
+    const risk = playwrightToolRisk(rawName);
+    return risk === 'unsafe' || (policy === 'mutations' && risk === 'mutation');
+}
+/** Extract the durable DSH session identity without depending on host SDK types. */
+export function playwrightSessionId(exec) {
+    const id = exec.agent?.session?.id;
+    return typeof id === 'string' && id.length > 0 ? id : UNSCOPED_PLAYWRIGHT_SESSION;
+}

package/lib/types/core/playwright-sessions/control.d.ts

@@ -0,0 +1,19 @@
+/** Public, secret-free control-plane contracts for the Agent Browser panel. */
+import type { PlaywrightConnectionMode } from './contracts.ts';
+export declare const PLAYWRIGHT_CONTROL_API_PREFIX = "/api/playwright-sessions";
+export type PlaywrightConnectionState = 'unavailable' | 'disconnected' | 'connecting' | 'connected' | 'error';
+export interface PlaywrightConnectionStatus {
+    mode: PlaywrightConnectionMode;
+    state: PlaywrightConnectionState;
+    ownedByThisSession: boolean;
+    busy: boolean;
+    liveView: boolean;
+    errorCode?: string;
+    errorMessage?: string;
+}
+export type PlaywrightControlErrorCode = 'bad-request' | 'forbidden' | 'not-found' | 'busy' | 'wrong-mode' | 'not-owner' | 'connect-failed' | 'internal';
+export declare class PlaywrightControlError extends Error {
+    readonly code: PlaywrightControlErrorCode;
+    constructor(code: PlaywrightControlErrorCode, message: string);
+}
+//# sourceMappingURL=control.d.ts.map

package/lib/types/core/playwright-sessions/control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../../../src/core/playwright-sessions/control.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAA;AAE9D,eAAO,MAAM,6BAA6B,6BAA6B,CAAA;AAEvE,MAAM,MAAM,yBAAyB,GAAG,aAAa,GAAG,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,OAAO,CAAA;AAE7G,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,wBAAwB,CAAA;IAC9B,KAAK,EAAE,yBAAyB,CAAA;IAChC,kBAAkB,EAAE,OAAO,CAAA;IAC3B,IAAI,EAAE,OAAO,CAAA;IACb,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,MAAM,0BAA0B,GAClC,aAAa,GACb,WAAW,GACX,WAAW,GACX,MAAM,GACN,YAAY,GACZ,WAAW,GACX,gBAAgB,GAChB,UAAU,CAAA;AAEd,qBAAa,sBAAuB,SAAQ,KAAK;IACnC,QAAQ,CAAC,IAAI,EAAE,0BAA0B;gBAAhC,IAAI,EAAE,0BAA0B,EAAE,OAAO,EAAE,MAAM;CAIvE"}

package/lib/types/core/playwright-sessions/control.js

@@ -0,0 +1,9 @@
+export const PLAYWRIGHT_CONTROL_API_PREFIX = '/api/playwright-sessions';
+export class PlaywrightControlError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'PlaywrightControlError';
+    }
+}

package/lib/types/core/playwright-sessions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './contracts.ts';
+export * from './names.ts';
+export * from './schema.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/core/playwright-sessions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/playwright-sessions/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}

package/lib/types/core/playwright-sessions/index.js

@@ -0,0 +1,3 @@
+export * from "./contracts.js";
+export * from "./names.js";
+export * from "./schema.js";

package/lib/types/core/playwright-sessions/names.d.ts

@@ -0,0 +1,4 @@
+/** Deterministic public tool and safe per-session directory names. */
+export declare function publicPlaywrightToolName(rawName: string): string;
+export declare function sanitizePlaywrightSessionKey(sessionId: string): string;
+//# sourceMappingURL=names.d.ts.map

package/lib/types/core/playwright-sessions/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../../../src/core/playwright-sessions/names.ts"],"names":[],"mappings":"AAAA,sEAAsE;AAoEtE,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAMhE;AAED,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAMtE"}

package/lib/types/core/playwright-sessions/names.js

@@ -0,0 +1,84 @@
+/** Deterministic public tool and safe per-session directory names. */
+const INVALID_NAME_CHARS = /[^A-Za-z0-9_-]/g;
+const MAX_PUBLIC_NAME_LENGTH = 64;
+const HASH_LENGTH = 12;
+/** A small synchronous SHA-256 implementation keeps this core module host/client pure. */
+function sha256Hex(value) {
+    const rightRotate = (word, amount) => (word >>> amount) | (word << (32 - amount));
+    const constants = [];
+    const initial = [];
+    for (let candidate = 2; constants.length < 64; candidate += 1) {
+        let prime = true;
+        for (let divisor = 2; divisor * divisor <= candidate; divisor += 1) {
+            if (candidate % divisor === 0) {
+                prime = false;
+                break;
+            }
+        }
+        if (!prime)
+            continue;
+        if (initial.length < 8)
+            initial.push((Math.sqrt(candidate) * 0x100000000) | 0);
+        constants.push((Math.cbrt(candidate) * 0x100000000) | 0);
+    }
+    const bytes = new TextEncoder().encode(value);
+    const bitLength = bytes.length * 8;
+    const paddedLength = ((bytes.length + 9 + 63) >> 6) << 6;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 0x100000000), false);
+    view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+    const hash = initial.slice();
+    const words = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLength; offset += 64) {
+        for (let index = 0; index < 16; index += 1)
+            words[index] = view.getUint32(offset + index * 4, false);
+        for (let index = 16; index < 64; index += 1) {
+            const word15 = words[index - 15] ?? 0;
+            const word2 = words[index - 2] ?? 0;
+            const sigma0 = rightRotate(word15, 7) ^ rightRotate(word15, 18) ^ (word15 >>> 3);
+            const sigma1 = rightRotate(word2, 17) ^ rightRotate(word2, 19) ^ (word2 >>> 10);
+            words[index] = (((words[index - 16] ?? 0) + sigma0 + (words[index - 7] ?? 0) + sigma1) >>> 0);
+        }
+        let [a, b, c, d, e, f, g, h] = hash;
+        for (let index = 0; index < 64; index += 1) {
+            const sum1 = rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25);
+            const choice = (e & f) ^ (~e & g);
+            const temp1 = (h + sum1 + choice + (constants[index] ?? 0) + (words[index] ?? 0)) >>> 0;
+            const sum0 = rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (sum0 + majority) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temp1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) >>> 0;
+        }
+        const current = [a, b, c, d, e, f, g, h];
+        for (let index = 0; index < 8; index += 1)
+            hash[index] = ((hash[index] ?? 0) + (current[index] ?? 0)) >>> 0;
+    }
+    return hash.map((word) => word.toString(16).padStart(8, '0')).join('');
+}
+export function publicPlaywrightToolName(rawName) {
+    const joined = `mcp__playwright__${rawName}`;
+    const normalized = joined.replace(INVALID_NAME_CHARS, '_');
+    if (normalized === joined && normalized.length <= MAX_PUBLIC_NAME_LENGTH)
+        return normalized;
+    const hash = sha256Hex(`playwright\0${rawName}`).slice(0, HASH_LENGTH);
+    return `${normalized.slice(0, MAX_PUBLIC_NAME_LENGTH - HASH_LENGTH - 1)}_${hash}`;
+}
+export function sanitizePlaywrightSessionKey(sessionId) {
+    const cleaned = sessionId.replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+    if (cleaned.length > 0 && cleaned.length <= 80)
+        return cleaned;
+    const hash = sha256Hex(sessionId).slice(0, HASH_LENGTH);
+    if (cleaned.length === 0)
+        return hash;
+    return `${cleaned.slice(0, 60)}-${hash}`;
+}

package/lib/types/core/playwright-sessions/schema.d.ts

@@ -0,0 +1,4 @@
+/** Convert Playwright MCP's zod-style schema snapshots to plain JSON Schema. */
+export type JsonSchema = Record<string, unknown>;
+export declare function convertPlaywrightInputSchema(input: unknown): JsonSchema;
+//# sourceMappingURL=schema.d.ts.map

package/lib/types/core/playwright-sessions/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/core/playwright-sessions/schema.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAEhF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAOhD,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAKvE"}

package/lib/types/core/playwright-sessions/schema.js

@@ -0,0 +1,90 @@
+/** Convert Playwright MCP's zod-style schema snapshots to plain JSON Schema. */
+export function convertPlaywrightInputSchema(input) {
+    const { schema } = convertNode(asRecord(input));
+    return schema.type === 'object'
+        ? schema
+        : { type: 'object', properties: {}, additionalProperties: false };
+}
+function convertNode(node) {
+    const definition = asRecord(node.def);
+    const type = typeof definition.type === 'string'
+        ? definition.type
+        : typeof node.type === 'string' ? node.type : undefined;
+    switch (type) {
+        case 'object': {
+            const properties = {};
+            const required = [];
+            for (const [key, raw] of Object.entries(asRecord(definition.shape))) {
+                const converted = convertNode(asRecord(raw));
+                properties[key] = converted.schema;
+                if (converted.required)
+                    required.push(key);
+            }
+            const schema = { type: 'object', properties };
+            if (required.length > 0)
+                schema.required = required;
+            return { schema, required: true };
+        }
+        case 'string': {
+            const schema = { type: 'string' };
+            copyFlag(schema, 'format', node, definition, 'string');
+            copyFlag(schema, 'minLength', node, definition, 'number');
+            copyFlag(schema, 'maxLength', node, definition, 'number');
+            return { schema, required: true };
+        }
+        case 'number': {
+            const schema = { type: flag(node, definition, 'isInt') === true ? 'integer' : 'number' };
+            const minimum = flag(node, definition, 'minValue');
+            const maximum = flag(node, definition, 'maxValue');
+            if (typeof minimum === 'number' && Number.isFinite(minimum))
+                schema.minimum = minimum;
+            if (typeof maximum === 'number' && Number.isFinite(maximum))
+                schema.maximum = maximum;
+            return { schema, required: true };
+        }
+        case 'boolean':
+            return { schema: { type: 'boolean' }, required: true };
+        case 'enum': {
+            const options = flag(node, definition, 'options');
+            const values = Array.isArray(options) && options.length > 0
+                ? options
+                : Object.values(asRecord(definition.entries));
+            const schema = { type: 'string' };
+            if (values.length > 0)
+                schema.enum = values;
+            return { schema, required: true };
+        }
+        case 'array': {
+            const items = convertNode(asRecord(definition.element)).schema;
+            return { schema: { type: 'array', items }, required: true };
+        }
+        case 'record': {
+            const values = convertNode(asRecord(definition.valueType)).schema;
+            return { schema: { type: 'object', additionalProperties: values }, required: true };
+        }
+        case 'default': {
+            const schema = convertNode(asRecord(definition.innerType)).schema;
+            const defaultValue = flag(definition, node, 'defaultValue');
+            if (defaultValue !== undefined)
+                schema.default = defaultValue;
+            return { schema, required: false };
+        }
+        case 'optional':
+            return { schema: convertNode(asRecord(definition.innerType)).schema, required: false };
+        default:
+            return { schema: {}, required: false };
+    }
+}
+function copyFlag(schema, outputKey, node, definition, expectedType) {
+    const value = flag(node, definition, outputKey);
+    if (typeof value === expectedType)
+        schema[outputKey] = value;
+}
+function flag(node, definition, key) {
+    return node[key] !== undefined ? node[key] : definition[key];
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}