@ycheung5/pi-computer-use 0.0.0-stage → 0.1.1

package/dist/browser-indicators.d.ts

@@ -0,0 +1,23 @@
+export declare function updateBrowserIndicator(input: {
+    mode: "mark" | "hide" | "show" | "clear";
+    point?: {
+        x: number;
+        y: number;
+    };
+}): {
+    active: boolean;
+    tabBadge: boolean;
+    clickMarker: boolean;
+    hidden?: undefined;
+    ariaHidden?: undefined;
+    pointerEvents?: undefined;
+    shadowClosed?: undefined;
+} | {
+    active: boolean;
+    tabBadge: boolean;
+    clickMarker: boolean;
+    hidden: boolean;
+    ariaHidden: boolean;
+    pointerEvents: string;
+    shadowClosed: boolean;
+};

package/dist/browser-indicators.js

@@ -0,0 +1,69 @@
+// Runs only in this extension's isolated browser realm. Keep the function self-contained.
+export function updateBrowserIndicator(input) {
+    const world = globalThis;
+    let cue = world.__piComputerUseCue;
+    if (input.mode === "clear") {
+        cue?.host.remove();
+        cue?.icon.remove();
+        delete world.__piComputerUseCue;
+        return { active: false, tabBadge: false, clickMarker: false };
+    }
+    if (!cue?.host.isConnected &&
+        input.mode === "mark" &&
+        document.documentElement) {
+        cue?.icon.remove();
+        const host = document.createElement("div");
+        host.setAttribute("aria-hidden", "true");
+        host.setAttribute("role", "presentation");
+        host.style.cssText =
+            "all:initial!important;position:fixed!important;left:0!important;top:0!important;width:0!important;height:0!important;overflow:visible!important;pointer-events:none!important;z-index:2147483647!important";
+        const root = host.attachShadow({ mode: "closed" });
+        const marker = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+        marker.setAttribute("viewBox", "0 0 28 34");
+        marker.setAttribute("aria-hidden", "true");
+        marker.style.cssText =
+            "position:fixed;width:28px;height:34px;pointer-events:none;display:none;filter:drop-shadow(0 0 3px #2d9cff)";
+        const arrow = document.createElementNS("http://www.w3.org/2000/svg", "path");
+        arrow.setAttribute("d", "M2 2 L2 25 L8 20 L13 31 L18 28 L13 18 L23 18 Z");
+        arrow.setAttribute("fill", "#2d9cff");
+        arrow.setAttribute("stroke", "white");
+        arrow.setAttribute("stroke-width", "1.5");
+        marker.append(arrow);
+        root.append(marker);
+        document.documentElement.append(host);
+        const icon = document.createElement("link");
+        icon.rel = "icon";
+        icon.type = "image/svg+xml";
+        icon.href =
+            "data:image/svg+xml," +
+                encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" rx="6" fill="#247fd9"/><text x="16" y="23" font-family="sans-serif" font-size="23" text-anchor="middle" fill="white">π</text></svg>');
+        (document.head ?? document.documentElement).append(icon);
+        cue = { host, marker, icon };
+        world.__piComputerUseCue = cue;
+    }
+    if (!cue)
+        return { active: false, tabBadge: false, clickMarker: false };
+    if (input.mode === "hide")
+        cue.host.style.setProperty("display", "none", "important");
+    else if (input.mode === "show")
+        cue.host.style.removeProperty("display");
+    else {
+        cue.host.style.removeProperty("display");
+        if (input.point &&
+            Number.isFinite(input.point.x) &&
+            Number.isFinite(input.point.y)) {
+            cue.marker.style.left = `${input.point.x}px`;
+            cue.marker.style.top = `${input.point.y}px`;
+            cue.marker.style.display = "block";
+        }
+    }
+    return {
+        active: cue.host.isConnected,
+        tabBadge: cue.icon.isConnected,
+        clickMarker: cue.marker.style.display !== "none",
+        hidden: cue.host.style.display === "none",
+        ariaHidden: cue.host.getAttribute("aria-hidden") === "true",
+        pointerEvents: cue.host.style.pointerEvents,
+        shadowClosed: cue.host.shadowRoot === null,
+    };
+}

package/dist/browser-profiles.d.ts

@@ -0,0 +1,10 @@
+export interface BrowserProfile {
+    path: string;
+    kept: boolean;
+    lock: string;
+    token: string;
+}
+export declare function acquireBrowserProfile(app: string, executable: string, kept: boolean): Promise<BrowserProfile>;
+export declare function recordProfileBrowser(profile: BrowserProfile, pid: number | undefined): Promise<void>;
+export declare function releaseBrowserProfile(profile: BrowserProfile, browserPid?: number): Promise<void>;
+export declare function browserIdleMs(): number;

package/dist/browser-profiles.js

