@tomflow/proflow-execution-browser-extension 0.1.36 → 0.1.38

package/dist/src/carrier-attention-view.d.ts

@@ -0,0 +1,13 @@
+export type CarrierAttentionView = {
+    attentionRef: string;
+    occurrenceRef: string;
+    taskId: string | null;
+    roleRef: string | null;
+    workerRef: string | null;
+    targetHost: string | null;
+    operationId: string;
+    reason: string;
+    actions: Array<"allowOnce" | "deny">;
+    observedAt: string;
+};
+export declare function parseCarrierAttentionViews(value: unknown): CarrierAttentionView[];

package/dist/src/carrier-attention-view.js

@@ -0,0 +1,54 @@
+function nullableString(value) {
+    return value === null || typeof value === "string";
+}
+function parseCarrierAttentionView(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const attentionRef = Reflect.get(value, "attentionRef");
+    const occurrenceRef = Reflect.get(value, "occurrenceRef");
+    const taskId = Reflect.get(value, "taskId");
+    const roleRef = Reflect.get(value, "roleRef");
+    const workerRef = Reflect.get(value, "workerRef");
+    const targetHost = Reflect.get(value, "targetHost");
+    const operationId = Reflect.get(value, "operationId");
+    const reason = Reflect.get(value, "reason");
+    const actions = Reflect.get(value, "actions");
+    const observedAt = Reflect.get(value, "observedAt");
+    if (typeof attentionRef !== "string" ||
+        attentionRef.length === 0 ||
+        typeof occurrenceRef !== "string" ||
+        occurrenceRef.length === 0 ||
+        !nullableString(taskId) ||
+        !nullableString(roleRef) ||
+        !nullableString(workerRef) ||
+        !nullableString(targetHost) ||
+        typeof operationId !== "string" ||
+        operationId.length === 0 ||
+        typeof reason !== "string" ||
+        reason.length === 0 ||
+        !Array.isArray(actions) ||
+        actions.some((action) => action !== "allowOnce" && action !== "deny") ||
+        typeof observedAt !== "string" ||
+        observedAt.length === 0)
+        return null;
+    return {
+        attentionRef,
+        occurrenceRef,
+        taskId,
+        roleRef,
+        workerRef,
+        targetHost,
+        operationId,
+        reason,
+        actions: [...actions],
+        observedAt,
+    };
+}
+export function parseCarrierAttentionViews(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .slice(0, 128)
+        .map(parseCarrierAttentionView)
+        .filter((item) => item !== null);
+}

package/dist/src/carrier-attention.d.ts

@@ -0,0 +1,26 @@
+export type CarrierAttentionAction = "allowOnce" | "deny";
+export type CarrierAttention = {
+    attentionRef: string;
+    occurrenceRef: string;
+    tabId: number;
+    contentInstanceId: string;
+    url: string;
+    permissionFingerprint: string;
+    taskId: string | null;
+    roleRef: string | null;
+    workerRef: string | null;
+    targetHost: string | null;
+    operationId: string;
+    reason: string;
+    actions: CarrierAttentionAction[];
+    observedAt: string;
+};
+export type CarrierAttentionInput = Omit<CarrierAttention, "attentionRef" | "occurrenceRef">;
+export declare function createCarrierAttentionRegistry(idFactory?: () => string): Readonly<{
+    derive(input: CarrierAttentionInput): CarrierAttention;
+    find(attentionRef: string): CarrierAttention | null;
+    current(tabId: number): CarrierAttention | null;
+    values(): CarrierAttention[];
+    delete(attentionRef: string): boolean;
+    removeTab(tabId: number): boolean;
+}>;

package/dist/src/carrier-attention.js

