pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/temp-root.js

@@ -1,207 +0,0 @@
-import { randomInt } from "node:crypto";
-import { existsSync, readdirSync, rmSync } from "node:fs";
-import { chmod, mkdtemp, readdir, rm, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { enqueueTempMutation } from "./temp-mutation-queue.js";
-import { TEMP_ROOT_MARKER_FILE_NAME, getCurrentProcessUid, readTempRootOwnershipMarker, getProtectedTempChildName, getPersistedProtectedChildPaths, persistProtectedTempChildren, getExistingProtectedChildren, removeTempRootChildrenExcept, getMarkerOwnerLiveness, refreshSecureTempRootLease, writeSecureTempRootOwnershipMarker, } from "./temp-root-ownership.js";
-export { refreshSecureTempRootLease, writeSecureTempRootOwnershipMarker, } from "./temp-root-ownership.js";
-const TEMP_ROOT_PREFIX = "pi-agent-browser-";
-const STALE_TEMP_ROOT_MAX_AGE_MS = 24 * 60 * 60 * 1_000;
-const STALE_TEMP_ROOT_BATCH_SIZE = 8;
-let lastTempGcName;
-let sessionTempRootPromise;
-let exitCleanupRegistered = false;
-const ownedTempRoots = new Set();
-const protectedTempChildren = new Set();
-function markerMatchesUid(marker, uid) {
-    return uid === undefined || marker.ownerUid === undefined || marker.ownerUid === uid;
-}
-async function pruneTempRoot(path, currentUid, cutoffTime) {
-    const marker = await readTempRootOwnershipMarker(path);
-    if (!marker || !markerMatchesUid(marker, currentUid)) {
-        return;
-    }
-    if ((marker.leaseUpdatedAtMs ?? marker.createdAtMs) >= cutoffTime) {
-        return;
-    }
-    // Preserve ambiguous owner liveness; never delete another live process's files.
-    if ((await getMarkerOwnerLiveness(marker)) !== "dead") {
-        return;
-    }
-    const stats = await stat(path).catch(() => undefined);
-    if (stats?.isDirectory() !== true) {
-        return;
-    }
-    const protectedChildren = await getExistingProtectedChildren(path, getPersistedProtectedChildPaths(path, marker));
-    if (protectedChildren.size > 0) {
-        await removeTempRootChildrenExcept(path, protectedChildren);
-        return;
-    }
-    await rm(path, { force: true, recursive: true }).catch(() => {
-        /* Stale-root cleanup is best-effort. */
-    });
-}
-async function pruneStaleTempRoots(currentTempRoot) {
-    const entries = await readdir(tmpdir(), { withFileTypes: true }).catch(() => []);
-    const cutoffTime = Date.now() - STALE_TEMP_ROOT_MAX_AGE_MS;
-    const currentUid = getCurrentProcessUid();
-    // ponytail: list/sort all names; stream directories if enumeration becomes the bottleneck.
-    const candidates = entries
-        .filter((entry) => entry.isDirectory() && entry.name.startsWith(TEMP_ROOT_PREFIX))
-        .map((entry) => entry.name)
-        .sort();
-    if (candidates.length === 0) {
-        return;
-    }
-    const previousName = lastTempGcName;
-    const start = previousName === undefined
-        ? randomInt(candidates.length)
-        : Math.max(0, candidates.findIndex((name) => name > previousName));
-    const batch = Array.from({ length: Math.min(STALE_TEMP_ROOT_BATCH_SIZE, candidates.length) }, (_, offset) => candidates[(start + offset) % candidates.length]);
-    lastTempGcName = batch.at(-1);
-    await Promise.all(batch.map(async (name) => {
-        const path = join(tmpdir(), name);
-        if (path !== currentTempRoot) {
-            await pruneTempRoot(path, currentUid, cutoffTime);
-        }
-    }));
-}
-function getProtectedChildrenForRoot(tempRoot) {
-    const normalizedTempRoot = resolve(tempRoot);
-    return new Set([...protectedTempChildren].filter((path) => dirname(path) === normalizedTempRoot && existsSync(path)));
-}
-function removeTempRootChildrenExceptSync(tempRoot, protectedChildren) {
-    for (const entry of readdirSync(tempRoot, { withFileTypes: true })) {
-        if (entry.name === TEMP_ROOT_MARKER_FILE_NAME) {
-            continue;
-        }
-        const entryPath = join(tempRoot, entry.name);
-        if (protectedChildren.has(resolve(entryPath))) {
-            continue;
-        }
-        rmSync(entryPath, { force: true, recursive: true });
-    }
-}
-function registerExitCleanup() {
-    if (exitCleanupRegistered) {
-        return;
-    }
-    exitCleanupRegistered = true;
-    process.once("exit", () => {
-        for (const tempRoot of ownedTempRoots) {
-            try {
-                const protectedChildren = getProtectedChildrenForRoot(tempRoot);
-                if (protectedChildren.size === 0) {
-                    rmSync(tempRoot, { force: true, recursive: true });
-                }
-                else {
-                    removeTempRootChildrenExceptSync(tempRoot, protectedChildren);
-                }
-            }
-            catch {
-                /* Best-effort process-exit cleanup. */
-            }
-        }
-    });
-}
-export async function preserveSecureTempDirectory(path) {
-    await enqueueTempMutation(async () => {
-        const childPath = resolve(path);
-        const tempRoot = dirname(childPath);
-        if (!ownedTempRoots.has(tempRoot) ||
-            getProtectedTempChildName(tempRoot, childPath) === undefined ||
-            !(await stat(childPath)).isDirectory()) {
-            throw new Error(`Cannot preserve ${path}; expected an existing child directory of a currently owned temp root.`);
-        }
-        protectedTempChildren.add(childPath);
-        await persistProtectedTempChildren(tempRoot, new Set([childPath]));
-        if (!getPersistedProtectedChildPaths(tempRoot, await readTempRootOwnershipMarker(tempRoot)).has(childPath)) {
-            throw new Error(`Could not persist temp directory preservation for ${path}.`);
-        }
-    });
-}
-function rememberPreservedPaths(tempRoot, paths) {
-    for (const path of paths) {
-        const childName = getProtectedTempChildName(tempRoot, path);
-        if (childName !== undefined && childName.length > 0) {
-            protectedTempChildren.add(resolve(join(tempRoot, childName)));
-        }
-    }
-}
-function forgetMissingPreservedPaths(tempRoot, preservedChildren) {
-    for (const path of protectedTempChildren) {
-        if (dirname(path) === tempRoot && !preservedChildren.has(path)) {
-            protectedTempChildren.delete(path);
-        }
-    }
-}
-export async function cleanupSecureTempArtifacts(options = {}) {
-    await enqueueTempMutation(async () => {
-        const tempRoot = await sessionTempRootPromise?.catch(() => undefined);
-        if (tempRoot === undefined || tempRoot.length === 0) {
-            return;
-        }
-        const normalizedTempRoot = resolve(tempRoot);
-        rememberPreservedPaths(normalizedTempRoot, options.preservePaths ?? []);
-        const preservedChildren = await getExistingProtectedChildren(normalizedTempRoot, protectedTempChildren);
-        forgetMissingPreservedPaths(normalizedTempRoot, preservedChildren);
-        if (preservedChildren.size === 0) {
-            sessionTempRootPromise = undefined;
-            ownedTempRoots.delete(tempRoot);
-            await rm(tempRoot, { force: true, recursive: true }).catch(() => {
-                /* Cleanup failure cannot revive retired ownership. */
-            });
-            return;
-        }
-        await persistProtectedTempChildren(tempRoot, preservedChildren);
-        await removeTempRootChildrenExcept(tempRoot, preservedChildren);
-        await refreshSecureTempRootLease(tempRoot).catch(() => {
-            /* Cleanup retains existing ownership evidence on failed renewal. */
-        });
-    });
-}
-export async function getSessionTempRoot() {
-    if (!sessionTempRootPromise) {
-        sessionTempRootPromise = (async () => {
-            const tempRoot = await mkdtemp(join(tmpdir(), TEMP_ROOT_PREFIX));
-            await chmod(tempRoot, 0o700).catch(() => {
-                /* mkdtemp already creates a private root. */
-            });
-            await writeSecureTempRootOwnershipMarker(tempRoot);
-            ownedTempRoots.add(tempRoot);
-            registerExitCleanup();
-            return tempRoot;
-        })();
-    }
-    const tempRoot = await sessionTempRootPromise;
-    await refreshSecureTempRootLease(tempRoot).catch(() => {
-        /* A failed refresh leaves the existing marker. */
-    });
-    await pruneStaleTempRoots(tempRoot).catch(() => {
-        /* GC cannot prevent using the owned root. */
-    });
-    return tempRoot;
-}
-export async function getSecureTempChildDirectoryValidationError(path, childPrefix) {
-    const parentDirectory = dirname(path);
-    const childName = path.slice(parentDirectory.length + 1);
-    if (!childName.startsWith(childPrefix)) {
-        return `Refusing to remove ${path}; expected wrapper temp child prefix ${childPrefix}.`;
-    }
-    const marker = await readTempRootOwnershipMarker(parentDirectory);
-    if (!marker) {
-        return `Refusing to remove ${path}; parent directory is not a pi-agent-browser owned temp root.`;
-    }
-    const currentUid = getCurrentProcessUid();
-    if (!markerMatchesUid(marker, currentUid)) {
-        return `Refusing to remove ${path}; parent temp root is owned by uid ${marker.ownerUid ?? "unknown"}, not current uid ${currentUid ?? "unknown"}.`;
-    }
-    return undefined;
-}
-export async function getSecureTempDebugState() {
-    return {
-        currentTempRoot: await sessionTempRootPromise?.catch(() => undefined),
-        ownedTempRoots: [...ownedTempRoots].sort(),
-    };
-}

package/dist/extensions/agent-browser/lib/temp.js

@@ -1,91 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { chmod, mkdir, mkdtemp, open, rm } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { enqueueTempMutation } from "./temp-mutation-queue.js";
-import { getSessionTempRoot, refreshSecureTempRootLease } from "./temp-root.js";
-import { assertSecureTempRootBudget, getTempArtifactByteLength, prunePersistentSessionArtifactsToBudget, } from "./temp-artifact-budget.js";
-export { cleanupSecureTempArtifacts, getSecureTempChildDirectoryValidationError, getSecureTempDebugState, preserveSecureTempDirectory, writeSecureTempRootOwnershipMarker, } from "./temp-root.js";
-export { getPersistentSessionArtifactMaxBytes, getSecureTempRootMaxBytes, } from "./temp-artifact-budget.js";
-async function ensurePersistentSessionArtifactDir(store) {
-    const rootDir = join(store.sessionDir, ".pi-agent-browser-artifacts");
-    const sessionDir = join(rootDir, store.sessionId);
-    await mkdir(rootDir, { recursive: true, mode: 0o700 });
-    await chmod(rootDir, 0o700).catch(() => {
-        /* Native creation may already enforce the mode. */
-    });
-    await mkdir(sessionDir, { recursive: true, mode: 0o700 });
-    await chmod(sessionDir, 0o700).catch(() => {
-        /* Native creation may already enforce the mode. */
-    });
-    return sessionDir;
-}
-export async function openSecureTempFile(prefix, suffix) {
-    const tempRoot = await getSessionTempRoot();
-    const path = join(tempRoot, `${prefix}-${randomBytes(8).toString("hex")}${suffix}`);
-    const fileHandle = await open(path, "wx", 0o600);
-    return { fileHandle, path };
-}
-export async function writeSecureTempChunk(options) {
-    const { content, fileHandle, path } = options;
-    await enqueueTempMutation(async () => {
-        const tempRoot = dirname(path);
-        await refreshSecureTempRootLease(tempRoot).catch(() => {
-            /* Lease renewal is best-effort; file ownership is already captured. */
-        });
-        await assertSecureTempRootBudget(tempRoot, getTempArtifactByteLength(content));
-        await fileHandle.appendFile(content);
-    });
-}
-export async function writeSecureTempFile(options) {
-    const { content, prefix, suffix } = options;
-    const { fileHandle, path } = await openSecureTempFile(prefix, suffix);
-    try {
-        await writeSecureTempChunk({ content, fileHandle, path });
-    }
-    catch (error) {
-        await rm(path, { force: true }).catch(() => {
-            /* Retain the original write failure if removal also fails. */
-        });
-        throw error;
-    }
-    finally {
-        await fileHandle.close();
-    }
-    return path;
-}
-export async function createSecureTempDirectory(prefix) {
-    const tempRoot = await getSessionTempRoot();
-    await assertSecureTempRootBudget(tempRoot, 0);
-    const directory = await mkdtemp(join(tempRoot, prefix));
-    await chmod(directory, 0o700).catch(() => {
-        /* mkdtemp supplies the private directory when chmod is unavailable. */
-    });
-    await refreshSecureTempRootLease(tempRoot).catch(() => {
-        /* Renewal is best-effort after private creation. */
-    });
-    return directory;
-}
-export async function writePersistentSessionArtifactFile(options) {
-    const { content, prefix, store, suffix } = options;
-    return await enqueueTempMutation(async () => {
-        const artifactDir = await ensurePersistentSessionArtifactDir(store);
-        const evictedArtifacts = await prunePersistentSessionArtifactsToBudget(artifactDir, getTempArtifactByteLength(content), new Set((store.protectedPaths ?? []).filter((path) => dirname(path) === artifactDir)));
-        const path = join(artifactDir, `${prefix}-${randomBytes(8).toString("hex")}${suffix}`);
-        const fileHandle = await open(path, "wx", 0o600);
-        try {
-            await fileHandle.writeFile(content);
-        }
-        catch (error) {
-            await rm(path, { force: true }).catch(() => {
-                /* Preserve write failure identity. */
-            });
-            throw error;
-        }
-        finally {
-            await fileHandle.close().catch(() => {
-                /* A completed artifact write retains its receipt even if close fails. */
-            });
-        }
-        return { evictedArtifacts, path };
-    });
-}

package/dist/extensions/agent-browser/lib/tool-surface.js

@@ -1,239 +0,0 @@
-import { Text } from "@earendil-works/pi-tui";
-import { formatAgentBrowserRenderCall } from "./pi-tool-rendering.js";
-import { JsonSchema } from "./json-schema.js";
-import { AGENT_BROWSER_NAMESPACE, AGENT_BROWSER_OUTPUT_SCHEMA, finalizeAgentBrowserNativeResult, } from "./native-output.js";
-import { AGENT_BROWSER_PARAMS, AGENT_BROWSER_CODE_PARAMS, AGENT_BROWSER_ACTION_PARAMS, AGENT_BROWSER_QA_PARAMS, AGENT_BROWSER_ELECTRON_PARAMS, AGENT_BROWSER_SOURCE_PARAMS, AGENT_BROWSER_NETWORK_SOURCE_PARAMS, AGENT_BROWSER_TOOLS_PARAMS, } from "./input-modes/params.js";
-export const AGENT_BROWSER_TOOL_INVENTORY = {
-    action: {
-        name: "agent_browser_action",
-        description: "Click, check, fill, or select a unique accessible target using stable locators or current refs.",
-    },
-    qa: {
-        name: "agent_browser_qa",
-        description: "Check a URL or attached page with visible assertions and a diagnostic pass/fail verdict.",
-    },
-    electron: {
-        name: "agent_browser_electron",
-        description: "Discover, launch, probe, and clean up owned Electron desktop applications.",
-    },
-    source: {
-        name: "agent_browser_source",
-        description: "Find experimental DOM/React/local-source candidates with a bounded workspace scan.",
-    },
-    network: {
-        name: "agent_browser_network_source",
-        description: "Correlate failed requests with initiator and local-source candidates.",
-    },
-};
-export const AGENT_BROWSER_INSTRUCTION_GROUP = {
-    name: "browser",
-    description: "Search the web, browse and interact with pages, verify browser UI, and inspect Electron apps.",
-};
-const advancedNames = new Set(Object.values(AGENT_BROWSER_TOOL_INVENTORY).map(({ name }) => name));
-const nativeOutput = {
-    namespace: AGENT_BROWSER_NAMESPACE,
-    outputSchema: AGENT_BROWSER_OUTPUT_SCHEMA,
-};
-function registerCoreTools(pi, options, execute) {
-    pi.registerTool({
-        name: "agent_browser",
-        ...nativeOutput,
-        label: "Agent Browser",
-        description: "Browse and interact through native agent-browser commands. One command in args; fixed sequences use batch --bail and JSON-array stdin. Use agent_browser_code for loops/branches and agent_browser_tools for advanced capabilities.",
-        promptSnippet: "Browse pages, inspect current refs, interact, and run native command batches.",
-        parameters: AGENT_BROWSER_PARAMS,
-        renderCall: options.renderCall,
-        renderResult: options.renderResult,
-        execute,
-        executionMode: options.executionMode,
-    });
-    pi.registerTool({
-        name: "agent_browser_code",
-        ...nativeOutput,
-        label: "Agent Browser Code",
-        description: "Run fresh JavaScript against a persistent browser. await browser({args,stdin?,timeoutMs?}) returns success/data/error/nextActions and imageObservations; emit(selected JSON) and emitImage(image handle) explicitly choose output. No host APIs or imports. Use native batch for fixed sequences.",
-        promptSnippet: "Branch, loop, and aggregate browser observations with explicit JSON/image output.",
-        parameters: AGENT_BROWSER_CODE_PARAMS,
-        execute: async (id, params, signal, onUpdate, ctx) => finalizeAgentBrowserNativeResult(await options.executeCode(id, params, signal, onUpdate, ctx), params),
-        executionMode: options.executionMode,
-        renderCall(args, theme, context) {
-            const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-            text.setText(formatAgentBrowserRenderCall(args, theme, context.expanded));
-            return text;
-        },
-        renderResult: options.renderResult,
-    });
-}
-function registerActionTool(pi, options, execute) {
-    pi.registerTool({
-        ...AGENT_BROWSER_TOOL_INVENTORY.action,
-        ...nativeOutput,
-        defaultActive: false,
-        label: "Browser Action",
-        parameters: AGENT_BROWSER_ACTION_PARAMS,
-        renderResult: options.renderResult,
-        executionMode: options.executionMode,
-        execute(id, { outputPath, timeoutMs, ...semanticAction }, signal, onUpdate, ctx) {
-            return execute(id, { semanticAction, outputPath, timeoutMs }, signal, onUpdate, ctx);
-        },
-    });
-}
-function registerQaTool(pi, options, execute) {
-    pi.registerTool({
-        ...AGENT_BROWSER_TOOL_INVENTORY.qa,
-        ...nativeOutput,
-        defaultActive: false,
-        label: "Browser QA",
-        parameters: AGENT_BROWSER_QA_PARAMS,
-        renderResult: options.renderResult,
-        executionMode: options.executionMode,
-        execute(id, { outputPath, timeoutMs, sessionMode, ...qa }, signal, onUpdate, ctx) {
-            return execute(id, { qa, outputPath, timeoutMs, sessionMode }, signal, onUpdate, ctx);
-        },
-    });
-}
-function registerElectronTool(pi, options, execute) {
-    pi.registerTool({
-        ...AGENT_BROWSER_TOOL_INVENTORY.electron,
-        ...nativeOutput,
-        defaultActive: false,
-        label: "Browser Electron",
-        parameters: AGENT_BROWSER_ELECTRON_PARAMS,
-        renderResult: options.renderResult,
-        executionMode: options.executionMode,
-        execute(id, { outputPath, ...electron }, signal, onUpdate, ctx) {
-            return execute(id, { electron, outputPath }, signal, onUpdate, ctx);
-        },
-    });
-}
-function registerSourceTools(pi, options, execute) {
-    pi.registerTool({
-        ...AGENT_BROWSER_TOOL_INVENTORY.source,
-        ...nativeOutput,
-        defaultActive: false,
-        label: "Browser Source",
-        parameters: AGENT_BROWSER_SOURCE_PARAMS,
-        renderResult: options.renderResult,
-        executionMode: options.executionMode,
-        execute(id, { outputPath, timeoutMs, sessionMode, ...sourceLookup }, signal, onUpdate, ctx) {
-            return execute(id, { sourceLookup, outputPath, timeoutMs, sessionMode }, signal, onUpdate, ctx);
-        },
-    });
-    pi.registerTool({
-        ...AGENT_BROWSER_TOOL_INVENTORY.network,
-        ...nativeOutput,
-        defaultActive: false,
-        label: "Browser Network Source",
-        parameters: AGENT_BROWSER_NETWORK_SOURCE_PARAMS,
-        renderResult: options.renderResult,
-        executionMode: options.executionMode,
-        execute(id, { outputPath, timeoutMs, sessionMode, ...networkSourceLookup }, signal, onUpdate, ctx) {
-            return execute(id, { networkSourceLookup, outputPath, timeoutMs, sessionMode }, signal, onUpdate, ctx);
-        },
-    });
-}
-function toolStatus(available, active) {
-    if (!available) {
-        return "unavailable in this Pi tool selection";
-    }
-    return active ? "active" : "inactive";
-}
-function registerToolLoader(pi) {
-    pi.registerTool({
-        name: "agent_browser_tools",
-        namespace: AGENT_BROWSER_NAMESPACE,
-        outputSchema: JsonSchema.Object({
-            inventory: JsonSchema.Array(JsonSchema.Object({
-                key: JsonSchema.String(),
-                name: JsonSchema.String(),
-                description: JsonSchema.String(),
-                available: JsonSchema.Boolean(),
-                active: JsonSchema.Boolean(),
-            })),
-            added: JsonSchema.Array(JsonSchema.String()),
-        }),
-        label: "Browser Tools",
-        description: "List or enable advanced browser tools: action → agent_browser_action; qa → agent_browser_qa; electron → agent_browser_electron; source → agent_browser_source; network → agent_browser_network_source. Omit enable for inventory. Activation only adds tools; it preserves other active tools.",
-        promptSnippet: "Discover and enable specialized browser actions, QA, Electron, and source tools.",
-        parameters: AGENT_BROWSER_TOOLS_PARAMS,
-        async execute(_id, params) {
-            const available = new Set(pi.getAllTools().map(({ name }) => name));
-            const active = new Set(pi.getActiveTools());
-            const added = (params.enable ?? [])
-                .map((key) => AGENT_BROWSER_TOOL_INVENTORY[key].name)
-                .filter((name) => available.has(name) && !active.has(name));
-            if (added.length > 0) {
-                pi.setActiveTools([...new Set([...active, ...added])]);
-            }
-            const current = new Set(pi.getActiveTools());
-            const inventory = Object.entries(AGENT_BROWSER_TOOL_INVENTORY).map(([key, tool]) => ({
-                key,
-                name: tool.name,
-                description: tool.description,
-                available: available.has(tool.name),
-                active: current.has(tool.name),
-            }));
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: inventory
-                            .map((tool) => `${tool.key}: ${tool.name} (${toolStatus(tool.available, tool.active)}) — ${tool.description}`)
-                            .join("\n"),
-                    },
-                ],
-                details: { inventory, added: [...new Set(added)] },
-                structuredContent: { inventory, added: [...new Set(added)] },
-            };
-        },
-    });
-}
-function hasExplicitToolSelection() {
-    const argv = process.argv.slice(2);
-    const delimiter = argv.indexOf("--");
-    return (delimiter < 0 ? argv : argv.slice(0, delimiter)).some((arg) => arg === "--tools" || arg === "-t");
-}
-function registerAdvancedToolReplay(pi) {
-    pi.on("session_start", async (_event, ctx) => {
-        // ponytail: official 1.0 SDK supplies initialActiveToolNames on resume, bypassing
-        // native transcript restoration. Remove this additive fallback once the supported SDK restores it.
-        if (hasExplicitToolSelection()) {
-            return;
-        }
-        // A host-filtered catalog is an explicit selection, not our default surface.
-        const available = new Set(pi.getAllTools().map(({ name }) => name));
-        if (!["agent_browser", "agent_browser_code", "agent_browser_tools", ...advancedNames].every((name) => available.has(name))) {
-            return;
-        }
-        // Native dynamic imports bypass Pi's host-package aliases in consumer installs.
-        // Only tool names are needed; replay native deltas without requiring the optional pi-ai peer.
-        const restored = new Set();
-        for (const message of ctx.sessionManager.buildSessionProjection().messages) {
-            if (message.role !== "system") {
-                continue;
-            }
-            for (const removed of message.toolsRemoved ?? []) {
-                restored.delete(removed.name);
-            }
-            for (const added of message.toolsAdded ?? []) {
-                restored.add(added.name);
-            }
-        }
-        const active = new Set(pi.getActiveTools());
-        const added = [...restored].filter((name) => advancedNames.has(name) && available.has(name) && !active.has(name));
-        if (added.length > 0) {
-            pi.setActiveTools([...active, ...added]);
-        }
-    });
-}
-/** Register once; adapters retain native execution, output, activation, and replay contracts. */
-export function registerAgentBrowserToolSurface(pi, options) {
-    const execute = async (id, params, signal, onUpdate, ctx) => finalizeAgentBrowserNativeResult(await options.execute(id, params, signal, onUpdate, ctx), params);
-    registerCoreTools(pi, options, execute);
-    registerActionTool(pi, options, execute);
-    registerQaTool(pi, options, execute);
-    registerElectronTool(pi, options, execute);
-    registerSourceTools(pi, options, execute);
-    registerToolLoader(pi);
-    registerAdvancedToolReplay(pi);
-}

