@oxvo/ai-live-assist 7.3.4 → 7.4.23

package/cjs/pageAssistancePreference.js

@@ -0,0 +1,488 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageAssistancePreferenceStore = exports.PageAssistanceRecoveryStore = exports.digestPageAssistanceVisitor = exports.MAX_PAGE_ASSISTANCE_RECOVERY_TTL_MS = exports.MAX_PAGE_ASSISTANCE_PREFERENCE_TTL_MS = void 0;
+const STORAGE_PREFIX = "__oxvo_ai_live_assist_page_assistance_v1_";
+const STORAGE_RECORD_VERSION = 1;
+const STORAGE_RECORD_KIND = "page_assistance_receipt";
+const MAX_STORAGE_RECORD_LENGTH = 8192;
+const MAX_RECEIPT_LENGTH = 512;
+const MIN_RECEIPT_LENGTH = 32;
+const MAX_SITE_KEY_LENGTH = 256;
+const MAX_VISITOR_ID_LENGTH = 512;
+const RECOVERY_STORAGE_PREFIX = "__oxvo_ai_live_assist_page_assistance_recovery_v1_";
+const RECOVERY_RECORD_KIND = "page_assistance_recovery";
+const MAX_RECOVERY_RECORD_LENGTH = 2048;
+const OPAQUE_ID_PATTERN = /^[A-Za-z0-9_.:-]{8,128}$/;
+const CHECKSUM_PATTERN = /^[0-9a-f]{64}$/;
+exports.MAX_PAGE_ASSISTANCE_PREFERENCE_TTL_MS = 180 * 24 * 60 * 60 * 1000;
+exports.MAX_PAGE_ASSISTANCE_RECOVERY_TTL_MS = 5 * 60 * 1000;
+const validBoundedString = (value, maximum) => typeof value === "string" &&
+    value.length > 0 &&
+    value.length <= maximum &&
+    value.trim() === value &&
+    !/[\u0000-\u001f\u007f]/.test(value);
+const validPositiveInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+const validNonNegativeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const validOrigin = (value) => {
+    if (!validBoundedString(value, 2048))
+        return false;
+    try {
+        const parsed = new URL(value);
+        return ((parsed.protocol === "https:" || parsed.protocol === "http:") &&
+            parsed.origin === value);
+    }
+    catch {
+        return false;
+    }
+};
+const validSiteKey = (value) => validBoundedString(value, MAX_SITE_KEY_LENGTH) &&
+    /^[A-Za-z0-9_.:-]+$/.test(value);
+const validVisitorDigest = (value) => typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value);
+const validReceipt = (value) => typeof value === "string" &&
+    value.length >= MIN_RECEIPT_LENGTH &&
+    value.length <= MAX_RECEIPT_LENGTH &&
+    /^[A-Za-z0-9_-]+$/.test(value);
+const validExpiry = (value, now) => {
+    if (typeof value !== "string" || value.length > 64)
+        return false;
+    const expiresAt = Date.parse(value);
+    return (Number.isFinite(expiresAt) &&
+        expiresAt > now &&
+        expiresAt <= now + exports.MAX_PAGE_ASSISTANCE_PREFERENCE_TTL_MS);
+};
+const parseBinding = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const candidate = value;
+    if (!validOrigin(candidate.origin) ||
+        !validSiteKey(candidate.siteKey) ||
+        !validVisitorDigest(candidate.visitorDigest) ||
+        !validPositiveInteger(candidate.schemaVersion) ||
+        !validPositiveInteger(candidate.configRevision) ||
+        !validPositiveInteger(candidate.policyVersion) ||
+        candidate.capability !== "browser_control") {
+        return null;
+    }
+    return {
+        origin: candidate.origin,
+        siteKey: candidate.siteKey,
+        visitorDigest: candidate.visitorDigest,
+        schemaVersion: candidate.schemaVersion,
+        configRevision: candidate.configRevision,
+        policyVersion: candidate.policyVersion,
+        capability: "browser_control",
+    };
+};
+const sameBinding = (left, right) => left.origin === right.origin &&
+    left.siteKey === right.siteKey &&
+    left.visitorDigest === right.visitorDigest &&
+    left.schemaVersion === right.schemaVersion &&
+    left.configRevision === right.configRevision &&
+    left.policyVersion === right.policyVersion &&
+    left.capability === right.capability;
+const sameReceipt = (left, right) => left?.receipt === right?.receipt && left?.expiresAt === right?.expiresAt;
+const defaultStorage = () => {
+    try {
+        return typeof localStorage === "undefined" ? null : localStorage;
+    }
+    catch {
+        return null;
+    }
+};
+const defaultEventTarget = () => typeof window === "undefined" ? null : window;
+const defaultSessionStorage = () => {
+    try {
+        return typeof sessionStorage === "undefined" ? null : sessionStorage;
+    }
+    catch {
+        return null;
+    }
+};
+const canonicalJson = (value) => JSON.stringify(Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)));
+const recoveryDigest = async (value, subtle) => {
+    if (!subtle)
+        return null;
+    try {
+        const input = new TextEncoder().encode(canonicalJson({
+            version: 1,
+            kind: RECOVERY_RECORD_KIND,
+            ...value,
+        }));
+        const digest = new Uint8Array(await subtle.digest("SHA-256", input));
+        if (digest.byteLength !== 32)
+            return null;
+        return Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    }
+    catch {
+        return null;
+    }
+};
+const validRecoveryInput = (value, now) => OPAQUE_ID_PATTERN.test(value.sessionId ?? "") &&
+    OPAQUE_ID_PATTERN.test(value.tabId ?? "") &&
+    OPAQUE_ID_PATTERN.test(value.bindingGeneration ?? "") &&
+    OPAQUE_ID_PATTERN.test(value.requestId ?? "") &&
+    CHECKSUM_PATTERN.test(value.proposalChecksum ?? "") &&
+    validNonNegativeInteger(value.authorityEpoch) &&
+    (value.decision === "allow_session" ||
+        value.decision === "allow_persistent") &&
+    ((value.decision === "allow_session" && value.persistentReceipt === null) ||
+        (value.decision === "allow_persistent" &&
+            (value.persistentReceipt === null ||
+                validReceipt(value.persistentReceipt)))) &&
+    validPositiveInteger(value.configRevision) &&
+    validPositiveInteger(value.policyVersion) &&
+    validPositiveInteger(value.expiresAt) &&
+    value.expiresAt > now &&
+    value.expiresAt <= now + exports.MAX_PAGE_ASSISTANCE_RECOVERY_TTL_MS;
+const sameRecovery = (left, right) => left.sessionId === right.sessionId &&
+    left.tabId === right.tabId &&
+    left.bindingGeneration === right.bindingGeneration &&
+    left.requestId === right.requestId &&
+    left.proposalChecksum === right.proposalChecksum &&
+    left.authorityEpoch === right.authorityEpoch &&
+    left.decision === right.decision &&
+    left.persistentReceipt === right.persistentReceipt &&
+    left.configRevision === right.configRevision &&
+    left.policyVersion === right.policyVersion &&
+    left.expiresAt === right.expiresAt &&
+    left.submissionDigest === right.submissionDigest;
+const digestPageAssistanceVisitor = async (visitorId, subtle = globalThis.crypto?.subtle) => {
+    if (!validBoundedString(visitorId, MAX_VISITOR_ID_LENGTH) ||
+        visitorId.length < 8 ||
+        !subtle) {
+        return null;
+    }
+    try {
+        const input = new TextEncoder().encode(`oxvo:page-assistance:visitor:v1\u0000${visitorId}`);
+        const digest = new Uint8Array(await subtle.digest("SHA-256", input));
+        if (digest.byteLength !== 32)
+            return null;
+        const hex = Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+        return `sha256:${hex}`;
+    }
+    catch {
+        return null;
+    }
+};
+exports.digestPageAssistanceVisitor = digestPageAssistanceVisitor;
+class PageAssistanceRecoveryStore {
+    constructor(siteKey, options = {}) {
+        this.key = validSiteKey(siteKey)
+            ? `${RECOVERY_STORAGE_PREFIX}${encodeURIComponent(siteKey)}`
+            : null;
+        this.storage =
+            options.storage === undefined ? defaultSessionStorage() : options.storage;
+        this.now = options.now ?? Date.now;
+        this.subtle = options.subtle ?? globalThis.crypto?.subtle;
+    }
+    async remember(value, isCurrent) {
+        if (!isCurrent() ||
+            !this.key ||
+            !this.storage ||
+            !validRecoveryInput(value, this.now())) {
+            return null;
+        }
+        const submissionDigest = await recoveryDigest(value, this.subtle);
+        if (!isCurrent() || !submissionDigest)
+            return null;
+        const receipt = {
+            ...value,
+            submissionDigest,
+        };
+        const record = {
+            version: 1,
+            kind: RECOVERY_RECORD_KIND,
+            ...receipt,
+        };
+        try {
+            const serialized = JSON.stringify(record);
+            if (serialized.length > MAX_RECOVERY_RECORD_LENGTH)
+                return null;
+            if (!isCurrent())
+                return null;
+            this.storage.setItem(this.key, serialized);
+            const stored = await this.read();
+            if (!isCurrent())
+                return null;
+            return stored && sameRecovery(stored, receipt) ? stored : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    storedRecordPresent() {
+        if (!this.key || !this.storage)
+            return null;
+        try {
+            return this.storage.getItem(this.key) !== null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async read() {
+        if (!this.key || !this.storage)
+            return null;
+        let encoded = null;
+        try {
+            encoded = this.storage.getItem(this.key);
+            if (!encoded || encoded.length > MAX_RECOVERY_RECORD_LENGTH) {
+                if (encoded)
+                    this.clearIfUnchanged(encoded);
+                return null;
+            }
+            const candidate = JSON.parse(encoded);
+            const recoveryCandidate = candidate;
+            const expectedKeys = [
+                "authorityEpoch",
+                "bindingGeneration",
+                "configRevision",
+                "decision",
+                "expiresAt",
+                "kind",
+                "persistentReceipt",
+                "policyVersion",
+                "proposalChecksum",
+                "requestId",
+                "sessionId",
+                "submissionDigest",
+                "tabId",
+                "version",
+            ];
+            if (Object.keys(candidate).sort().join("|") !== expectedKeys.join("|") ||
+                candidate.version !== 1 ||
+                candidate.kind !== RECOVERY_RECORD_KIND ||
+                !validRecoveryInput(recoveryCandidate, this.now()) ||
+                !CHECKSUM_PATTERN.test(candidate.submissionDigest ?? "")) {
+                this.clearIfUnchanged(encoded);
+                return null;
+            }
+            const value = {
+                sessionId: recoveryCandidate.sessionId,
+                tabId: recoveryCandidate.tabId,
+                bindingGeneration: recoveryCandidate.bindingGeneration,
+                requestId: recoveryCandidate.requestId,
+                proposalChecksum: recoveryCandidate.proposalChecksum,
+                authorityEpoch: recoveryCandidate.authorityEpoch,
+                decision: recoveryCandidate.decision,
+                persistentReceipt: recoveryCandidate.persistentReceipt,
+                configRevision: recoveryCandidate.configRevision,
+                policyVersion: recoveryCandidate.policyVersion,
+                expiresAt: recoveryCandidate.expiresAt,
+            };
+            const submissionDigest = await recoveryDigest(value, this.subtle);
+            if (!submissionDigest ||
+                submissionDigest !== candidate.submissionDigest) {
+                this.clearIfUnchanged(encoded);
+                return null;
+            }
+            return { ...value, submissionDigest };
+        }
+        catch {
+            if (encoded)
+                this.clearIfUnchanged(encoded);
+            return null;
+        }
+    }
+    consume(submissionDigest) {
+        if (!CHECKSUM_PATTERN.test(submissionDigest) ||
+            !this.key ||
+            !this.storage) {
+            return false;
+        }
+        try {
+            const encoded = this.storage.getItem(this.key);
+            if (!encoded)
+                return false;
+            if (encoded.length > MAX_RECOVERY_RECORD_LENGTH)
+                return false;
+            const candidate = JSON.parse(encoded);
+            if (candidate.submissionDigest !== submissionDigest)
+                return false;
+            if (this.storage.getItem(this.key) !== encoded)
+                return false;
+            this.storage.removeItem(this.key);
+            return this.storage.getItem(this.key) === null;
+        }
+        catch {
+            return false;
+        }
+    }
+    clearIfUnchanged(expected) {
+        if (!this.key || !this.storage)
+            return;
+        try {
+            if (this.storage.getItem(this.key) === expected) {
+                this.storage.removeItem(this.key);
+            }
+        }
+        catch {
+            // A concurrent replacement must never be removed on stale read failure.
+        }
+    }
+    clear() {
+        if (!this.key || !this.storage)
+            return;
+        try {
+            this.storage.removeItem(this.key);
+        }
+        catch {
+            // Permission recovery is optional and fails closed without storage.
+        }
+    }
+}
+exports.PageAssistanceRecoveryStore = PageAssistanceRecoveryStore;
+class PageAssistancePreferenceStore {
+    constructor(binding, options = {}) {
+        this.listeners = new Set();
+        this.lastKnownReceipt = null;
+        this.destroyed = false;
+        this.onStorage = (event) => {
+            if (this.destroyed ||
+                !this.key ||
+                (event.key !== this.key && event.key !== null) ||
+                (event.storageArea !== null && event.storageArea !== this.storage)) {
+                return;
+            }
+            const previous = event.key === this.key
+                ? (this.parse(event.oldValue) ?? this.lastKnownReceipt)
+                : this.lastKnownReceipt;
+            let value = null;
+            if (event.key === this.key) {
+                value = this.parse(event.newValue);
+            }
+            else if (this.storage) {
+                try {
+                    value = this.parse(this.storage.getItem(this.key));
+                }
+                catch {
+                    value = null;
+                }
+            }
+            this.notify(value, previous);
+        };
+        this.binding = parseBinding(binding);
+        this.key = this.binding
+            ? `${STORAGE_PREFIX}${encodeURIComponent(this.binding.siteKey)}`
+            : null;
+        this.storage =
+            options.storage === undefined ? defaultStorage() : options.storage;
+        this.eventTarget =
+            options.eventTarget === undefined
+                ? defaultEventTarget()
+                : options.eventTarget;
+        this.now = options.now ?? Date.now;
+        if (this.key)
+            this.eventTarget?.addEventListener("storage", this.onStorage);
+    }
+    read() {
+        if (this.destroyed || !this.key || !this.storage)
+            return null;
+        try {
+            const value = this.parse(this.storage.getItem(this.key));
+            this.lastKnownReceipt = value;
+            return value;
+        }
+        catch {
+            this.lastKnownReceipt = null;
+            return null;
+        }
+    }
+    remember(value) {
+        if (this.destroyed ||
+            !this.binding ||
+            !this.key ||
+            !this.storage ||
+            !validReceipt(value.receipt) ||
+            !validExpiry(value.expiresAt, this.now())) {
+            return false;
+        }
+        const previous = this.read();
+        const record = {
+            version: STORAGE_RECORD_VERSION,
+            kind: STORAGE_RECORD_KIND,
+            binding: this.binding,
+            receipt: value.receipt,
+            expiresAt: value.expiresAt,
+        };
+        try {
+            const serialized = JSON.stringify(record);
+            if (serialized.length > MAX_STORAGE_RECORD_LENGTH)
+                return false;
+            this.storage.setItem(this.key, serialized);
+            const stored = this.read();
+            if (stored?.receipt !== value.receipt ||
+                stored.expiresAt !== value.expiresAt) {
+                return false;
+            }
+            this.notify(stored, previous);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    clear() {
+        if (this.destroyed || !this.key || !this.storage)
+            return;
+        const previous = this.read();
+        try {
+            this.storage.removeItem(this.key);
+        }
+        catch {
+            return;
+        }
+        this.notify(null, previous);
+    }
+    subscribe(listener) {
+        if (this.destroyed)
+            return () => undefined;
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.eventTarget?.removeEventListener("storage", this.onStorage);
+        this.listeners.clear();
+    }
+    parse(value) {
+        if (!value || value.length > MAX_STORAGE_RECORD_LENGTH || !this.binding) {
+            return null;
+        }
+        try {
+            const candidate = JSON.parse(value);
+            const binding = parseBinding(candidate.binding);
+            if (candidate.version !== STORAGE_RECORD_VERSION ||
+                candidate.kind !== STORAGE_RECORD_KIND ||
+                !binding ||
+                !sameBinding(binding, this.binding) ||
+                !validReceipt(candidate.receipt) ||
+                !validExpiry(candidate.expiresAt, this.now())) {
+                return null;
+            }
+            return {
+                receipt: candidate.receipt,
+                expiresAt: candidate.expiresAt,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    notify(value, previous) {
+        this.lastKnownReceipt = value;
+        if (sameReceipt(value, previous))
+            return;
+        for (const listener of this.listeners) {
+            try {
+                listener(value, previous);
+            }
+            catch {
+                // Consumer callbacks cannot interrupt permission revocation.
+            }
+        }
+    }
+}
+exports.PageAssistancePreferenceStore = PageAssistancePreferenceStore;

package/cjs/preview.d.ts

@@ -0,0 +1,33 @@
+import type { AiGuidePreviewBridge, AiGuidePreviewController, AiGuidePreviewControllerState, AiGuidePreviewInput, BootstrapConfig } from "./types.js";
+export declare const AI_GUIDE_PREVIEW_PARENT_SOURCE = "oxvo-ai-guide-settings-preview";
+export declare const AI_GUIDE_PREVIEW_WIDGET_SOURCE = "oxvo-ai-guide-widget-preview";
+export declare const AI_GUIDE_PREVIEW_PROTOCOL_VERSION = 1;
+export declare const AI_GUIDE_PREVIEW_RENDERER_VERSION = "1.0.27";
+export declare const buildAiGuidePreviewBootstrap: (draft: unknown) => BootstrapConfig;
+export declare class AiGuidePreviewControllerImpl implements AiGuidePreviewController {
+    private readonly port;
+    private readonly nonce;
+    private view;
+    private config;
+    private display;
+    private mode;
+    private destroyed;
+    private rendering;
+    constructor(port: MessagePort, nonce: string);
+    update(input: AiGuidePreviewInput): void;
+    getState(): AiGuidePreviewControllerState;
+    destroy(): void;
+    private resolveMode;
+    private resolveModeForConfig;
+    private hasInteractiveMode;
+    private scheduleRender;
+    private callbacks;
+    private render;
+    private blockNavigation;
+    private onMessage;
+    private post;
+}
+export declare const installAiGuidePreview: (options: {
+    parentOrigin: string;
+    nonce: string;
+}, currentWindow?: Window) => AiGuidePreviewBridge | undefined;