codex-chatgpt-control 0.5.1-alpha.2 → 0.5.1-alpha.4

package/dist/src/operations/transactional-chat-power.d.ts

@@ -0,0 +1,17 @@
+import { type ChatPopoverSnapshot } from "../commands/chat-popover.js";
+import type { LocatorLike, PageLike } from "../types.js";
+export type TransactionalChatPower = Readonly<{
+    presentation: "closed" | "simple";
+    triggerId: string;
+    currentLabel: string;
+    modelMarker: string;
+    popover?: ChatPopoverSnapshot;
+}>;
+/** Read current scoped Chat effort without opening a menu or probing a value. */
+export declare function readTransactionalChatPower(page: Readonly<PageLike>): Promise<TransactionalChatPower | undefined>;
+export declare function transactionalPowerTrigger(page: Readonly<PageLike>, snapshot: TransactionalChatPower): LocatorLike | undefined;
+export declare function preflightTransactionalPowerTrigger(locator: LocatorLike, snapshot: TransactionalChatPower): Promise<boolean>;
+export declare function transactionalPowerMenu(page: Readonly<PageLike>, snapshot: TransactionalChatPower): LocatorLike | undefined;
+export declare function transactionalPowerSlider(page: Readonly<PageLike>, snapshot: TransactionalChatPower): LocatorLike | undefined;
+/** Locator preflight is read-only and uses the same active/owned rules as discovery. */
+export declare function preflightTransactionalPowerSlider(locator: LocatorLike, snapshot: TransactionalChatPower): Promise<boolean>;

package/dist/src/operations/transactional-chat-power.js