@@ -0,0 +1,44 @@
+export function createCarrierAttentionRegistry(idFactory = () => crypto.randomUUID()) {
+    const byTab = new Map();
+    return Object.freeze({
+        derive(input) {
+            const current = byTab.get(input.tabId);
+            if (current?.contentInstanceId === input.contentInstanceId &&
+                current.url === input.url &&
+                current.permissionFingerprint === input.permissionFingerprint) {
+                const refreshed = { ...current, ...input };
+                byTab.set(input.tabId, refreshed);
+                return refreshed;
+            }
+            const occurrenceRef = idFactory();
+            const attention = {
+                ...input,
+                occurrenceRef,
+                attentionRef: `carrier-attention:${input.tabId}:${occurrenceRef}`,
+            };
+            byTab.set(input.tabId, attention);
+            return attention;
+        },
+        find(attentionRef) {
+            for (const attention of byTab.values())
+                if (attention.attentionRef === attentionRef)
+                    return attention;
+            return null;
+        },
+        current(tabId) {
+            return byTab.get(tabId) ?? null;
+        },
+        values() {
+            return [...byTab.values()];
+        },
+        delete(attentionRef) {
+            for (const [tabId, attention] of byTab)
+                if (attention.attentionRef === attentionRef)
+                    return byTab.delete(tabId);
+            return false;
+        },
+        removeTab(tabId) {
+            return byTab.delete(tabId);
+        },
+    });
+}

package/dist/src/carrier-continuation-control.d.ts

@@ -0,0 +1,44 @@
+export type CarrierContinuationDenial = {
+    attentionRef: string;
+    tabId: number;
+    taskId: string | null;
+    roleRef: string | null;
+    workerRef: string | null;
+    url: string;
+    contentInstanceId: string;
+    permissionFingerprint: string;
+};
+export type CarrierRecoveryObservation = {
+    tabId: number;
+    url: string;
+    contentInstanceId?: string;
+    pageState: "IDLE" | "BUSY" | "BLOCKED" | "UNKNOWN";
+    blockerFacts?: {
+        fingerprint: string;
+    };
+};
+export type CarrierPermissionDenialContext = {
+    tabId: number;
+    contentInstanceId: string;
+    url: string;
+    permissionFingerprint: string;
+    taskId: string | null;
+    roleRef: string | null;
+    workerRef: string | null;
+};
+export type CarrierDispatchDenialContext = {
+    taskId: string;
+    roleRef: string;
+    workerRef: string;
+    conversationLocator: string | null;
+};
+export declare function createCarrierContinuationControl(initial?: unknown): Readonly<{
+    beginDenied(denial: CarrierContinuationDenial): void;
+    cancelDenied(attentionRef: string): boolean;
+    hasMatchingPermissionDenial(context: CarrierPermissionDenialContext): boolean;
+    hasMatchingDispatchDenial(context: CarrierDispatchDenialContext): boolean;
+    consumeRecovery(previous: CarrierRecoveryObservation | undefined, current: CarrierRecoveryObservation): CarrierContinuationDenial | null;
+    suppressRecovery(previous: CarrierRecoveryObservation | undefined, current: CarrierRecoveryObservation): boolean;
+    snapshot(): CarrierContinuationDenial[];
+    load: (value: unknown) => boolean;
+}>;

package/dist/src/carrier-continuation-control.js