@@ -0,0 +1,174 @@
+import { createHash, randomUUID } from "node:crypto";
+import { access, mkdir, mkdtemp, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+};
+const busy = (detail) => {
+    throw new Error(`BROWSER_PROFILE_BUSY: ${detail}; close the owning automation browser before retrying`);
+};
+async function ownerAt(lock) {
+    try {
+        const value = JSON.parse(await readFile(join(lock, "owner.json"), "utf8"));
+        if (value &&
+            typeof value === "object" &&
+            "token" in value &&
+            typeof value.token === "string" &&
+            "workerPid" in value &&
+            Number.isSafeInteger(value.workerPid) &&
+            Number(value.workerPid) > 0 &&
+            "phase" in value &&
+            ["launching", "running"].includes(String(value.phase))) {
+            const owner = value;
+            if (owner.browserPid !== undefined &&
+                (!Number.isSafeInteger(owner.browserPid) || owner.browserPid <= 0))
+                return undefined;
+            return owner;
+        }
+    }
+    catch { }
+    return undefined;
+}
+function stale(owner) {
+    if (!owner || alive(owner.workerPid))
+        return false;
+    if (owner.browserPid === undefined)
+        return false; // A crash during launch has an unknown browser owner.
+    return !alive(owner.browserPid);
+}
+async function claim(lock) {
+    const token = randomUUID();
+    try {
+        await access(`${lock}.recover`);
+        busy("profile recovery is active or incomplete");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    try {
+        await mkdir(lock);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        const owner = await ownerAt(lock);
+        if (!stale(owner))
+            busy(owner?.browserPid && alive(owner.browserPid)
+                ? "profile browser is still alive (possibly orphaned)"
+                : "live, unknown or incomplete profile ownership");
+        const recovery = `${lock}.recover`;
+        try {
+            await mkdir(recovery);
+        }
+        catch {
+            busy("another profile recovery is active or incomplete");
+        }
+        try {
+            const confirmed = await ownerAt(lock);
+            if (!stale(confirmed) || confirmed?.token !== owner?.token)
+                busy("profile ownership changed during recovery");
+            const abandoned = `${lock}.abandoned-${token}`;
+            await rename(lock, abandoned);
+            try {
+                await mkdir(lock);
+            }
+            finally {
+                await rm(abandoned, { recursive: true, force: true });
+            }
+        }
+        finally {
+            await rm(recovery, { recursive: true, force: true });
+        }
+    }
+    const owner = { token, workerPid: process.pid, phase: "launching" };
+    await writeFile(join(lock, "owner.json"), JSON.stringify(owner), {
+        flag: "wx",
+    });
+    return token;
+}
+export async function acquireBrowserProfile(app, executable, kept) {
+    const local = process.env.LOCALAPPDATA;
+    if (!local)
+        throw new Error("BROWSER_SETUP_FAILED: Windows LOCALAPPDATA is required");
+    const root = resolve(process.env.PI_CU_BROWSER_PROFILE_ROOT ??
+        join(local, "pi-computer-use", "browser"));
+    await mkdir(root, { recursive: true });
+    // Only sweep our recorded temporary leases after both recorded processes
+    // are gone; unknown launches and live orphans remain untouched.
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        if (!entry.isDirectory() ||
+            !/^temporary-[A-Za-z0-9]+\.lock$/.test(entry.name))
+            continue;
+        const lock = join(root, entry.name);
+        if (!stale(await ownerAt(lock)))
+            continue;
+        try {
+            const token = await claim(lock);
+            await releaseBrowserProfile({
+                path: lock.slice(0, -5),
+                kept: false,
+                lock,
+                token,
+            });
+        }
+        catch (error) {
+            if (!(error instanceof Error &&
+                error.message.startsWith("BROWSER_PROFILE_BUSY")))
+                throw error;
+        }
+    }
+    const identity = createHash("sha256")
+        .update(`${app}\0${resolve(executable).toLowerCase()}`)
+        .digest("hex")
+        .slice(0, 24);
+    const path = kept
+        ? join(root, `kept-${app}-${identity}`)
+        : await mkdtemp(join(root, "temporary-"));
+    const lock = `${path}.lock`;
+    try {
+        const token = await claim(lock);
+        await mkdir(path, { recursive: true });
+        return { path, kept, lock, token };
+    }
+    catch (error) {
+        if (!kept)
+            await rm(path, { recursive: true, force: true });
+        throw error;
+    }
+}
+export async function recordProfileBrowser(profile, pid) {
+    if (!pid)
+        busy("launched browser did not expose its owning process");
+    const owner = await ownerAt(profile.lock);
+    if (owner?.token !== profile.token)
+        busy("profile ownership changed before launch completed");
+    await writeFile(join(profile.lock, "owner.json"), JSON.stringify({ ...owner, browserPid: pid, phase: "running" }));
+}
+export async function releaseBrowserProfile(profile, browserPid) {
+    const owner = await ownerAt(profile.lock);
+    if (owner?.token !== profile.token)
+        busy("profile ownership changed during cleanup");
+    if (browserPid && alive(browserPid))
+        busy("browser is still alive; profile retained and blocked");
+    if (!profile.kept)
+        await rm(profile.path, {
+            recursive: true,
+            force: true,
+            maxRetries: 10,
+            retryDelay: 100,
+        });
+    await rm(profile.lock, { recursive: true, force: true });
+}
+export function browserIdleMs() {
+    const value = Number(process.env.PI_CU_BROWSER_IDLE_MS ?? 600000);
+    if (!Number.isSafeInteger(value) || value < 1000 || value > 86400000)
+        throw new Error("BROWSER_SETTINGS: PI_CU_BROWSER_IDLE_MS must be 1000–86400000 milliseconds");
+    return value;
+}

package/dist/browser.d.ts

@@ -0,0 +1,11 @@
+import type { WorkerResult } from "./protocol.js";
+export declare function configureBrowser(settings: {
+    browserApp: string;
+    browserVisible: boolean;
+    browserSignIn: boolean;
+}): Promise<void>;
+export declare function isBrowserRequest(args: Record<string, unknown>): boolean;
+export declare function clearBrowserIndicators(): Promise<void>;
+export declare function browserListing(): Promise<Record<string, unknown>>;
+export declare function browse(action: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<WorkerResult>;
+export declare function disposeBrowser(): Promise<void>;