pi-agent-browser-native 0.9.2 → 0.9.4

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

@@ -1,5 +1,6 @@
 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*$/;
@@ -8,167 +9,168 @@ 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("'")))) {
+    if (token.length >= 2 &&
+        ((token.startsWith('"') && token.endsWith('"')) ||
+            (token.startsWith("'") && token.endsWith("'")))) {
         return token.slice(1, -1);
     }
     return token;
 }
-function segmentLaunchesAgentBrowser(tokens) {
-    let index = 0;
+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;
     }
-    let executableToken = tokens[index];
-    if (executableToken === "env") {
-        index += 1;
-        while (index < tokens.length && isShellAssignmentToken(tokens[index])) {
-            index += 1;
-        }
-        executableToken = tokens[index] ?? "";
+    if (tokens[index] === "env") {
+        index = skipAssignments(tokens, index + 1);
     }
-    if (executableToken === "npx" || executableToken === "bunx") {
-        index += 1;
-        while (index < tokens.length && tokens[index].startsWith("-")) {
-            index += 1;
-        }
-        executableToken = tokens[index] ?? "";
+    if (tokens[index] === "npx" || tokens[index] === "bunx") {
+        index = skipRunnerOptions(tokens, index + 1);
     }
-    if (executableToken === "pnpm" || executableToken === "yarn") {
-        index += 1;
-        if (tokens[index] !== "dlx") {
+    if (tokens[index] === "pnpm" || tokens[index] === "yarn") {
+        if (tokens[index + 1] !== "dlx") {
             return false;
         }
-        index += 1;
-        while (index < tokens.length && tokens[index].startsWith("-")) {
-            index += 1;
-        }
-        executableToken = tokens[index] ?? "";
+        index = skipRunnerOptions(tokens, index + 2);
     }
-    return DIRECT_AGENT_BROWSER_EXECUTABLE_PATTERN.test(executableToken);
+    return DIRECT_AGENT_BROWSER_EXECUTABLE_PATTERN.test(tokens[index] ?? "");
 }
-// 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) {
-    let currentToken = "";
-    let quoteState;
-    let awaitingHeredocDelimiter;
-    let pendingHeredoc;
-    let pendingHeredocLine = "";
-    let segmentTokens = [];
-    const acceptToken = (token) => {
+/** 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 (awaitingHeredocDelimiter) {
-            pendingHeredoc = {
+        if (this.awaitingHeredocDelimiter) {
+            this.pendingHeredoc = {
                 delimiter: stripOuterQuotes(token),
-                stripTabs: awaitingHeredocDelimiter.stripTabs,
+                stripTabs: this.awaitingHeredocDelimiter.stripTabs,
             };
-            awaitingHeredocDelimiter = undefined;
+            this.awaitingHeredocDelimiter = undefined;
             return;
         }
-        segmentTokens.push(token);
-    };
-    const flushToken = () => {
-        acceptToken(currentToken);
-        currentToken = "";
-    };
-    const flushSegment = () => {
-        const launchesAgentBrowser = segmentLaunchesAgentBrowser(segmentTokens);
-        segmentTokens = [];
-        return launchesAgentBrowser;
-    };
-    for (let index = 0; index < command.length; index += 1) {
+        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 (pendingHeredoc) {
-            if (char === "\n") {
-                const candidate = pendingHeredoc.stripTabs ? pendingHeredocLine.replace(/^\t+/, "") : pendingHeredocLine;
-                if (candidate === pendingHeredoc.delimiter) {
-                    pendingHeredoc = undefined;
-                }
-                pendingHeredocLine = "";
-                continue;
-            }
-            pendingHeredocLine += char;
-            continue;
+        if (this.quoteState === undefined) {
+            return undefined;
         }
-        if (quoteState === "single") {
-            currentToken += char;
-            if (char === "'") {
-                quoteState = undefined;
-            }
-            continue;
+        this.currentToken += char;
+        if (this.quoteState === "double" && char === "\\" && index + 1 < command.length) {
+            this.currentToken += command[index + 1];
+            return index + 1;
         }
-        if (quoteState === "double") {
-            currentToken += char;
-            if (char === "\\" && index + 1 < command.length) {
-                currentToken += command[index + 1];
-                index += 1;
-                continue;
-            }
-            if (char === '"') {
-                quoteState = undefined;
-            }
-            continue;
+        if ((this.quoteState === "single" && char === "'") ||
+            (this.quoteState === "double" && char === '"')) {
+            this.quoteState = undefined;
         }
+        return index;
+    }
+    consumeTokenCharacter(command, index) {
+        const char = command[index];
         if (char === "'" || char === '"') {
-            currentToken += char;
-            quoteState = char === "'" ? "single" : "double";
-            continue;
+            this.currentToken += char;
+            this.quoteState = char === "'" ? "single" : "double";
+            return index;
         }
         if (char === "\\" && index + 1 < command.length) {
-            currentToken += char;
-            currentToken += command[index + 1];
-            index += 1;
-            continue;
-        }
-        if (char === "\n") {
-            flushToken();
-            if (flushSegment()) {
-                return true;
-            }
-            continue;
+            this.currentToken += char + command[index + 1];
+            return index + 1;
         }
-        if (/\s/.test(char)) {
-            flushToken();
-            continue;
+        if (char !== "\n" && /\s/.test(char)) {
+            this.flushToken();
+            return index;
         }
-        const threeCharOperator = command.slice(index, index + 3);
-        if (threeCharOperator === "<<-") {
-            flushToken();
-            awaitingHeredocDelimiter = { stripTabs: true };
-            index += 2;
-            continue;
+        if (command.slice(index, index + 2) === "<<") {
+            this.flushToken();
+            const stripTabs = command[index + 2] === "-";
+            this.awaitingHeredocDelimiter = { stripTabs };
+            return index + (stripTabs ? 2 : 1);
         }
-        const twoCharOperator = command.slice(index, index + 2);
-        if (twoCharOperator === "<<") {
-            flushToken();
-            awaitingHeredocDelimiter = { stripTabs: false };
-            index += 1;
-            continue;
-        }
-        if (twoCharOperator === "&&" || twoCharOperator === "||") {
-            flushToken();
-            if (flushSegment()) {
-                return true;
+        return undefined;
+    }
+    scan(command) {
+        for (let index = 0; index < command.length; index += 1) {
+            if (this.consumeHeredoc(command[index])) {
+                continue;
             }
-            index += 1;
-            continue;
-        }
-        if (char === "|" || char === ";" || char === "&") {
-            flushToken();
-            if (flushSegment()) {
-                return true;
+            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;
             }
-            continue;
+            this.currentToken += command[index];
         }
-        currentToken += char;
+        return this.flushSegment();
     }
-    flushToken();
-    return 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);
@@ -179,12 +181,13 @@ function isTruthyEnvValue(value) {
 async function isPackageDevelopmentCwd(cwd) {
     try {
         const packageJson = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
-        return packageJson.name === PACKAGE_NAME;
+        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);
+    return (isTruthyEnvValue(process.env[DIRECT_AGENT_BROWSER_BASH_BYPASS_ENV]) ||
+        (await isPackageDevelopmentCwd(cwd)));
 }

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

@@ -1,67 +1,131 @@
 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))
+    if (!Array.isArray(data)) {
         return false;
+    }
     return data.some((row, index) => {
-        if (!isRecord(row) || row.success !== true)
+        if (!isRecord(row) || row.success !== true) {
             return false;
-        const rowCommand = Array.isArray(row.command) && row.command.every((token) => typeof token === "string")
-            ? row.command
-            : fallbackCommands[index];
-        return rowCommand ? isCloseAllCommand(extractUpstreamCommandTokens(rowCommand)) : 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))
+    if (!Array.isArray(rows)) {
         return undefined;
-    let sawClose = false;
-    let endsClosed = false;
-    let browserActiveAfterClose = false;
-    let recordingClosedAfterBatch = false;
-    let statePath;
+    }
+    let state;
     for (const [index, row] of rows.entries()) {
-        if (!isRecord(row))
+        const step = lifecycleStep(row, fallbackCommands.at(index));
+        if (step === undefined) {
             continue;
-        const stepSucceeded = row.success === true;
-        const rowCommand = Array.isArray(row.command) && row.command.every((token) => typeof token === "string")
-            ? row.command
-            : fallbackCommands[index];
-        const result = isRecord(row.result) ? row.result : isRecord(row.data) ? row.data : undefined;
-        const lifecycle = isRecord(row.lifecycle) ? row.lifecycle : isRecord(result?.lifecycle) ? result.lifecycle : undefined;
-        const effectiveLaunch = isRecord(lifecycle?.effectiveLaunch) ? lifecycle.effectiveLaunch : undefined;
-        const browserLaunched = typeof effectiveLaunch?.browserLaunched === "boolean" ? effectiveLaunch.browserLaunched : undefined;
-        if (!rowCommand) {
-            if (sawClose && browserLaunched !== false) {
-                endsClosed = false;
-                browserActiveAfterClose = true;
-                recordingClosedAfterBatch = false;
-            }
-            continue;
-        }
-        const [command, subcommand] = extractUpstreamCommandTokens(rowCommand);
-        if (stepSucceeded && isCloseCommand(command)) {
-            sawClose = true;
-            endsClosed = true;
-            browserActiveAfterClose = false;
-            recordingClosedAfterBatch = true;
-            statePath = typeof result?.statePath === "string" ? result.statePath : undefined;
         }
-        else if (sawClose && command === "record") {
-            if (browserLaunched !== false) {
-                endsClosed = false;
-                browserActiveAfterClose = true;
-            }
-            if (stepSucceeded && subcommand === "stop")
-                recordingClosedAfterBatch = true;
-            else if (stepSucceeded && browserActiveAfterClose && (subcommand === "start" || subcommand === "restart"))
-                recordingClosedAfterBatch = false;
+        if (successfulClose(step)) {
+            state = closedState(step);
         }
-        else if (sawClose && browserLaunched !== false) {
-            endsClosed = false;
-            browserActiveAfterClose = true;
+        else if (state !== undefined) {
+            state = advanceClosedState(state, step);
         }
     }
-    return sawClose ? { endsClosed, recordingClosedAfterBatch, statePath } : undefined;
+    return state === undefined
+        ? undefined
+        : {
+            endsClosed: state.endsClosed,
+            recordingClosedAfterBatch: state.recordingClosedAfterBatch,
+            statePath: state.statePath,
+        };
 }

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

@@ -0,0 +1,61 @@
+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;
+    }
+}