@@ -0,0 +1,114 @@
+function parseDenials(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 128)
+        return null;
+    const parsed = [];
+    for (const item of value) {
+        if (typeof item !== "object" || item === null || Array.isArray(item))
+            return null;
+        const attentionRef = Reflect.get(item, "attentionRef");
+        const tabId = Reflect.get(item, "tabId");
+        const taskId = Reflect.get(item, "taskId");
+        const roleRef = Reflect.get(item, "roleRef");
+        const workerRef = Reflect.get(item, "workerRef");
+        const url = Reflect.get(item, "url");
+        const contentInstanceId = Reflect.get(item, "contentInstanceId");
+        const permissionFingerprint = Reflect.get(item, "permissionFingerprint");
+        if (typeof attentionRef !== "string" ||
+            !Number.isInteger(tabId) ||
+            (taskId !== null && typeof taskId !== "string") ||
+            (roleRef !== null && typeof roleRef !== "string") ||
+            (workerRef !== null && typeof workerRef !== "string") ||
+            typeof url !== "string" ||
+            typeof contentInstanceId !== "string" ||
+            typeof permissionFingerprint !== "string")
+            return null;
+        parsed.push({
+            attentionRef,
+            tabId: tabId,
+            taskId,
+            roleRef,
+            workerRef,
+            url,
+            contentInstanceId,
+            permissionFingerprint,
+        });
+    }
+    return parsed;
+}
+export function createCarrierContinuationControl(initial) {
+    const byTab = new Map();
+    const load = (value) => {
+        const denials = parseDenials(value);
+        byTab.clear();
+        if (!denials)
+            return false;
+        for (const denial of denials)
+            byTab.set(denial.tabId, denial);
+        return true;
+    };
+    if (initial !== undefined)
+        load(initial);
+    return Object.freeze({
+        beginDenied(denial) {
+            byTab.set(denial.tabId, { ...denial });
+        },
+        cancelDenied(attentionRef) {
+            for (const [tabId, denial] of byTab)
+                if (denial.attentionRef === attentionRef)
+                    return byTab.delete(tabId);
+            return false;
+        },
+        hasMatchingPermissionDenial(context) {
+            const denial = byTab.get(context.tabId);
+            return (denial?.contentInstanceId === context.contentInstanceId &&
+                denial.url === context.url &&
+                denial.permissionFingerprint === context.permissionFingerprint &&
+                denial.taskId === context.taskId &&
+                denial.roleRef === context.roleRef &&
+                denial.workerRef === context.workerRef);
+        },
+        hasMatchingDispatchDenial(context) {
+            if (context.conversationLocator === null)
+                return false;
+            for (const denial of byTab.values())
+                if (denial.taskId === context.taskId &&
+                    denial.roleRef === context.roleRef &&
+                    denial.workerRef === context.workerRef &&
+                    denial.url === context.conversationLocator)
+                    return true;
+            return false;
+        },
+        consumeRecovery(previous, current) {
+            const denial = byTab.get(current.tabId);
+            if (!denial)
+                return null;
+            if (denial.url !== current.url ||
+                denial.contentInstanceId !== current.contentInstanceId) {
+                byTab.delete(current.tabId);
+                return null;
+            }
+            if (current.pageState !== "IDLE")
+                return null;
+            if (previous &&
+                (previous.tabId !== denial.tabId ||
+                    previous.url !== denial.url ||
+                    previous.contentInstanceId !== denial.contentInstanceId ||
+                    previous.pageState !== "BLOCKED" ||
+                    previous.blockerFacts?.fingerprint !== denial.permissionFingerprint)) {
+                byTab.delete(current.tabId);
+                return null;
+            }
+            byTab.delete(current.tabId);
+            return { ...denial };
+        },
+        suppressRecovery(previous, current) {
+            return this.consumeRecovery(previous, current) !== null;
+        },
+        snapshot() {
+            return [...byTab.values()].map((denial) => ({ ...denial }));
+        },
+        load,
+    });
+}

package/dist/src/carrier-permission-attempt.d.ts

@@ -0,0 +1,18 @@
+export type CarrierPermissionAttemptSnapshot = ReadonlyArray<{
+    tabId: number;
+    key: string;
+}>;
+/**
+ * Tracks only automatic actions whose post-click reality is not yet known.
+ * A confirmed release removes the entry, so a later identical permission is a
+ * new occurrence; an MV3 service-worker restart reloads the bounded snapshot
+ * and therefore cannot blindly repeat an uncertain click.
+ */
+export declare function createCarrierPermissionAttemptRegistry(initial?: unknown): Readonly<{
+    has(tabId: number, key: string): boolean;
+    begin(tabId: number, key: string): void;
+    release(tabId: number, key: string): boolean;
+    observe(tabId: number, currentKey: string | null): boolean;
+    load(value: unknown): boolean;
+    snapshot(): CarrierPermissionAttemptSnapshot;
+}>;