@@ -0,0 +1,212 @@
+import { localeLabels } from "../dom/locale-labels.js";
+import { readChatPopover } from "../commands/chat-popover.js";
+/** Read current scoped Chat effort without opening a menu or probing a value. */
+export async function readTransactionalChatPower(page) {
+    const popover = (await readChatPopover(page)).snapshot;
+    if (page.evaluate === undefined)
+        return undefined;
+    const expandedTriggerLabels = ["Thinking effort"];
+    const trigger = await page.evaluate((config) => {
+        const normalize = (value) => value.replace(/\s+/g, " ").trim();
+        const visible = (element) => {
+            let current = element;
+            for (let depth = 0; current !== null && depth < 64; depth += 1) {
+                if (current.nodeType !== 1)
+                    return true;
+                const node = current;
+                if (node.hidden || node.hasAttribute("hidden") || node.hasAttribute("inert") || node.getAttribute("aria-hidden") === "true"
+                    || node.getAttribute("aria-disabled") === "true" || node.getAttribute("data-active") === "false")
+                    return false;
+                const style = window.getComputedStyle(node);
+                if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0" || style.pointerEvents === "none")
+                    return false;
+                if (current === element) {
+                    const rect = node.getBoundingClientRect();
+                    if (rect.width <= 0 || rect.height <= 0)
+                        return false;
+                }
+                current = current.parentNode;
+            }
+            return current === null;
+        };
+        const forms = document.querySelectorAll("main form");
+        if (forms.length > 8)
+            return undefined;
+        const candidates = [];
+        let visited = 0;
+        for (const form of Array.from(forms)) {
+            if (!visible(form))
+                continue;
+            const nodes = [];
+            let node = form.firstChild;
+            while (node !== null) {
+                if (++visited > 4096)
+                    return undefined;
+                if (node.nodeType === 1)
+                    nodes.push(node);
+                if (node.firstChild !== null) {
+                    node = node.firstChild;
+                    continue;
+                }
+                while (node !== null && node !== form && node.nextSibling === null)
+                    node = node.parentNode;
+                if (node === form || node === null)
+                    break;
+                node = node.nextSibling;
+            }
+            const editors = nodes.filter(node => (node.tagName === "TEXTAREA" || node.getAttribute("contenteditable") === "true" || node.getAttribute("role") === "textbox") && visible(node));
+            if (editors.length !== 1)
+                continue;
+            const editor = editors[0];
+            const editorLabel = normalize(editor.getAttribute("aria-label") ?? editor.getAttribute("placeholder") ?? "").toLocaleLowerCase();
+            if (!config.chatLabels.some(label => normalize(label).toLocaleLowerCase() === editorLabel)
+                || config.workLabels.some(label => normalize(label).toLocaleLowerCase() === editorLabel))
+                continue;
+            for (const button of nodes) {
+                if (button.tagName !== "BUTTON" || !visible(button) || button.disabled
+                    || button.getAttribute("aria-haspopup") !== "menu"
+                    || !(button.getAttribute("class") ?? "").split(/\s+/).includes("__composer-pill"))
+                    continue;
+                const expanded = button.getAttribute("aria-expanded");
+                const id = button.getAttribute("id");
+                if ((expanded !== "true" && expanded !== "false") || id === null || id.length === 0 || id.length > 240 || /\s/.test(id))
+                    continue;
+                let raw = "";
+                let child = button.firstChild;
+                while (child !== null) {
+                    if (++visited > 4096)
+                        return undefined;
+                    const hidden = child.nodeType === 1 && !visible(child);
+                    if (child.nodeType === 3) {
+                        raw += child.nodeValue ?? "";
+                        if (raw.length > 240)
+                            return undefined;
+                    }
+                    if (!hidden && child.firstChild !== null) {
+                        child = child.firstChild;
+                        continue;
+                    }
+                    while (child !== null && child !== button && child.nextSibling === null)
+                        child = child.parentNode;
+                    if (child === button || child === null)
+                        break;
+                    child = child.nextSibling;
+                }
+                const text = normalize(raw);
+                const labels = [...config.effortLabels, ...(expanded === "true" ? config.expandedTriggerLabels : [])]
+                    .filter(label => text.toLocaleLowerCase().endsWith(label.toLocaleLowerCase()))
+                    .sort((left, right) => right.length - left.length);
+                const currentLabel = labels[0];
+                if (currentLabel === undefined)
+                    continue;
+                const prefix = normalize(text.slice(0, text.length - currentLabel.length));
+                if (prefix.length > 0 && !/^(?:latest|(?:gpt[\s-]?)?\d+(?:\.\d+)?(?:[ .-][a-z]+)?)$/i.test(prefix))
+                    continue;
+                candidates.push({ triggerId: id, currentLabel: text.slice(text.length - currentLabel.length), modelMarker: prefix, expanded: expanded === "true" });
+            }
+        }
+        return candidates.length === 1 ? candidates[0] : undefined;
+    }, {
+        chatLabels: localeLabels.composerTextbox,
+        workLabels: localeLabels.workComposerTextbox,
+        effortLabels: Array.from(new Set([...Object.values(localeLabels.configurationOptions).flat(), ...Object.entries(localeLabels.modeOptions).filter(([key]) => key !== "latest").flatMap(([, labels]) => labels)])),
+        expandedTriggerLabels
+    }).catch(() => undefined);
+    if (trigger === undefined || trigger === null || typeof trigger.currentLabel !== "string")
+        return undefined;
+    if (!trigger.expanded) {
+        if (popover !== undefined)
+            return undefined;
+        return { presentation: "closed", triggerId: trigger.triggerId, currentLabel: trigger.currentLabel, modelMarker: trigger.modelMarker };
+    }
+    if (popover?.view !== "simple" || popover.slider === undefined || popover.effort === undefined
+        || popover.triggerId !== trigger.triggerId
+        || (popover.effort !== trigger.currentLabel && !expandedTriggerLabels.includes(trigger.currentLabel)))
+        return undefined;
+    return { presentation: "simple", triggerId: trigger.triggerId, currentLabel: popover.effort, modelMarker: trigger.modelMarker, popover };
+}
+function idSelector(id) { return `[id="${id.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]`; }
+export function transactionalPowerTrigger(page, snapshot) {
+    return page.locator?.(idSelector(snapshot.triggerId));
+}
+export async function preflightTransactionalPowerTrigger(locator, snapshot) {
+    if (locator.evaluate === undefined || await locator.count?.() !== 1)
+        return false;
+    const state = await locator.evaluate(element => {
+        let current = element;
+        let form = false, main = false;
+        for (let depth = 0; current !== null && depth < 64; depth += 1) {
+            if (current.nodeType !== 1)
+                break;
+            const node = current;
+            if (node.hidden || node.hasAttribute("hidden") || node.hasAttribute("inert") || node.getAttribute("aria-hidden") === "true"
+                || node.getAttribute("aria-disabled") === "true" || node.getAttribute("data-active") === "false")
+                return undefined;
+            const style = window.getComputedStyle(node);
+            if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0" || style.pointerEvents === "none")
+                return undefined;
+            if (node.tagName === "FORM")
+                form = true;
+            if (node.tagName === "MAIN" && form)
+                main = true;
+            current = current.parentNode;
+        }
+        const rect = element.getBoundingClientRect();
+        if (current?.nodeType === 1 || !form || !main || rect.width <= 0 || rect.height <= 0 || element.tagName !== "BUTTON"
+            || element.disabled || element.hasAttribute("disabled")
+            || !(element.getAttribute("class") ?? "").split(/\s+/).includes("__composer-pill"))
+            return undefined;
+        return { id: element.getAttribute("id"), expanded: element.getAttribute("aria-expanded"), popup: element.getAttribute("aria-haspopup") };
+    }).catch(() => undefined);
+    return state !== undefined && state.id === snapshot.triggerId && state.expanded === "false" && state.popup === "menu";
+}
+export function transactionalPowerMenu(page, snapshot) {
+    return page.locator?.(`[role="menu"][aria-labelledby="${snapshot.triggerId.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]`);
+}
+export function transactionalPowerSlider(page, snapshot) {
+    const popover = snapshot.popover;
+    if (popover?.slider === undefined)
+        return undefined;
+    const roots = page.locator?.('[data-testid="composer-intelligence-picker-content"]');
+    const root = roots?.nth?.(popover.rootIndex) ?? (popover.rootIndex === 0 ? roots : undefined);
+    const sliders = root?.locator?.('[data-testid="composer-model-picker-slider-simple-view"][data-active="true"] [role="slider"]');
+    return sliders?.nth?.(popover.slider.index) ?? (popover.slider.index === 0 ? sliders : undefined);
+}
+/** Locator preflight is read-only and uses the same active/owned rules as discovery. */
+export async function preflightTransactionalPowerSlider(locator, snapshot) {
+    if (locator.evaluate === undefined || await locator.count?.() !== 1 || snapshot.popover?.slider === undefined)
+        return false;
+    const state = await locator.evaluate(element => {
+        let current = element;
+        let owner = false, panel = false, view = false;
+        let triggerId = null;
+        for (let depth = 0; current !== null && depth < 64; depth += 1) {
+            if (current.nodeType !== 1)
+                break;
+            const node = current;
+            if (node.hidden || node.hasAttribute("hidden") || node.hasAttribute("inert") || node.getAttribute("data-active") === "false"
+                || node.getAttribute("aria-disabled") === "true" || node.getAttribute("data-locked") === "true"
+                || (current !== element && node.getAttribute("aria-hidden") === "true"))
+                return undefined;
+            const style = window.getComputedStyle(node);
+            if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0" || style.pointerEvents === "none")
+                return undefined;
+            if (node.getAttribute("data-testid") === "composer-intelligence-picker-content")
+                owner = true;
+            if (node.getAttribute("data-testid") === "composer-model-picker-slider-simple-view" && node.getAttribute("data-active") === "true")
+                panel = true;
+            if (node.getAttribute("data-view") === "simple" && node.getAttribute("data-has-slider") === "true"
+                && node.getAttribute("data-has-advanced-view") === "true" && node.getAttribute("data-model-selection-view") === "true")
+                view = true;
+            if (node.getAttribute("role") === "menu" && node.getAttribute("data-state") === "open")
+                triggerId = node.getAttribute("aria-labelledby");
+            current = current.parentNode;
+        }
+        const rect = element.getBoundingClientRect();
+        if (current?.nodeType === 1 || !owner || !panel || !view || rect.width <= 0 || rect.height <= 0 || element.getAttribute("role") !== "slider")
+            return undefined;
+        return { triggerId, minimum: element.getAttribute("aria-valuemin"), maximum: element.getAttribute("aria-valuemax"), current: element.getAttribute("aria-valuenow") };
+    }).catch(() => undefined);
+    return state !== undefined && state.triggerId === snapshot.triggerId && state.minimum === String(snapshot.popover.slider.minimum)
+        && state.maximum === String(snapshot.popover.slider.maximum) && state.current === String(snapshot.popover.slider.current);
+}

