@tomflow/proflow-execution-browser-extension 0.1.0

package/dist/extension/content.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/extension/content.js

@@ -0,0 +1,90 @@
+const contentInstanceId = `content:${crypto.randomUUID()}`;
+function pageState() {
+    if (document.querySelector('[role="dialog"]'))
+        return { pageState: "BLOCKED", activityKind: "ACTION_PERMISSION" };
+    if (document.querySelector('[data-testid="stop-button"], button[aria-label*="Stop"]'))
+        return { pageState: "BUSY", activityKind: "GENERATING" };
+    if (document.querySelector('#prompt-textarea, textarea, [contenteditable="true"]'))
+        return { pageState: "IDLE", activityKind: null };
+    return { pageState: "UNKNOWN", activityKind: null };
+}
+function observation() {
+    return {
+        url: location.href,
+        contentInstanceId,
+        ...pageState(),
+        observedAt: new Date().toISOString(),
+    };
+}
+function safeElement(selector) {
+    if (!selector || selector.length > 512)
+        throw new Error("SELECTOR_INVALID");
+    const element = document.querySelector(selector);
+    if (!(element instanceof HTMLElement))
+        throw new Error("ELEMENT_NOT_FOUND");
+    return element;
+}
+function hasFingerprint(fingerprint) {
+    return Boolean(fingerprint && document.body.innerText.includes(fingerprint));
+}
+chrome.runtime.onMessage.addListener((command, _sender, sendResponse) => {
+    void (async () => {
+        if (command.type !== "PROFLOW_PAGE_COMMAND" ||
+            command.contentInstanceId !== contentInstanceId ||
+            command.expectedUrl !== location.href)
+            throw new Error("STALE_CONTENT_SESSION");
+        if (command.operation === "observe")
+            return observation();
+        if (command.operation === "verify")
+            return {
+                ...observation(),
+                verified: hasFingerprint(command.fingerprint),
+            };
+        if (pageState().pageState === "BLOCKED")
+            throw new Error("PAGE_PERMISSION_REQUIRES_HUMAN");
+        if (command.operation === "click") {
+            safeElement(command.selector).click();
+            return observation();
+        }
+        const input = safeElement(command.selector ?? "#prompt-textarea");
+        if (command.value === undefined || command.value.length > 4_096)
+            throw new Error("INPUT_BUDGET_EXCEEDED");
+        input.focus();
+        if (input instanceof HTMLTextAreaElement ||
+            input instanceof HTMLInputElement)
+            input.value = command.value;
+        else
+            input.textContent = command.value;
+        input.dispatchEvent(new InputEvent("input", {
+            bubbles: true,
+            inputType: "insertText",
+            data: command.value,
+        }));
+        if (command.operation === "submit")
+            safeElement('button[data-testid="send-button"], button[aria-label*="Send"]').click();
+        return observation();
+    })().then((value) => sendResponse({ ok: true, value }), (error) => sendResponse({
+        ok: false,
+        error: error instanceof Error ? error.message : "PAGE_COMMAND_FAILED",
+    }));
+    return true;
+});
+const publish = () => chrome.runtime.sendMessage({
+    type: "PROFLOW_CONTENT_OBSERVATION",
+    observation: observation(),
+});
+void publish();
+let publishTimer;
+const observer = new MutationObserver(() => {
+    if (publishTimer !== undefined)
+        clearTimeout(publishTimer);
+    publishTimer = setTimeout(() => {
+        publishTimer = undefined;
+        void publish();
+    }, 100);
+});
+observer.observe(document.documentElement, {
+    subtree: true,
+    childList: true,
+    attributes: true,
+});

package/dist/extension/options.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/extension/options.js

