pi-agent-browser-native 0.9.3 → 0.9.5

package/dist/extensions/agent-browser/lib/input-modes/lookup-plan.js

@@ -0,0 +1,132 @@
+import { isRecord } from "../parsing.js";
+import { validateLookupMaxWorkspaceFiles } from "./shared.js";
+function optionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function validateString(value, field, allowEmpty = false) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "string" && (value.trim().length > 0 || (allowEmpty && value === ""))) {
+        return undefined;
+    }
+    if (allowEmpty) {
+        return `${field} must be a non-empty string or the empty default namespace when provided.`;
+    }
+    return `${field} must be a non-empty string when provided.`;
+}
+function validateSourceQuery(input) {
+    for (const field of ["selector", "reactFiberId", "componentName"]) {
+        const error = validateString(input[field], `sourceLookup.${field}`);
+        if (error !== undefined) {
+            return error;
+        }
+    }
+    if (input.selector === undefined &&
+        input.reactFiberId === undefined &&
+        input.componentName === undefined) {
+        return "sourceLookup requires selector, reactFiberId, or componentName.";
+    }
+    if (input.includeDomHints !== undefined && typeof input.includeDomHints !== "boolean") {
+        return "sourceLookup.includeDomHints must be a boolean when provided.";
+    }
+    return undefined;
+}
+function planSourceSteps(query) {
+    const steps = [];
+    if (query.selector !== undefined) {
+        steps.push({ action: "dom", args: ["is", "visible", query.selector] });
+        if (query.includeDomHints) {
+            steps.push({ action: "dom", args: ["get", "html", query.selector] });
+        }
+    }
+    if (query.reactFiberId !== undefined) {
+        steps.push({ action: "react", args: ["react", "inspect", query.reactFiberId] });
+    }
+    if (query.componentName !== undefined) {
+        steps.push({ action: "react", args: ["react", "tree"] });
+    }
+    return steps;
+}
+export function compileAgentBrowserSourceLookup(input) {
+    if (!isRecord(input)) {
+        return { error: "sourceLookup must be an object." };
+    }
+    const error = validateSourceQuery(input);
+    if (error !== undefined) {
+        return { error };
+    }
+    const maxFiles = validateLookupMaxWorkspaceFiles(input.maxWorkspaceFiles, "sourceLookup.maxWorkspaceFiles");
+    if (maxFiles.error !== undefined) {
+        return { error: maxFiles.error };
+    }
+    const query = {
+        componentName: optionalString(input.componentName),
+        includeDomHints: input.includeDomHints !== false,
+        maxWorkspaceFiles: maxFiles.value,
+        reactFiberId: optionalString(input.reactFiberId),
+        selector: optionalString(input.selector),
+    };
+    const steps = planSourceSteps(query);
+    return {
+        compiled: {
+            args: ["batch"],
+            query,
+            stdin: JSON.stringify(steps.map((step) => step.args)),
+            steps,
+        },
+    };
+}
+function validateNetworkQuery(input) {
+    for (const field of ["filter", "requestId", "namespace", "session", "url"]) {
+        const error = validateString(input[field], `networkSourceLookup.${field}`, field === "namespace");
+        if (error !== undefined) {
+            return error;
+        }
+    }
+    if (input.filter === undefined && input.requestId === undefined && input.url === undefined) {
+        return "networkSourceLookup requires requestId, filter, or url.";
+    }
+    return undefined;
+}
+function planNetworkSteps(query) {
+    const steps = [];
+    if (query.requestId !== undefined) {
+        steps.push({ action: "network", args: ["network", "request", query.requestId] });
+    }
+    const effectiveFilter = query.filter ?? query.url;
+    if (effectiveFilter !== undefined && effectiveFilter.length > 0) {
+        steps.push({ action: "network", args: ["network", "requests", "--filter", effectiveFilter] });
+    }
+    return steps;
+}
+export function compileAgentBrowserNetworkSourceLookup(input) {
+    if (!isRecord(input)) {
+        return { error: "networkSourceLookup must be an object." };
+    }
+    const error = validateNetworkQuery(input);
+    if (error !== undefined) {
+        return { error };
+    }
+    const maxFiles = validateLookupMaxWorkspaceFiles(input.maxWorkspaceFiles, "networkSourceLookup.maxWorkspaceFiles");
+    if (maxFiles.error !== undefined) {
+        return { error: maxFiles.error };
+    }
+    const query = {
+        filter: optionalString(input.filter),
+        maxWorkspaceFiles: maxFiles.value,
+        namespace: optionalString(input.namespace),
+        requestId: optionalString(input.requestId),
+        session: optionalString(input.session),
+        url: optionalString(input.url),
+    };
+    const steps = planNetworkSteps(query);
+    const args = [
+        ...(query.namespace !== undefined ? ["--namespace", query.namespace] : []),
+        ...(query.session !== undefined ? ["--session", query.session] : []),
+        "batch",
+    ];
+    return {
+        compiled: { args, query, stdin: JSON.stringify(steps.map((step) => step.args)), steps },
+    };
+}