package/dist/src/carrier-permission-attempt.js

@@ -0,0 +1,68 @@
+function parsedAttempts(value) {
+    const result = new Map();
+    if (value === undefined)
+        return { attempts: result, valid: true };
+    if (!Array.isArray(value))
+        return { attempts: result, valid: false };
+    let valid = value.length <= 256;
+    for (const candidate of value.slice(0, 256)) {
+        if (typeof candidate !== "object" ||
+            candidate === null ||
+            Array.isArray(candidate)) {
+            valid = false;
+            continue;
+        }
+        const tabId = Reflect.get(candidate, "tabId");
+        const key = Reflect.get(candidate, "key");
+        if (!Number.isInteger(tabId) ||
+            tabId < 0 ||
+            typeof key !== "string" ||
+            key.length === 0 ||
+            key.length > 1_000) {
+            valid = false;
+            continue;
+        }
+        if (result.has(tabId))
+            valid = false;
+        result.set(tabId, key);
+    }
+    return { attempts: result, valid };
+}
+/**
+ * Tracks only automatic actions whose post-click reality is not yet known.
+ * A confirmed release removes the entry, so a later identical permission is a
+ * new occurrence; an MV3 service-worker restart reloads the bounded snapshot
+ * and therefore cannot blindly repeat an uncertain click.
+ */
+export function createCarrierPermissionAttemptRegistry(initial) {
+    const attempts = parsedAttempts(initial).attempts;
+    return Object.freeze({
+        has(tabId, key) {
+            return attempts.get(tabId) === key;
+        },
+        begin(tabId, key) {
+            attempts.set(tabId, key);
+        },
+        release(tabId, key) {
+            if (attempts.get(tabId) !== key)
+                return false;
+            return attempts.delete(tabId);
+        },
+        observe(tabId, currentKey) {
+            const attempted = attempts.get(tabId);
+            if (attempted === undefined || attempted === currentKey)
+                return false;
+            return attempts.delete(tabId);
+        },
+        load(value) {
+            const parsed = parsedAttempts(value);
+            attempts.clear();
+            for (const [tabId, key] of parsed.attempts)
+                attempts.set(tabId, key);
+            return parsed.valid;
+        },
+        snapshot() {
+            return [...attempts].map(([tabId, key]) => ({ tabId, key }));
+        },
+    });
+}

package/dist/src/carrier-permission-lifecycle.d.ts

@@ -0,0 +1,34 @@
+import type { ActionPermissionFacts, PermissionSemanticAction } from "./carrier-permission.ts";
+export type CarrierPermissionDecision = {
+    decision: "AUTO_ALLOW" | "DEFER" | "HUMAN_REQUIRED";
+    reason: string;
+};
+export type CarrierPermissionLifecycleResult = {
+    status: "RELEASED";
+    action: "allowAlways";
+} | {
+    status: "HUMAN_REQUIRED";
+    reason: string;
+} | {
+    status: "STALE";
+};
+export type CarrierPermissionLifecyclePort = {
+    classify(): Promise<CarrierPermissionDecision>;
+    revalidate(): boolean | Promise<boolean>;
+    waitBeforeReclassify?(): Promise<void>;
+    act(action: PermissionSemanticAction): Promise<void>;
+    released(): Promise<boolean>;
+};
+export declare function resolveRoutineCarrierPermission(input: {
+    facts: ActionPermissionFacts;
+    autoAlreadyAttempted: boolean;
+    maxClassifications?: number;
+    humanDenied?: () => boolean;
+    port: CarrierPermissionLifecyclePort;
+}): Promise<CarrierPermissionLifecycleResult>;
+export declare function resolveHumanCarrierPermission(input: {
+    action: "allowOnce" | "deny";
+    revalidate(): boolean | Promise<boolean>;
+    act(action: "allowOnce" | "deny"): Promise<void>;
+    released(): Promise<boolean>;
+}): Promise<"RELEASED">;

