pi-agent-browser-native 0.9.5 → 0.9.6

package/dist/extensions/agent-browser/lib/bash-guard.js

@@ -1,193 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { isRecord } from "./parsing.js";
-const DIRECT_AGENT_BROWSER_BASH_BYPASS_ENV = "PI_AGENT_BROWSER_ALLOW_DIRECT_BASH";
-const DIRECT_AGENT_BROWSER_EXECUTABLE_PATTERN = /^(?:[.~]|\.\.?|\/)?(?:[^\s;&|]+\/)?agent-browser$/;
-const HARMLESS_AGENT_BROWSER_INSPECTION_PATTERN = /^\s*(?:command\s+-v|which|type\s+-P)\s+agent-browser\s*$/;
-const PACKAGE_NAME = "pi-agent-browser-native";
-function isShellAssignmentToken(token) {
-    return /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
-}
-function stripOuterQuotes(token) {
-    if (token.length >= 2 &&
-        ((token.startsWith('"') && token.endsWith('"')) ||
-            (token.startsWith("'") && token.endsWith("'")))) {
-        return token.slice(1, -1);
-    }
-    return token;
-}
-function skipAssignments(tokens, start) {
-    let index = start;
-    while (index < tokens.length && isShellAssignmentToken(tokens[index])) {
-        index += 1;
-    }
-    return index;
-}
-function skipRunnerOptions(tokens, start) {
-    let index = start;
-    while (index < tokens.length && tokens[index].startsWith("-")) {
-        index += 1;
-    }
-    return index;
-}
-function separatorWidth(command, index) {
-    const char = command[index];
-    if (char !== "\n" && char !== "|" && char !== ";" && char !== "&") {
-        return 0;
-    }
-    const operator = command.slice(index, index + 2);
-    return operator === "&&" || operator === "||" ? 2 : 1;
-}
-function segmentLaunchesAgentBrowser(tokens) {
-    let index = skipAssignments(tokens, 0);
-    if (index >= tokens.length) {
-        return false;
-    }
-    if (tokens[index] === "env") {
-        index = skipAssignments(tokens, index + 1);
-    }
-    if (tokens[index] === "npx" || tokens[index] === "bunx") {
-        index = skipRunnerOptions(tokens, index + 1);
-    }
-    if (tokens[index] === "pnpm" || tokens[index] === "yarn") {
-        if (tokens[index + 1] !== "dlx") {
-            return false;
-        }
-        index = skipRunnerOptions(tokens, index + 2);
-    }
-    return DIRECT_AGENT_BROWSER_EXECUTABLE_PATTERN.test(tokens[index] ?? "");
-}
-/** Owns only the best-effort lexical scan, not shell execution or authorization. */
-class ShellLaunchScanner {
-    currentToken = "";
-    quoteState;
-    awaitingHeredocDelimiter;
-    pendingHeredoc;
-    pendingHeredocLine = "";
-    segmentTokens = [];
-    flushToken() {
-        const token = this.currentToken;
-        this.currentToken = "";
-        if (token.length === 0) {
-            return;
-        }
-        if (this.awaitingHeredocDelimiter) {
-            this.pendingHeredoc = {
-                delimiter: stripOuterQuotes(token),
-                stripTabs: this.awaitingHeredocDelimiter.stripTabs,
-            };
-            this.awaitingHeredocDelimiter = undefined;
-            return;
-        }
-        this.segmentTokens.push(token);
-    }
-    flushSegment() {
-        this.flushToken();
-        const launches = segmentLaunchesAgentBrowser(this.segmentTokens);
-        this.segmentTokens = [];
-        return launches;
-    }
-    consumeHeredoc(char) {
-        const heredoc = this.pendingHeredoc;
-        if (!heredoc) {
-            return false;
-        }
-        if (char !== "\n") {
-            this.pendingHeredocLine += char;
-            return true;
-        }
-        const candidate = heredoc.stripTabs
-            ? this.pendingHeredocLine.replace(/^\t+/, "")
-            : this.pendingHeredocLine;
-        if (candidate === heredoc.delimiter) {
-            this.pendingHeredoc = undefined;
-        }
-        this.pendingHeredocLine = "";
-        return true;
-    }
-    consumeQuoted(command, index) {
-        const char = command[index];
-        if (this.quoteState === undefined) {
-            return undefined;
-        }
-        this.currentToken += char;
-        if (this.quoteState === "double" && char === "\\" && index + 1 < command.length) {
-            this.currentToken += command[index + 1];
-            return index + 1;
-        }
-        if ((this.quoteState === "single" && char === "'") ||
-            (this.quoteState === "double" && char === '"')) {
-            this.quoteState = undefined;
-        }
-        return index;
-    }
-    consumeTokenCharacter(command, index) {
-        const char = command[index];
-        if (char === "'" || char === '"') {
-            this.currentToken += char;
-            this.quoteState = char === "'" ? "single" : "double";
-            return index;
-        }
-        if (char === "\\" && index + 1 < command.length) {
-            this.currentToken += char + command[index + 1];
-            return index + 1;
-        }
-        if (char !== "\n" && /\s/.test(char)) {
-            this.flushToken();
-            return index;
-        }
-        if (command.slice(index, index + 2) === "<<") {
-            this.flushToken();
-            const stripTabs = command[index + 2] === "-";
-            this.awaitingHeredocDelimiter = { stripTabs };
-            return index + (stripTabs ? 2 : 1);
-        }
-        return undefined;
-    }
-    scan(command) {
-        for (let index = 0; index < command.length; index += 1) {
-            if (this.consumeHeredoc(command[index])) {
-                continue;
-            }
-            const consumed = this.consumeQuoted(command, index) ?? this.consumeTokenCharacter(command, index);
-            if (consumed !== undefined) {
-                index = consumed;
-                continue;
-            }
-            const width = separatorWidth(command, index);
-            if (width > 0) {
-                if (this.flushSegment()) {
-                    return true;
-                }
-                index += width - 1;
-                continue;
-            }
-            this.currentToken += command[index];
-        }
-        return this.flushSegment();
-    }
-}
-// Best-effort detection for common direct launches only. This is an ergonomics guard,
-// not a general-purpose bash parser or security boundary.
-export function looksLikeDirectAgentBrowserBash(command) {
-    return new ShellLaunchScanner().scan(command);
-}
-export function isHarmlessAgentBrowserInspectionCommand(command) {
-    return HARMLESS_AGENT_BROWSER_INSPECTION_PATTERN.test(command);
-}
-function isTruthyEnvValue(value) {
-    return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
-}
-async function isPackageDevelopmentCwd(cwd) {
-    try {
-        const packageJson = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
-        return isRecord(packageJson) && packageJson.name === PACKAGE_NAME;
-    }
-    catch {
-        return false;
-    }
-}
-export async function isDirectAgentBrowserBashAllowed(cwd) {
-    return (isTruthyEnvValue(process.env[DIRECT_AGENT_BROWSER_BASH_BYPASS_ENV]) ||
-        (await isPackageDevelopmentCwd(cwd)));
-}