package/dist/extensions/agent-browser/lib/upstream-version.js

@@ -1,15 +0,0 @@
-import { MINIMUM_AGENT_BROWSER_VERSION, MINIMUM_AGENT_BROWSER_VERSION_LABEL, SUPPORTED_AGENT_BROWSER_VERSION_LABEL, TARGET_AGENT_BROWSER_VERSION, TARGET_AGENT_BROWSER_VERSION_LABEL, isSupportedAgentBrowserVersion, } from "../../../scripts/agent-browser-target.mjs";
-export { MINIMUM_AGENT_BROWSER_VERSION, MINIMUM_AGENT_BROWSER_VERSION_LABEL, SUPPORTED_AGENT_BROWSER_VERSION_LABEL, TARGET_AGENT_BROWSER_VERSION, TARGET_AGENT_BROWSER_VERSION_LABEL, isSupportedAgentBrowserVersion, };
-export function parseAgentBrowserVersionOutput(stdout) {
-    const match = stdout.trim().match(/^agent-browser\s+(\S+)$/);
-    return match?.[1];
-}
-export function getAgentBrowserVersionValidationError(stdout) {
-    const observed = parseAgentBrowserVersionOutput(stdout);
-    if (observed !== undefined && isSupportedAgentBrowserVersion(observed)) {
-        return undefined;
-    }
-    return observed !== undefined
-        ? `Installed agent-browser ${observed} is unsupported; stable versions must be at least ${MINIMUM_AGENT_BROWSER_VERSION_LABEL}. Install ${TARGET_AGENT_BROWSER_VERSION_LABEL} (recommended), run pi-agent-browser-doctor, then reload Pi.`
-        : `agent-browser --version returned an unrecognized value; expected ${SUPPORTED_AGENT_BROWSER_VERSION_LABEL}. Run pi-agent-browser-doctor and install a supported upstream version.`;
-}