package/dist/extensions/agent-browser/lib/input-modes/lookup-redaction.js

@@ -0,0 +1,57 @@
+import { isRecord } from "../parsing.js";
+import { redactInvocationArgs, redactSensitiveText } from "../runtime-redaction.js";
+export function redactNetworkSourceLookupUrl(value) {
+    if (value === undefined || value.length === 0) {
+        return value;
+    }
+    try {
+        const isRelative = value.startsWith("/");
+        const url = new URL(value, isRelative ? "https://redacted.invalid" : undefined);
+        url.username = url.username.length > 0 ? "[REDACTED]" : "";
+        url.password = url.password.length > 0 ? "[REDACTED]" : "";
+        // Snapshot keys before set() collapses duplicates and changes iterator positions.
+        for (const key of Array.from(url.searchParams.keys())) {
+            url.searchParams.set(key, "[REDACTED]");
+        }
+        if (/(?:token|secret|password|passwd|pwd|key|auth|session|jwt|credential)/i.test(url.hash)) {
+            url.hash = "#[REDACTED]";
+        }
+        return isRelative ? `${url.pathname}${url.search}${url.hash}` : url.toString();
+    }
+    catch {
+        return redactSensitiveText(value
+            .replace(/([a-z][a-z0-9+.-]*:\/\/)\S+:\S+@/gi, "$1[REDACTED]@")
+            .replace(/([?&][^=]+)=([^&#\s"'\]]+)/g, "$1=[REDACTED]"));
+    }
+}
+export function redactNetworkSourceLookupArgs(args) {
+    return redactInvocationArgs(args).map((arg) => redactNetworkSourceLookupUrl(arg) ?? arg);
+}
+export function redactNetworkSourceLookupSurface(value) {
+    if (typeof value === "string") {
+        return redactNetworkSourceLookupUrl(value) ?? value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactNetworkSourceLookupSurface(item));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactNetworkSourceLookupSurface(item)]));
+}
+export function redactNetworkSourceLookupAnalysis(analysis) {
+    return {
+        ...analysis,
+        candidates: analysis.candidates.map((candidate) => ({
+            ...candidate,
+            evidence: candidate.evidence.map((item) => redactNetworkSourceLookupUrl(item) ?? redactSensitiveText(item)),
+            file: redactNetworkSourceLookupUrl(candidate.file),
+            requestUrl: redactNetworkSourceLookupUrl(candidate.requestUrl),
+        })),
+        failedRequests: analysis.failedRequests.map((request) => ({
+            ...request,
+            error: redactNetworkSourceLookupUrl(request.error),
+            url: redactNetworkSourceLookupUrl(request.url),
+        })),
+    };
+}

package/dist/extensions/agent-browser/lib/input-modes/lookup-source-evidence.js

@@ -0,0 +1,151 @@
+import { isRecord } from "../parsing.js";
+import { getBatchResultItems } from "./shared.js";
+function extractStringField(value, names) {
+    for (const name of names) {
+        const field = value[name];
+        if (typeof field === "string" && field.trim().length > 0) {
+            return field;
+        }
+    }
+    return undefined;
+}
+function extractNumberField(value, names) {
+    for (const name of names) {
+        const field = value[name];
+        if (typeof field === "number" && Number.isFinite(field)) {
+            return field;
+        }
+        if (typeof field === "string" && /^\d+$/.test(field)) {
+            return Number(field);
+        }
+    }
+    return undefined;
+}
+function candidateKey(candidate) {
+    return [
+        candidate.source,
+        candidate.file ?? "",
+        candidate.line ?? "",
+        candidate.column ?? "",
+        candidate.componentName ?? "",
+    ].join(":");
+}
+export function distinctSourceCandidates(candidates) {
+    const keys = new Set();
+    return candidates.filter((candidate) => {
+        const key = candidateKey(candidate);
+        if (keys.has(key)) {
+            return false;
+        }
+        keys.add(key);
+        return true;
+    });
+}
+function sourceTextCandidates(value, hint) {
+    const pattern = /([A-Za-z0-9_./@-]+\.(?:tsx|jsx|ts|js))(?:[:#](\d+))?(?:[:#](\d+))?/g;
+    return [...value.matchAll(pattern)].map((match) => ({
+        column: match.at(3) !== undefined ? Number(match[3]) : undefined,
+        confidence: hint.source === "react-inspect" ? "high" : "medium",
+        evidence: hint.evidence,
+        file: match[1],
+        line: match.at(2) !== undefined ? Number(match[2]) : undefined,
+        source: hint.source,
+    }));
+}
+function sourceRecordCandidate(value, hint) {
+    const file = extractStringField(value, [
+        "file",
+        "fileName",
+        "filename",
+        "filePath",
+        "path",
+        "source",
+        "url",
+    ]);
+    if (file === undefined || !/\.(?:tsx|jsx|ts|js)(?:$|[:?#])/.test(file)) {
+        return [];
+    }
+    return [
+        {
+            column: extractNumberField(value, ["column", "columnNumber", "col"]),
+            confidence: hint.source === "react-inspect" ? "high" : "medium",
+            evidence: hint.evidence,
+            file,
+            line: extractNumberField(value, ["line", "lineNumber"]),
+            source: hint.source,
+        },
+    ];
+}
+export function sourceCandidatesFromValue(value, hint, depth = 0) {
+    if (depth > 6 || value === undefined || value === null) {
+        return [];
+    }
+    if (typeof value === "string") {
+        return sourceTextCandidates(value, hint);
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => sourceCandidatesFromValue(item, hint, depth + 1));
+    }
+    if (!isRecord(value)) {
+        return [];
+    }
+    return [
+        ...sourceRecordCandidate(value, hint),
+        ...Object.values(value).flatMap((nested) => sourceCandidatesFromValue(nested, hint, depth + 1)),
+    ];
+}
+function getHtmlAttributeValue(html, name) {
+    return new RegExp(`${name}=["']([^"']+)["']`, "i").exec(html)?.[1];
+}
+function htmlAttributeNumber(html, name) {
+    const value = getHtmlAttributeValue(html, name);
+    return value !== undefined && /^\d+$/.test(value) ? Number(value) : undefined;
+}
+function domSourceCandidates(html) {
+    if (typeof html !== "string") {
+        return [];
+    }
+    const file = getHtmlAttributeValue(html, "(?:data-source-file|data-file|data-component-file|data-source)");
+    const attributes = [];
+    if (file !== undefined && /\.(?:tsx|jsx|ts|js)$/.test(file)) {
+        attributes.push({
+            column: htmlAttributeNumber(html, "(?:data-source-column|data-column)"),
+            confidence: "medium",
+            evidence: ["selector HTML contained source-like data attributes"],
+            file,
+            line: htmlAttributeNumber(html, "(?:data-source-line|data-line)"),
+            source: "dom-attribute",
+        });
+    }
+    return [
+        ...attributes,
+        ...sourceCandidatesFromValue(html, {
+            source: "dom-attribute",
+            evidence: ["selector HTML contained source-like text"],
+        }),
+    ];
+}
+export function getLookupResultPayload(item) {
+    return isRecord(item.result) && "data" in item.result ? item.result.data : item.result;
+}
+export function observeSourceCandidates(data) {
+    const candidates = [];
+    let unsupported = false;
+    for (const item of getBatchResultItems(data)) {
+        const command = Array.isArray(item.command) ? item.command : [];
+        const result = getLookupResultPayload(item);
+        if (item.success === false && command[0] === "react") {
+            unsupported = true;
+        }
+        if (command[0] === "react" && command[1] === "inspect") {
+            candidates.push(...sourceCandidatesFromValue(result, {
+                source: "react-inspect",
+                evidence: ["react inspect returned source-like metadata"],
+            }));
+        }
+        if (command[0] === "get" && command[1] === "html") {
+            candidates.push(...domSourceCandidates(result));
+        }
+    }
+    return { candidates: distinctSourceCandidates(candidates), unsupported };
+}

package/dist/extensions/agent-browser/lib/input-modes/lookup-workspace.js

@@ -0,0 +1,142 @@
+import { readFile, readdir } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { distinctNetworkCandidates } from "./lookup-network-evidence.js";
+import { SOURCE_LOOKUP_IGNORED_DIRECTORIES, SOURCE_LOOKUP_WORKSPACE_EXTENSIONS, } from "./types.js";
+async function walkWorkspaceSourceFiles(root, maxFiles) {
+    const files = [];
+    async function visit(directory) {
+        if (files.length >= maxFiles) {
+            return;
+        }
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            // Unreadable workspace directories contribute no source candidates.
+            return;
+        }
+        for (const entry of entries) {
+            if (files.length >= maxFiles) {
+                return;
+            }
+            const path = join(directory, entry.name);
+            if (entry.isDirectory() && !SOURCE_LOOKUP_IGNORED_DIRECTORIES.has(entry.name)) {
+                // Ordered depth-first traversal preserves which files enter the bounded scan.
+                // oxlint-disable-next-line no-await-in-loop
+                await visit(path);
+            }
+            if (entry.isFile() && SOURCE_LOOKUP_WORKSPACE_EXTENSIONS.has(extname(entry.name))) {
+                files.push(path);
+            }
+        }
+    }
+    await visit(root);
+    return files;
+}
+async function readWorkspaceText(file) {
+    try {
+        return await readFile(file, "utf8");
+    }
+    catch {
+        // A file removed or unreadable after enumeration is not lookup evidence.
+        return undefined;
+    }
+}
+function scanLimitations(files, maxFiles) {
+    return files.length >= maxFiles ? [`Workspace source scan stopped at ${maxFiles} files.`] : [];
+}
+function componentPattern(name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:function|class)\\s+${escaped}\\b|(?:const|let|var)\\s+${escaped}\\s*=|export\\s+default\\s+function\\s+${escaped}\\b`);
+}
+export async function scanWorkspaceComponent(query, cwd) {
+    const componentName = query.componentName;
+    if (componentName === undefined || componentName.length === 0) {
+        return { candidates: [], limitations: [] };
+    }
+    const files = await walkWorkspaceSourceFiles(cwd, query.maxWorkspaceFiles);
+    const pattern = componentPattern(componentName);
+    const candidates = [];
+    for (const file of files) {
+        // Reads remain serial so the ten-candidate budget stops further filesystem work.
+        // oxlint-disable-next-line no-await-in-loop
+        const text = await readWorkspaceText(file);
+        if (text === undefined) {
+            continue;
+        }
+        const match = pattern.exec(text);
+        if (match === null) {
+            continue;
+        }
+        candidates.push({
+            componentName,
+            confidence: "low",
+            evidence: [`local workspace contains a matching ${componentName} declaration`],
+            file,
+            line: text.slice(0, match.index).split("\n").length,
+            source: "workspace-search",
+        });
+        if (candidates.length >= 10) {
+            break;
+        }
+    }
+    return { candidates, limitations: scanLimitations(files, query.maxWorkspaceFiles) };
+}
+function requestNeedles(value) {
+    try {
+        const parsed = new URL(value);
+        return [value, parsed.pathname].filter((item) => item.length > 0 && item !== "/");
+    }
+    catch {
+        return [value];
+    }
+}
+function workspaceRequestNeedles(query, failedRequests) {
+    return [
+        ...new Set([query.url, query.filter, ...failedRequests.map((request) => request.url)]
+            .filter((value) => typeof value === "string" && value.length > 0)
+            .flatMap(requestNeedles)),
+    ].slice(0, 8);
+}
+function requestLiteralCandidates(text, file, needles) {
+    const candidates = [];
+    for (const needle of needles) {
+        const index = text.indexOf(needle);
+        if (index !== -1) {
+            candidates.push({
+                confidence: "low",
+                evidence: [`local workspace contains request URL literal ${needle}`],
+                file,
+                line: text.slice(0, index).split("\n").length,
+                requestUrl: needle,
+                source: "workspace-search",
+            });
+        }
+    }
+    return candidates;
+}
+export async function scanWorkspaceRequests(query, failedRequests, cwd) {
+    const needles = workspaceRequestNeedles(query, failedRequests);
+    if (needles.length === 0) {
+        return { candidates: [], limitations: [] };
+    }
+    const files = await walkWorkspaceSourceFiles(cwd, query.maxWorkspaceFiles);
+    let candidates = [];
+    for (const file of files) {
+        // Preserve first-match ordering and stop reading files at the candidate budget.
+        // oxlint-disable-next-line no-await-in-loop
+        const text = await readWorkspaceText(file);
+        if (text === undefined) {
+            continue;
+        }
+        candidates = distinctNetworkCandidates([
+            ...candidates,
+            ...requestLiteralCandidates(text, file, needles),
+        ]).slice(0, 10);
+        if (candidates.length >= 10) {
+            break;
+        }
+    }
+    return { candidates, limitations: scanLimitations(files, query.maxWorkspaceFiles) };
+}