package/dist/extensions/agent-browser/lib/batch-lifecycle.js

@@ -1,131 +0,0 @@
-import { extractUpstreamCommandTokens } from "./argv-descriptor.js";
-import { isCloseAllCommand, isCloseCommand } from "./command-taxonomy.js";
-import { isRecord } from "./parsing.js";
-import { isSuccessfulNativeConfirmedClose } from "./native-confirmation.js";
-import { detectConfirmationRequired } from "./results/confirmation.js";
-function rowCommand(value, fallback) {
-    return Array.isArray(value) && value.every((token) => typeof token === "string")
-        ? value
-        : fallback;
-}
-function rowResult(row) {
-    if (isRecord(row.result)) {
-        return row.result;
-    }
-    return isRecord(row.data) ? row.data : undefined;
-}
-function rowBrowserLaunched(row, result) {
-    const lifecycle = isRecord(row.lifecycle) ? row.lifecycle : result?.lifecycle;
-    if (!isRecord(lifecycle) || !isRecord(lifecycle.effectiveLaunch)) {
-        return undefined;
-    }
-    const launched = lifecycle.effectiveLaunch.browserLaunched;
-    return typeof launched === "boolean" ? launched : undefined;
-}
-function lifecycleStep(value, fallback) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    const result = rowResult(value);
-    const command = rowCommand(value.command, fallback);
-    return {
-        result,
-        succeeded: value.success === true,
-        browserLaunched: rowBrowserLaunched(value, result),
-        tokens: command === undefined ? undefined : extractUpstreamCommandTokens(command),
-    };
-}
-export function batchHasSuccessfulCloseAll(data, fallbackCommands = []) {
-    if (!Array.isArray(data)) {
-        return false;
-    }
-    return data.some((row, index) => {
-        if (!isRecord(row) || row.success !== true) {
-            return false;
-        }
-        const command = rowCommand(row.command, fallbackCommands.at(index));
-        return (command !== undefined &&
-            !detectConfirmationRequired(row.result) &&
-            isCloseAllCommand(extractUpstreamCommandTokens(command)));
-    });
-}
-function successfulClose(step) {
-    return (step.succeeded &&
-        step.tokens !== undefined &&
-        !detectConfirmationRequired(step.result) &&
-        (isCloseCommand(step.tokens[0]) || isSuccessfulNativeConfirmedClose(step.tokens, step.result)));
-}
-function closedState(step) {
-    const result = step.result;
-    const closeData = step.tokens?.[0] === "confirm" && isRecord(result) && isRecord(result.result)
-        ? result.result.data
-        : result;
-    return {
-        endsClosed: true,
-        browserActiveAfterClose: false,
-        recordingClosedAfterBatch: true,
-        statePath: isRecord(closeData) && typeof closeData.statePath === "string"
-            ? closeData.statePath
-            : undefined,
-    };
-}
-function recordingState(state, step) {
-    const relaunched = step.browserLaunched !== false;
-    const browserActiveAfterClose = state.browserActiveAfterClose || relaunched;
-    let recordingClosedAfterBatch = state.recordingClosedAfterBatch;
-    const subcommand = step.tokens?.[1];
-    if (step.succeeded && subcommand === "stop") {
-        recordingClosedAfterBatch = true;
-    }
-    else if (step.succeeded &&
-        browserActiveAfterClose &&
-        (subcommand === "start" || subcommand === "restart")) {
-        recordingClosedAfterBatch = false;
-    }
-    return {
-        ...state,
-        endsClosed: state.endsClosed && !relaunched,
-        browserActiveAfterClose,
-        recordingClosedAfterBatch,
-    };
-}
-function advanceClosedState(state, step) {
-    if (step.tokens?.[0] === "record") {
-        return recordingState(state, step);
-    }
-    if (step.browserLaunched === false) {
-        return state;
-    }
-    return {
-        ...state,
-        endsClosed: false,
-        browserActiveAfterClose: true,
-        recordingClosedAfterBatch: step.tokens === undefined ? false : state.recordingClosedAfterBatch,
-    };
-}
-/** Fold in execution order. Unknown launch evidence conservatively retains active ownership, including failed rows. */
-export function getSuccessfulBatchCloseLifecycle(rows, fallbackCommands = []) {
-    if (!Array.isArray(rows)) {
-        return undefined;
-    }
-    let state;
-    for (const [index, row] of rows.entries()) {
-        const step = lifecycleStep(row, fallbackCommands.at(index));
-        if (step === undefined) {
-            continue;
-        }
-        if (successfulClose(step)) {
-            state = closedState(step);
-        }
-        else if (state !== undefined) {
-            state = advanceClosedState(state, step);
-        }
-    }
-    return state === undefined
-        ? undefined
-        : {
-            endsClosed: state.endsClosed,
-            recordingClosedAfterBatch: state.recordingClosedAfterBatch,
-            statePath: state.statePath,
-        };
-}