package/dist/src/carrier-permission-lifecycle.js

@@ -0,0 +1,73 @@
+export async function resolveRoutineCarrierPermission(input) {
+    const denied = () => input.humanDenied?.()
+        ? { status: "HUMAN_REQUIRED", reason: "HUMAN_DENIED" }
+        : null;
+    const maxClassifications = Math.max(1, input.maxClassifications ?? 40);
+    let decision = null;
+    for (let attempt = 0; attempt < maxClassifications; attempt += 1) {
+        const beforeClassification = denied();
+        if (beforeClassification)
+            return beforeClassification;
+        try {
+            decision = await input.port.classify();
+        }
+        catch {
+            return {
+                status: "HUMAN_REQUIRED",
+                reason: "PERMISSION_CLASSIFICATION_FAILED",
+            };
+        }
+        const afterClassification = denied();
+        if (afterClassification)
+            return afterClassification;
+        if (decision.decision !== "DEFER")
+            break;
+        if (!(await input.port.revalidate()))
+            return { status: "STALE" };
+        if (attempt === maxClassifications - 1)
+            return {
+                status: "HUMAN_REQUIRED",
+                reason: "PERMISSION_CONTEXT_DEFER_TIMEOUT",
+            };
+        await input.port.waitBeforeReclassify?.();
+    }
+    if (!decision)
+        return {
+            status: "HUMAN_REQUIRED",
+            reason: "PERMISSION_CLASSIFICATION_FAILED",
+        };
+    if (decision.decision !== "AUTO_ALLOW")
+        return { status: "HUMAN_REQUIRED", reason: decision.reason };
+    if (!input.facts.actions.includes("allowAlways"))
+        return {
+            status: "HUMAN_REQUIRED",
+            reason: "AUTO_ALLOW_ACTION_UNAVAILABLE",
+        };
+    if (input.autoAlreadyAttempted)
+        return {
+            status: "HUMAN_REQUIRED",
+            reason: "AUTO_ALLOW_REALITY_UNCONFIRMED",
+        };
+    if (!(await input.port.revalidate()))
+        return { status: "STALE" };
+    const beforeAction = denied();
+    if (beforeAction)
+        return beforeAction;
+    try {
+        await input.port.act("allowAlways");
+    }
+    catch {
+        return { status: "HUMAN_REQUIRED", reason: "AUTO_ALLOW_FAILED" };
+    }
+    return (await input.port.released())
+        ? { status: "RELEASED", action: "allowAlways" }
+        : { status: "HUMAN_REQUIRED", reason: "AUTO_ALLOW_REALITY_UNCONFIRMED" };
+}
+export async function resolveHumanCarrierPermission(input) {
+    if (!(await input.revalidate()))
+        throw new Error("STALE_PERMISSION");
+    await input.act(input.action);
+    if (!(await input.released()))
+        throw new Error("PERMISSION_ACTION_REALITY_UNCONFIRMED");
+    return "RELEASED";
+}

package/dist/src/carrier-permission.d.ts

@@ -0,0 +1,16 @@
+export type PermissionSemanticAction = "allowAlways" | "allowOnce" | "deny";
+export type ActionPermissionCandidate = {
+    text: string;
+    buttonLabels: readonly string[];
+};
+export type ActionPermissionFacts = {
+    kind: "ACTION_PERMISSION";
+    targetHost: string | null;
+    operationId: string;
+    taskId: string | null;
+    actions: PermissionSemanticAction[];
+    fingerprint: string;
+};
+export declare function permissionSemanticAction(label: string): PermissionSemanticAction | null;
+export declare function detectActionPermission(candidates: readonly ActionPermissionCandidate[]): ActionPermissionFacts | null;
+export declare function permissionActionAllowed(facts: ActionPermissionFacts, expectedFingerprint: string, action: string): action is PermissionSemanticAction;