package/dist/src/operations/turn-ownership.d.ts

@@ -0,0 +1,202 @@
+/**
+ * The turn ownership classifier deliberately accepts normalized, already
+ * redacted observations.  It must never be handed DOM nodes or prompt text.
+ * Adapters are responsible for producing the bounded digests in these types.
+ */
+export declare const TURN_OWNERSHIP_SCHEMA_VERSION: "chatgpt.browser_control.turn_ownership.v1";
+export type OwnershipDigest = string;
+export type OwnershipIdentityEvidence = {
+    readonly status: "available";
+    /** Stable provider/browser/tab/thread identity, never user content. */
+    readonly value: string;
+} | {
+    readonly status: "unavailable";
+    readonly reason: "not_exposed" | "not_observed" | "redacted";
+};
+export type OwnershipTargetEvidence = {
+    readonly provider: OwnershipIdentityEvidence;
+    readonly browser: OwnershipIdentityEvidence;
+    readonly tab: OwnershipIdentityEvidence;
+    readonly thread: OwnershipIdentityEvidence;
+    readonly conversation: OwnershipIdentityEvidence;
+    readonly canonicalThreadUrl: OwnershipIdentityEvidence;
+    readonly authoritativeTabClaim: OwnershipIdentityEvidence;
+    readonly coordinationScope: "process" | "provider";
+};
+export type OwnershipEvidenceProfile = {
+    readonly stableConversationId: "required" | "unavailable";
+    readonly stableUserTurnId: "required" | "unavailable";
+    readonly stableAssistantTurnId: "required" | "unavailable";
+    readonly stableBranchId: "required" | "unavailable";
+    readonly authoritativeTabClaim: "required" | "unavailable";
+};
+export type OwnershipBinding = {
+    readonly schemaVersion: typeof TURN_OWNERSHIP_SCHEMA_VERSION;
+    readonly operationId: string;
+    readonly targetBindingDigest: OwnershipDigest;
+    readonly target: OwnershipTargetEvidence;
+    readonly evidenceProfile: OwnershipEvidenceProfile;
+    readonly replacementTabRecovery: boolean;
+    readonly actionId: string;
+    readonly actionKind: "send" | "work_steer";
+};
+export type OwnershipTurn = {
+    /** Stable turn ID, when the provider exposes one. Never raw turn text. */
+    readonly stableId?: string;
+    /** HMAC/cryptographic evidence digest for the normalized turn. */
+    readonly evidenceDigest: OwnershipDigest;
+    /** Deterministic structure digest; text is never accepted by this module. */
+    readonly structureDigest: OwnershipDigest;
+    /** Ordered position in the normalized provider snapshot. */
+    readonly ordinal: number;
+    /** Stable parent identity for assistant turns. */
+    readonly parentStableId?: string;
+    /** Stable branch identity for assistant turns. */
+    readonly branchStableId?: string;
+    readonly state?: "generating" | "terminal";
+    readonly artifactEvidenceDigests?: readonly OwnershipDigest[];
+};
+export type OwnershipSnapshotCompleteness = "complete" | "truncated" | "incomplete" | "out_of_order";
+export type OwnershipSnapshot = {
+    readonly schemaVersion: typeof TURN_OWNERSHIP_SCHEMA_VERSION;
+    readonly snapshotDigest: OwnershipDigest;
+    readonly target: OwnershipTargetEvidence;
+    readonly userTurns: readonly OwnershipTurn[];
+    readonly assistantTurns: readonly OwnershipTurn[];
+    readonly completeness: OwnershipSnapshotCompleteness;
+    readonly terminalState: "idle" | "generating" | "terminal" | "unknown";
+    /** Captured by the adapter after Send using the exact before/after delta. */
+    readonly postSendDelta?: OwnershipDeltaEvidence;
+};
+export type OwnershipBaseline = {
+    readonly schemaVersion: typeof TURN_OWNERSHIP_SCHEMA_VERSION;
+    /** Digest of the complete pre-Send normalized snapshot. */
+    readonly snapshotDigest: OwnershipDigest;
+    readonly target: OwnershipTargetEvidence;
+    readonly userTurns: readonly OwnershipTurn[];
+    readonly assistantTurns: readonly OwnershipTurn[];
+    readonly completeness: "complete";
+};
+export type OwnershipDeltaEvidence = {
+    readonly baselineSnapshotDigest: OwnershipDigest;
+    /** Exact new-user evidence digests from the normalized before/after delta. */
+    readonly addedUserEvidenceDigests: readonly OwnershipDigest[];
+    /** Digest over the canonical delta object, generated by the adapter. */
+    readonly deltaDigest: OwnershipDigest;
+};
+export type OwnershipSubmissionWitness = {
+    readonly actionId: string;
+    readonly actionKind: "send" | "work_steer";
+    /** Digest of the complete authenticated pre-Send ownership snapshot. */
+    readonly baselineSnapshotDigest: OwnershipDigest;
+    /** Durable action evidence for the exact post-Send user-turn delta. */
+    readonly postSendDeltaDigest: OwnershipDigest;
+    /** Durable evidence for the operation's submitted user turn. */
+    readonly operationUserEvidenceDigest: OwnershipDigest;
+    /** Optional immediate stable ID returned by the provider. */
+    readonly userTurnStableId?: string;
+};
+export type OwnershipCursorPhase = "owned_user_turn" | "owned_assistant_generating" | "owned_assistant_terminal";
+export type OwnershipCursor = Readonly<{
+    readonly schemaVersion: typeof TURN_OWNERSHIP_SCHEMA_VERSION;
+    readonly operationId: string;
+    readonly targetBindingDigest: OwnershipDigest;
+    readonly phase: OwnershipCursorPhase;
+    readonly userTurnId: string;
+    readonly userTurnEvidenceDigest: OwnershipDigest;
+    readonly assistantTurnId?: string;
+    readonly assistantBranchId?: string;
+    /** Digest of the normalized snapshot from which this cursor was issued. */
+    readonly snapshotDigest: OwnershipDigest;
+    /** Frozen assistant evidence used to detect mutation after terminal capture. */
+    readonly assistantEvidenceDigest?: OwnershipDigest;
+    readonly assistantStructureDigest?: OwnershipDigest;
+}>;
+export type OwnershipResultStatus = "no_operation_turn" | "owned_user_turn" | "owned_assistant_generating" | "owned_assistant_terminal" | "target_mismatch" | "target_evidence_unavailable" | "concurrent_user_turn" | "regeneration_ambiguous" | "ownership_ambiguous";
+export type OwnershipReason = "none" | "target_binding_mismatch" | "target_evidence_unavailable" | "replacement_tab_requires_owned_user" | "incomplete_snapshot" | "out_of_order_snapshot" | "baseline_turn_missing" | "baseline_turn_changed" | "intervening_user_turn" | "multiple_new_user_turns" | "operation_user_evidence_mismatch" | "post_send_delta_missing" | "post_send_delta_mismatch" | "stable_user_turn_id_unavailable" | "stable_assistant_turn_id_unavailable" | "stable_parent_identity_unavailable" | "stable_branch_identity_unavailable" | "assistant_parent_mismatch" | "assistant_state_unknown" | "terminal_state_mismatch" | "regeneration_siblings" | "prior_owned_turn_missing" | "prior_owned_turn_changed" | "prior_cursor_mismatch" | "unexpected_new_assistant_turn" | "baseline_target_mismatch";
+export type OwnershipRecoveryObservation = {
+    readonly status: "not_observed";
+} | {
+    readonly status: "owned_user_turn";
+    readonly userTurnId: string;
+    readonly evidenceDigest: OwnershipDigest;
+} | {
+    readonly status: "owned_assistant_generating";
+    readonly userTurnId: string;
+    readonly assistantTurnId: string;
+    readonly evidenceDigest: OwnershipDigest;
+} | {
+    readonly status: "owned_assistant_terminal";
+    readonly userTurnId: string;
+    readonly assistantTurnId: string;
+    readonly evidenceDigest: OwnershipDigest;
+} | {
+    readonly status: "ambiguous";
+    readonly evidenceDigest?: OwnershipDigest;
+};
+export type OwnershipEvidenceMaterial = Readonly<{
+    readonly schemaVersion: typeof TURN_OWNERSHIP_SCHEMA_VERSION;
+    readonly operationId: string;
+    readonly status: OwnershipResultStatus;
+    readonly reason: OwnershipReason;
+    readonly target: Readonly<{
+        readonly provider: "available" | "unavailable";
+        readonly browser: "available" | "unavailable";
+        readonly tab: "available" | "unavailable";
+        readonly thread: "available" | "unavailable";
+        readonly conversation: "available" | "unavailable";
+        readonly canonicalThreadUrl: "available" | "unavailable";
+        readonly authoritativeTabClaim: "available" | "unavailable";
+        readonly replacedTab: boolean;
+    }>;
+    readonly baselineSnapshotDigest: OwnershipDigest;
+    readonly snapshotDigest: OwnershipDigest;
+    readonly postSendDeltaDigest?: OwnershipDigest;
+    readonly addedUserCount: number;
+    readonly addedAssistantCount: number;
+    readonly terminalState: OwnershipSnapshot["terminalState"];
+    readonly userTurn?: Readonly<{
+        readonly evidenceDigest: OwnershipDigest;
+        readonly structureDigest: OwnershipDigest;
+        readonly ordinal: number;
+        readonly stableIdAvailable: boolean;
+        readonly parentStableIdAvailable: boolean;
+        readonly branchStableIdAvailable: boolean;
+        readonly artifactEvidenceDigests: readonly OwnershipDigest[];
+        readonly state?: OwnershipTurn["state"];
+    }>;
+    readonly assistantTurn?: Readonly<{
+        readonly evidenceDigest: OwnershipDigest;
+        readonly structureDigest: OwnershipDigest;
+        readonly ordinal: number;
+        readonly stableIdAvailable: boolean;
+        readonly parentStableIdAvailable: boolean;
+        readonly branchStableIdAvailable: boolean;
+        readonly artifactEvidenceDigests: readonly OwnershipDigest[];
+        readonly state?: OwnershipTurn["state"];
+    }>;
+}>;
+export type OwnershipClassification = Readonly<{
+    readonly status: OwnershipResultStatus;
+    readonly reason: OwnershipReason;
+    readonly evidence: OwnershipEvidenceMaterial;
+    readonly recoveryObservation: OwnershipRecoveryObservation;
+    readonly cursor?: OwnershipCursor;
+}>;
+export type TurnOwnershipInput = {
+    readonly binding: OwnershipBinding;
+    readonly baseline: OwnershipBaseline;
+    readonly snapshot: OwnershipSnapshot;
+    readonly submissionWitness?: OwnershipSubmissionWitness;
+    readonly prior?: OwnershipCursor;
+};
+/**
+ * Classify one normalized snapshot.  This function has no browser, DOM, or
+ * I/O dependency.  It only permits an owned user turn when the adapter has
+ * supplied the exact post-Send delta digest and operation-specific evidence.
+ */
+export declare function classifyTurnOwnership(input: TurnOwnershipInput): OwnershipClassification;
+/** Return the deterministic, redacted JSON input a caller may HMAC. */
+export declare function ownershipEvidenceJson(material: OwnershipEvidenceMaterial): string;
+/** Validate a cursor before persisting or supplying it to a later snapshot. */
+export declare function validateOwnershipCursor(cursor: OwnershipCursor): void;