package/dist/extensions/agent-browser/lib/browser-execution-claim-codec.js

@@ -1,61 +0,0 @@
-import { isRecord } from "./parsing.js";
-import { isBrowserStringArray } from "./browser-value-parsing.js";
-export const POLICY_LOCK_MAX_BYTES = 1_048_576;
-function claimNumber(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
-}
-function claimStartIdentity(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function validClaimToken(value) {
-    return (typeof value === "string" &&
-        value.length > 0 &&
-        !value.includes("/") &&
-        !value.includes("\\") &&
-        !value.includes("\0"));
-}
-function claimSessionNames(value) {
-    if (value === null) {
-        return null;
-    }
-    return isBrowserStringArray(value) && value.length > 0 ? value : undefined;
-}
-export function parseOwner(content) {
-    if (Buffer.byteLength(content) > POLICY_LOCK_MAX_BYTES) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(content);
-        if (!isRecord(parsed) || parsed.version !== 4) {
-            return undefined;
-        }
-        const pid = claimNumber(parsed.pid);
-        const sessionNames = claimSessionNames(parsed.sessionNames);
-        const startIdentity = claimStartIdentity(parsed.startIdentity);
-        if (pid === undefined ||
-            sessionNames === undefined ||
-            startIdentity === undefined ||
-            !validClaimToken(parsed.token)) {
-            return undefined;
-        }
-        return { sessionNames, pid, startIdentity, token: parsed.token, version: 4 };
-    }
-    catch {
-        return undefined;
-    }
-}
-export function parseTicket(content, token) {
-    if (Buffer.byteLength(content) > POLICY_LOCK_MAX_BYTES) {
-        return undefined;
-    }
-    try {
-        const parsed = JSON.parse(content);
-        if (!isRecord(parsed) || parsed.version !== 4 || parsed.token !== token) {
-            return undefined;
-        }
-        return claimNumber(parsed.ticket);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/extensions/agent-browser/lib/browser-execution-claim-storage.js

@@ -1,232 +0,0 @@
-import { randomInt, randomUUID } from "node:crypto";
-import { lstat, readFile, readdir, rename, rm } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-import { processStartIdentitiesMatch, readProcessStartIdentity } from "./process-identity.js";
-import { getErrorCode } from "./process-errors.js";
-import { parseOwner, parseTicket, POLICY_LOCK_MAX_BYTES, } from "./browser-execution-claim-codec.js";
-export const POLICY_LOCK_WAIT_MS = 1_000;
-export const LOCK_OWNER_FILE = "owner.json";
-export const LOCK_TICKET_FILE = "ticket.json";
-const STALE_CLAIM_MIN_AGE_MS = 30 * 60 * 1_000;
-const POLICY_GC_BATCH_SIZE = 8;
-let lastPolicyGcName;
-function secureEntry(entry, directory) {
-    if (entry.isSymbolicLink() || (directory ? !entry.isDirectory() : !entry.isFile())) {
-        return false;
-    }
-    if (!directory && entry.size > POLICY_LOCK_MAX_BYTES) {
-        return false;
-    }
-    return secureEntryOwnership(entry, directory ? 0o077 : 0o177);
-}
-function secureEntryOwnership(entry, mask) {
-    if (process.platform === "win32") {
-        return true;
-    }
-    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
-    return uid !== undefined && entry.uid === uid && (entry.mode & mask) === 0;
-}
-async function readClaimTicket(path, owner) {
-    const ticketPath = join(path, LOCK_TICKET_FILE);
-    try {
-        if (!secureEntry(await lstat(ticketPath), false)) {
-            return undefined;
-        }
-        const ticket = parseTicket(await readFile(ticketPath, "utf8"), owner.token);
-        return ticket === undefined ? undefined : { owner, path, ticket };
-    }
-    catch (error) {
-        return getErrorCode(error) === "ENOENT" ? { owner, path, ticket: null } : undefined;
-    }
-}
-export async function readClaim(path) {
-    try {
-        const directory = await lstat(path);
-        const ownerPath = join(path, LOCK_OWNER_FILE);
-        const ownerEntry = await lstat(ownerPath);
-        if (!secureEntry(directory, true) || !secureEntry(ownerEntry, false)) {
-            return undefined;
-        }
-        const owner = parseOwner(await readFile(ownerPath, "utf8"));
-        return owner ? await readClaimTicket(path, owner) : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function claimDisappeared(path) {
-    try {
-        await lstat(path);
-        return false;
-    }
-    catch (error) {
-        return getErrorCode(error) === "ENOENT";
-    }
-}
-export async function readClaims(basePath) {
-    const directory = dirname(basePath);
-    const prefix = `${basename(basePath)}.claim-`;
-    let names;
-    try {
-        names = await readdir(directory);
-    }
-    catch {
-        return undefined;
-    }
-    const claims = [];
-    for (const name of names.filter((candidate) => candidate.startsWith(prefix))) {
-        const path = join(directory, name);
-        // Claim absence must be resolved before accepting the next contender.
-        // oxlint-disable-next-line no-await-in-loop
-        const claim = await readClaim(path);
-        if (!claim) {
-            // A disappearing immutable claim is not a corrupt contender.
-            // oxlint-disable-next-line no-await-in-loop
-            if (await claimDisappeared(path)) {
-                continue;
-            }
-            return undefined;
-        }
-        if (name !== `${prefix}${claim.owner.token}`) {
-            return undefined;
-        }
-        claims.push(claim);
-    }
-    return claims;
-}
-export async function ownerAlive(owner, budget) {
-    try {
-        process.kill(owner.pid, 0);
-    }
-    catch (error) {
-        const code = getErrorCode(error);
-        if (code === "ESRCH") {
-            return false;
-        }
-        if (code !== "EPERM") {
-            return undefined;
-        }
-    }
-    const current = await readProcessStartIdentity(owner.pid, process.platform, budget);
-    return current === undefined
-        ? undefined
-        : processStartIdentitiesMatch(owner.startIdentity, current);
-}
-export function waitForRetry(signal) {
-    return new Promise((resolve) => {
-        if (signal?.aborted === true) {
-            resolve();
-            return;
-        }
-        const timer = setTimeout(done, 10);
-        function done() {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", done);
-            resolve();
-        }
-        signal?.addEventListener("abort", done, { once: true });
-    });
-}
-async function moveOwnedClaim(path, movedPath, token, deadline) {
-    while (true) {
-        // Each retry must revalidate ownership before another move attempt.
-        // oxlint-disable-next-line no-await-in-loop
-        if ((await readClaim(path))?.owner.token !== token) {
-            return undefined;
-        }
-        try {
-            // Windows readers may temporarily hold the directory; moves stay serialized.
-            // oxlint-disable-next-line no-await-in-loop
-            await rename(path, movedPath);
-            return "moved";
-        }
-        catch (error) {
-            const code = getErrorCode(error);
-            if (code === "ENOENT") {
-                return "absent";
-            }
-            if (process.platform !== "win32" || code !== "EPERM" || Date.now() >= deadline) {
-                return undefined;
-            }
-            // Retry only after a bounded pause, then revalidate the same immutable owner.
-            // oxlint-disable-next-line no-await-in-loop
-            await waitForRetry();
-            if (Date.now() >= deadline) {
-                return undefined;
-            }
-        }
-    }
-}
-export async function removeClaimOwnedBy(path, token, deadline = 0) {
-    const movedPath = join(dirname(path), `.pi-agent-browser-policy-remove-${token}-${randomUUID()}`);
-    const movement = await moveOwnedClaim(path, movedPath, token, deadline);
-    if (movement === "absent") {
-        return true;
-    }
-    if (movement !== "moved") {
-        return false;
-    }
-    const moved = await readClaim(movedPath);
-    if (moved?.owner.token !== token) {
-        try {
-            await rename(movedPath, path);
-        }
-        catch {
-            /* An unverified moved claim remains unavailable to contenders. */
-        }
-        return false;
-    }
-    await rm(movedPath, { force: true, recursive: true });
-    return true;
-}
-function gcBatch(names) {
-    // ponytail: list/sort all names; stream directories if enumeration becomes the bottleneck.
-    const candidates = names
-        .filter((name) => name.startsWith(".pi-agent-browser-policy-remove-") ||
-        /^\.pi-agent-browser-policy-[a-f0-9]{64}\.lock-v4\.(?:candidate|claim)-/.test(name))
-        .sort();
-    if (candidates.length === 0) {
-        return [];
-    }
-    const previous = lastPolicyGcName;
-    const start = previous === undefined
-        ? randomInt(candidates.length)
-        : Math.max(0, candidates.findIndex((name) => name > previous));
-    const batch = Array.from({ length: Math.min(POLICY_GC_BATCH_SIZE, candidates.length) }, (_, offset) => candidates[(start + offset) % candidates.length]);
-    lastPolicyGcName = batch.at(-1);
-    return batch;
-}
-async function cleanDeadClaim(directory, name, budget) {
-    const path = join(directory, name);
-    const published = name.includes(".lock-v4.claim-");
-    if (published) {
-        const entry = await lstat(path).catch(() => undefined);
-        if (!entry || entry.mtimeMs >= Date.now() - STALE_CLAIM_MIN_AGE_MS) {
-            return;
-        }
-    }
-    const claim = await readClaim(path);
-    if (!claim || (published && !name.endsWith(`.claim-${claim.owner.token}`))) {
-        return;
-    }
-    if ((await ownerAlive(claim.owner, budget)) === false) {
-        await removeClaimOwnedBy(path, claim.owner.token).catch(() => false);
-    }
-}
-export async function cleanDeadPolicyArtifacts(directory, budget) {
-    let names;
-    try {
-        names = await readdir(directory);
-    }
-    catch {
-        return;
-    }
-    for (const name of gcBatch(names)) {
-        if (budget.signal?.aborted === true || Date.now() >= (budget.deadline ?? Infinity)) {
-            return;
-        }
-        // Bounded GC respects the acquisition budget between native liveness probes.
-        // oxlint-disable-next-line no-await-in-loop
-        await cleanDeadClaim(directory, name, budget);
-    }
-}