package/dist/src/carrier-permission.js

@@ -0,0 +1,65 @@
+const actionLabels = [
+    [/^(始终允许|always allow)$/i, "allowAlways"],
+    [/^(允许一次|allow once)$/i, "allowOnce"],
+    [/^(拒绝|deny)$/i, "deny"],
+];
+export function permissionSemanticAction(label) {
+    const normalized = label.trim();
+    for (const [pattern, action] of actionLabels)
+        if (pattern.test(normalized))
+            return action;
+    return null;
+}
+function normalizedText(value) {
+    return value.replace(/\s+/g, " ").trim().slice(0, 4_096);
+}
+function hashFingerprint(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function targetHost(text) {
+    const url = text.match(/https?:\/\/([a-z0-9.-]+)(?=[/:\s"'”]|$)/i)?.[1];
+    if (url)
+        return url.toLowerCase();
+    const hosts = text.match(/[a-z0-9][a-z0-9-]*(?:\.[a-z0-9-]+){2,}/gi) ?? [];
+    return (hosts.find((value) => value.includes("devtunnels.ms"))?.toLowerCase() ??
+        hosts[0]?.toLowerCase() ??
+        null);
+}
+function operationId(text) {
+    return (text.match(/(?:工具调用|tool call)\s*[：:]\s*[^\s.]+(?:\.[^\s.]+)*\.([A-Za-z][A-Za-z0-9_]*)/i)?.[1] ?? null);
+}
+function taskId(text) {
+    return text.match(/\btask-[A-Za-z0-9-]+\b/)?.[0] ?? null;
+}
+export function detectActionPermission(candidates) {
+    for (const candidate of candidates) {
+        const actions = candidate.buttonLabels
+            .map(permissionSemanticAction)
+            .filter((value) => value !== null);
+        if (!actions.includes("deny") ||
+            (!actions.includes("allowAlways") && !actions.includes("allowOnce")))
+            continue;
+        const text = normalizedText(candidate.text);
+        const operation = operationId(text);
+        if (!operation)
+            continue;
+        return {
+            kind: "ACTION_PERMISSION",
+            targetHost: targetHost(text),
+            operationId: operation,
+            taskId: taskId(text),
+            actions,
+            fingerprint: `permission:v1:${hashFingerprint(`${text}|${actions.join(",")}`)}`,
+        };
+    }
+    return null;
+}
+export function permissionActionAllowed(facts, expectedFingerprint, action) {
+    return (facts.fingerprint === expectedFingerprint &&
+        facts.actions.includes(action));
+}

package/dist/src/chatgpt-runtime-adapter.d.ts

@@ -0,0 +1,16 @@
+import { type ActionPermissionFacts, type PermissionSemanticAction } from "./carrier-permission.ts";
+export type ChatGptPageReality = {
+    pageState: "IDLE" | "BUSY" | "BLOCKED" | "UNKNOWN";
+    activityKind: "GENERATING" | "ACTION_PERMISSION" | "ACTION_RUNNING" | "WAITING_HUMAN" | null;
+    blockerFacts?: ActionPermissionFacts;
+};
+export declare function classifyChatGptPageSignals(input: {
+    permission: ActionPermissionFacts | null;
+    hasDialog: boolean;
+    isGenerating: boolean;
+    hasComposer: boolean;
+}): ChatGptPageReality;
+export declare function observeChatGptPage(document: Document): ChatGptPageReality;
+export declare function performChatGptPermissionAction(document: Document, expectedFingerprint: string, action: PermissionSemanticAction): ActionPermissionFacts;
+export declare function submitChatGptComposer(document: Document, value: string): Promise<void>;
+export declare function writeChatGptInput(document: Document, selector: string, value: string): void;