@@ -0,0 +1,68 @@
+export {};
+function parseEndpoint(raw) {
+    const parsed = new URL(raw);
+    if (parsed.protocol !== "http:" ||
+        parsed.hostname !== "127.0.0.1" ||
+        parsed.pathname !== "/" ||
+        parsed.search !== "" ||
+        parsed.hash !== "")
+        throw new Error("Endpoint must be a loopback HTTP origin");
+    return raw.replace(/\/$/, "");
+}
+function wireConfigForm(config) {
+    const endpoint = document.querySelector(`#${config.endpointId}`);
+    const token = document.querySelector(`#${config.tokenId}`);
+    const status = document.querySelector(`#${config.statusId}`);
+    const form = document.querySelector(`#${config.formId}`);
+    if (!endpoint || !token || !status || !form)
+        throw new Error("OPTIONS_DOM_INVALID");
+    void chrome.storage.local.get(config.storageKey).then((stored) => {
+        const value = stored[config.storageKey];
+        if (typeof value !== "object" || value === null)
+            return;
+        const record = value;
+        if (typeof record.endpoint === "string")
+            endpoint.value = record.endpoint;
+    });
+    form.addEventListener("submit", (event) => {
+        event.preventDefault();
+        void (async () => {
+            const normalizedEndpoint = parseEndpoint(endpoint.value);
+            if (token.value.length < 32)
+                throw new Error("Token is too short");
+            await chrome.storage.local.set({
+                [config.storageKey]: {
+                    endpoint: normalizedEndpoint,
+                    token: token.value,
+                },
+            });
+            token.value = "";
+            status.textContent = "Saved.";
+        })().catch((error) => {
+            status.textContent =
+                error instanceof Error ? error.message : "Save failed";
+        });
+    });
+}
+document.querySelector("#extension-id")?.append(chrome.runtime.id);
+wireConfigForm({
+    storageKey: "proflowRuntimeBridge",
+    formId: "bridge-form",
+    endpointId: "bridge-endpoint",
+    tokenId: "bridge-token",
+    statusId: "bridge-status",
+});
+wireConfigForm({
+    storageKey: "proflowTaskApplication",
+    formId: "task-application-form",
+    endpointId: "task-application-endpoint",
+    tokenId: "task-application-token",
+    statusId: "task-application-status",
+});
+wireConfigForm({
+    storageKey: "proflowApprovalApplication",
+    formId: "approval-application-form",
+    endpointId: "approval-application-endpoint",
+    tokenId: "approval-application-token",
+    statusId: "approval-application-status",
+});

package/dist/extension/side-panel.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/extension/side-panel.js

@@ -0,0 +1,262 @@
+export {};
+function element(selector) {
+    const value = document.querySelector(selector);
+    if (!value)
+        throw new Error(`SIDE_PANEL_TARGET_MISSING:${selector}`);
+    return value;
+}
+const connection = element("#connection");
+const browserStatus = element("#browser-status");
+const tasksTarget = element("#tasks");
+const selectedTarget = element("#selected-task");
+const nodesTarget = element("#nodes");
+const errorTarget = element("#error");
+const resultTarget = element("#result");
+const startButton = element("#start-task");
+const ensureWorkersButton = element("#ensure-workers");
+const newTaskForm = element("#new-task-form");
+const approvalsTarget = element("#approvals");
+const systemAssessmentTarget = element("#system-assessment");
+let selected = null;
+function requestId(prefix) {
+    return `${prefix}:${crypto.randomUUID()}`;
+}
+function record(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error("TASK_APPLICATION_RESPONSE_INVALID");
+    return value;
+}
+async function taskApplication(operation, input) {
+    const raw = await chrome.runtime.sendMessage({
+        type: "PROFLOW_TASK_APPLICATION",
+        operation,
+        input,
+    });
+    const response = record(raw);
+    if (response.ok !== true)
+        throw new Error(typeof response.error === "string"
+            ? response.error
+            : "TASK_APPLICATION_FAILED");
+    return response.value;
+}
+async function approvalApplication(operation, input) {
+    const raw = await chrome.runtime.sendMessage({
+        type: "PROFLOW_APPROVAL_APPLICATION",
+        operation,
+        input,
+    });
+    const response = record(raw);
+    if (response.ok !== true)
+        throw new Error(typeof response.error === "string"
+            ? response.error
+            : "APPROVAL_APPLICATION_FAILED");
+    return response.value;
+}
+async function refreshApprovals() {
+    const value = record(await approvalApplication("approval.list", { status: "PENDING" }));
+    const approvals = Array.isArray(value.approvals)
+        ? value.approvals
+        : [];
+    approvalsTarget.replaceChildren();
+    for (const approval of approvals) {
+        const row = document.createElement("div");
+        row.className = "task";
+        const label = document.createElement("span");
+        label.textContent = `${approval.capability} · ${approval.executionRef} · expires ${approval.expiresAt}`;
+        row.append(label);
+        const allow = document.createElement("button");
+        allow.type = "button";
+        allow.textContent = "Allow";
+        allow.addEventListener("click", () => void run(async () => {
+            await approvalApplication("approval.allow", {
+                approvalRef: approval.approvalRef,
+                expectedVersion: approval.version,
+            });
+            await refreshApprovals();
+        }));
+        const deny = document.createElement("button");
+        deny.type = "button";
+        deny.textContent = "Deny";
+        deny.addEventListener("click", () => void run(async () => {
+            await approvalApplication("approval.deny", {
+                approvalRef: approval.approvalRef,
+                expectedVersion: approval.version,
+                reason: "Denied from Extension Side Panel",
+            });
+            await refreshApprovals();
+        }));
+        row.append(allow, deny);
+        approvalsTarget.append(row);
+    }
+}
+function setBusy(button, busy) {
+    button.disabled = busy;
+}
+async function loadTask(taskId) {
+    selected = (await taskApplication("task.get", { taskId }));
+    selectedTarget.textContent = `${selected.taskId} · ${selected.status} · v${selected.version}`;
+    startButton.disabled = selected.status !== "READY";
+    ensureWorkersButton.disabled =
+        selected.status === "SUCCEEDED" || selected.status === "TERMINATED";
+    nodesTarget.replaceChildren();
+    for (const node of selected.nodes) {
+        const row = document.createElement("div");
+        row.className = "task";
+        const label = document.createElement("span");
+        label.textContent = `${node.title} · ${node.status} · run ${node.runNo}`;
+        row.append(label);
+        if (["SUCCEEDED", "FAILED", "WAITING"].includes(node.status)) {
+            const reopen = document.createElement("button");
+            reopen.type = "button";
+            reopen.textContent = "Reopen";
+            reopen.addEventListener("click", () => {
+                void run(async () => {
+                    if (!selected)
+                        return;
+                    await taskApplication("node.reopen", {
+                        taskId: selected.taskId,
+                        nodeId: node.nodeId,
+                        reason: "Human reopen from Extension Side Panel",
+                        expectedTaskVersion: selected.version,
+                        idempotencyKey: requestId("extension-reopen"),
+                    });
+                    await loadTask(selected.taskId);
+                    await refreshTasks();
+                });
+            });
+            row.append(reopen);
+        }
+        nodesTarget.append(row);
+    }
+}
+async function refreshTasks() {
+    const value = record(await taskApplication("task.list", {}));
+    const tasks = Array.isArray(value.tasks)
+        ? value.tasks
+        : [];
+    tasksTarget.replaceChildren();
+    for (const task of tasks) {
+        const row = document.createElement("div");
+        row.className = "task";
+        const open = document.createElement("button");
+        open.type = "button";
+        open.textContent = `${task.title} · ${task.status}`;
+        open.addEventListener("click", () => void run(() => loadTask(task.taskId)));
+        row.append(open);
+        if (task.blockedReason) {
+            const detail = document.createElement("div");
+            detail.className = "meta";
+            detail.textContent = task.blockedReason;
+            row.append(detail);
+        }
+        tasksTarget.append(row);
+    }
+}
+async function refreshBrowserStatus() {
+    const snapshot = record(await chrome.runtime.sendMessage({ type: "PROFLOW_SIDE_PANEL_SNAPSHOT" }));
+    connection.textContent =
+        snapshot.taskApplicationConfigured === true &&
+            snapshot.approvalApplicationConfigured === true
+            ? "Task + Approval applications connected"
+            : "Local application credential missing — open Extension Options";
+    browserStatus.textContent = JSON.stringify(snapshot, null, 2);
+    const observer = typeof snapshot.systemObserver === "object" &&
+        snapshot.systemObserver !== null &&
+        !Array.isArray(snapshot.systemObserver)
+        ? snapshot.systemObserver
+        : null;
+    if (observer === null) {
+        systemAssessmentTarget.textContent = "No assessment yet.";
+    }
+    else {
+        const unresolved = Array.isArray(observer.unresolved)
+            ? observer.unresolved.filter((item) => typeof item === "string")
+            : [];
+        const carry = Array.isArray(observer.carryForward)
+            ? observer.carryForward
+            : [];
+        systemAssessmentTarget.textContent = [
+            `assessmentRef: ${String(observer.assessmentRef ?? "?")}`,
+            `needsHumanAttention: ${observer.needsHumanAttention === true}`,
+            `unresolved: ${unresolved.join(" | ")}`,
+            `carryForward: ${carry.length}`,
+        ].join("\n");
+    }
+    if (snapshot.taskApplicationConfigured === true)
+        await refreshTasks();
+    if (snapshot.approvalApplicationConfigured === true)
+        await refreshApprovals();
+}
+async function run(action) {
+    errorTarget.textContent = "";
+    try {
+        await action();
+    }
+    catch (error) {
+        errorTarget.textContent =
+            error instanceof Error ? error.message : "Operation failed";
+    }
+}
+newTaskForm.addEventListener("submit", (event) => {
+    event.preventDefault();
+    void run(async () => {
+        const title = element("#task-title").value.trim();
+        const objective = element("#task-objective").value.trim();
+        const nodes = JSON.parse(element("#task-plan").value);
+        if (!Array.isArray(nodes) || nodes.length === 0)
+            throw new Error("Task plan must be a non-empty JSON array");
+        const value = await taskApplication("task.create", {
+            title,
+            objective,
+            plan: { nodes },
+            initialDocuments: [],
+            idempotencyKey: requestId("extension-new-task"),
+        });
+        const created = record(value);
+        resultTarget.textContent = `Created ${String(created.taskId ?? "Task")}.`;
+        if (typeof created.taskId === "string")
+            await loadTask(created.taskId);
+        await refreshTasks();
+    });
+});
+element("#refresh-tasks").addEventListener("click", () => void run(refreshTasks));
+element("#refresh-approvals").addEventListener("click", () => void run(refreshApprovals));
+startButton.addEventListener("click", () => {
+    void run(async () => {
+        if (!selected)
+            return;
+        setBusy(startButton, true);
+        try {
+            await taskApplication("task.start", {
+                taskId: selected.taskId,
+                expectedTaskVersion: selected.version,
+                idempotencyKey: requestId("extension-start-task"),
+            });
+            await loadTask(selected.taskId);
+            await refreshTasks();
+        }
+        finally {
+            startButton.disabled = selected?.status !== "READY";
+        }
+    });
+});
+ensureWorkersButton.addEventListener("click", () => {
+    void run(async () => {
+        if (!selected)
+            return;
+        setBusy(ensureWorkersButton, true);
+        try {
+            await taskApplication("task.ensureWorkers", { taskId: selected.taskId });
+            await loadTask(selected.taskId);
+            await refreshTasks();
+        }
+        finally {
+            ensureWorkersButton.disabled =
+                selected?.status === "SUCCEEDED" || selected?.status === "TERMINATED";
+        }
+    });
+});
+void run(refreshBrowserStatus);
+setInterval(() => {
+    void run(refreshBrowserStatus);
+}, 5_000);

package/dist/src/bridge.d.ts

@@ -0,0 +1,26 @@
+import type { BrowserRealityPort } from "./index.ts";
+export interface BrowserRealityBridgeOptions {
+    token: string;
+    extensionId: string;
+    host?: "127.0.0.1";
+    port?: number;
+    heartbeatFreshnessMs?: number;
+    commandTimeoutMs?: number;
+    now?: () => Date;
+    idFactory?: () => string;
+}
+export declare class BrowserRealityBridgeError extends Error {
+    readonly code: "BRIDGE_AUTH_INVALID" | "BRIDGE_INPUT_INVALID" | "BRIDGE_OFFLINE" | "BRIDGE_COMMAND_TIMEOUT" | "BRIDGE_COMMAND_FAILED";
+    constructor(code: BrowserRealityBridgeError["code"], message: string);
+}
+export declare function createBrowserRealityBridgeServer(options: BrowserRealityBridgeOptions): Promise<Readonly<{
+    endpoint: string;
+    browser: BrowserRealityPort;
+    status(): {
+        online: boolean;
+        extensionInstanceId: string | null;
+        queuedCommands: number;
+        pendingCommands: number;
+    };
+    close(): Promise<void>;
+}>>;