pi-agent-browser-native 0.6.16 → 0.7.0

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

@@ -0,0 +1,33 @@
+import { isRecord } from "./parsing.js";
+export const BROWSER_TRANSITION_ENTRY = "agent-browser-transition";
+export const BROWSER_RESULT_TOOLS = new Set([
+    "agent_browser", "agent_browser_code", "agent_browser_action", "agent_browser_qa", "agent_browser_electron",
+    "agent_browser_source", "agent_browser_network_source",
+]);
+/** Direct tools and ordered code calls replay through the same browser state reducers. */
+export function getBrowserResultMessage(entry) {
+    if (!isRecord(entry))
+        return undefined;
+    if (entry.type === "custom" && entry.customType === BROWSER_TRANSITION_ENTRY && isRecord(entry.data)) {
+        return isRecord(entry.data.details) && typeof entry.data.isError === "boolean" ? entry.data : undefined;
+    }
+    const message = entry.type === "message" && isRecord(entry.message) ? entry.message : undefined;
+    return message && typeof message.toolName === "string" && BROWSER_RESULT_TOOLS.has(message.toolName) ? message : undefined;
+}
+// Page data and rendered output are not state. Keep only fields consumed by the
+// existing replay reducers; recording reservations retain their own native journal.
+const TRANSITION_FIELDS = [
+    "args", "command", "subcommand", "sessionName", "namespace", "sessionMode", "usedImplicitSession",
+    "agentBrowserStarted", "resultCategory", "exitCode", "closeAllApplied", "attachedBrowserSession",
+    "sessionTabTarget", "sessionTabTargetUnknown", "sessionTabReopenPending", "refSnapshot", "refSnapshotInvalidation",
+    "readConfirmation", "compatibilityWorkaround", "managedSessionHeadedAutosaveDisabled", "managedSessionHeadedAutosaveInterval",
+    "managedSessionOutcome", "managedSessionCwd", "managedSessionRestoreDisabled", "artifactManifest", "electron", "compiledNetworkSourceLookup",
+];
+export function appendBrowserTransition(pi, toolCallId, details, isError) {
+    const state = Object.fromEntries(TRANSITION_FIELDS.filter(key => details[key] !== undefined).map(key => [key, details[key]]));
+    if (Array.isArray(details.batchSteps))
+        state.batchSteps = details.batchSteps.filter(isRecord).map(step => ({
+            command: step.command, success: step.success, lifecycle: step.lifecycle,
+        }));
+    pi.appendEntry(BROWSER_TRANSITION_ENTRY, { toolCallId, details: state, isError });
+}

package/dist/extensions/agent-browser/lib/command-taxonomy.js

@@ -316,9 +316,9 @@ export function isSessionTabPinningExcludedCommand(command) {
 export function isSessionTabPostCommandCorrectionExcludedCommand(command) {
     return hasCommandCapability(command, "excludedFromPostCommandCorrection");
 }
-export function getRecordCommandOperands(tokens) {
+export function getRecordCommandOperandIndices(tokens) {
     if (tokens[0] !== "record" || !["start", "restart"].includes(tokens[1] ?? ""))
-        return {};
+        return [];
     const operands = [];
     for (let index = 2; index < tokens.length && operands.length < 2; index += 1) {
         // Native validates the range; bare/non-numeric --fps keeps its old literal meaning.
@@ -329,9 +329,13 @@ export function getRecordCommandOperands(tokens) {
         else if (tokens[index] === "--contact-sheet-threshold" && tokens[index + 1] !== undefined)
             index += 1;
         else
-            operands.push(tokens[index]);
+            operands.push(index);
     }
-    return operands.length > 0 ? { path: operands[0], url: operands[1] } : { path: tokens[2], url: tokens[3] };
+    return operands.length > 0 ? operands : [2, 3];
+}
+export function getRecordCommandOperands(tokens) {
+    const [path, url] = getRecordCommandOperandIndices(tokens);
+    return path === undefined ? {} : { path: tokens[path], url: url === undefined ? undefined : tokens[url] };
 }
 /** Starts conservatively invalidate refs because older supported natives replace the page, even on failure. Restarts invalidate only when they have a URL. */
 export function isRecordPageTransitionCommand(tokens) {

package/dist/extensions/agent-browser/lib/execution-cwd.js

@@ -0,0 +1,66 @@
+import { readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import { isRecord } from "./parsing.js";
+import { getBrowserResultMessage } from "./browser-transcript.js";
+import { getAgentBrowserSessionIdentityKey } from "./argv-grammar.js";
+function isDirectoryOwner(source) {
+    if (/^(?:npm:pi-change-working-dir|git:github\.com\/fitchmultz\/pi-change-working-dir(?:\.git)?)(?:@.+)?$/.test(source.source))
+        return true;
+    const directories = [source.baseDir, isAbsolute(source.path) ? dirname(source.path) : undefined];
+    return directories.some(directory => {
+        if (!directory || !isAbsolute(directory))
+            return false;
+        try {
+            return JSON.parse(readFileSync(join(directory, "package.json"), "utf8")).name === "pi-change-working-dir";
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** The synchronous owner reply is captured before any browser policy, queue, or child await. */
+export function resolveExecutionCwd(pi, ctx) {
+    const request = { sessionManager: ctx.sessionManager };
+    pi.events.emit("pi-change-working-dir:resolve-execution-cwd", request);
+    const result = request.result;
+    if (result !== undefined) {
+        const invalid = "pi-change-working-dir returned an invalid execution directory. Update the extension and restart Pi.";
+        if (!isRecord(result) || Array.isArray(result))
+            throw new Error(invalid);
+        if (result.error !== undefined)
+            throw new Error(typeof result.error === "string" && result.error.length > 0 ? result.error : invalid);
+        if (typeof result.cwd !== "string" || !isAbsolute(result.cwd) || result.cwd.includes("\0"))
+            throw new Error(invalid);
+        return result.cwd;
+    }
+    if (pi.getAllTools().some(tool => tool.name === "change_dir" && isDirectoryOwner(tool.sourceInfo))
+        || pi.getCommands().some(command => /^cwd(?::\d+)?$/.test(command.name) && isDirectoryOwner(command.sourceInfo))) {
+        throw new Error("Update pi-change-working-dir and restart Pi to use agent_browser with the selected working directory.");
+    }
+    return ctx.cwd;
+}
+export function getBrowserCwdError(cwd) {
+    try {
+        if (statSync(cwd).isDirectory())
+            return undefined;
+    }
+    catch (error) {
+        if (!["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
+            throw error;
+    }
+    return `Browser launch directory is unavailable: ${cwd}. Restore that directory, or explicitly use sessionMode: "fresh" without --session, or --config from the selected execution directory. The existing browser was left untouched.`;
+}
+export function restoreManagedSessionCwd(branch, sessionName, namespace, fallback) {
+    const key = getAgentBrowserSessionIdentityKey(sessionName, namespace);
+    for (const entry of [...branch].reverse()) {
+        const message = getBrowserResultMessage(entry);
+        if (!message)
+            continue;
+        const details = message.details;
+        if (!isRecord(details) || typeof details.sessionName !== "string" || typeof details.managedSessionCwd !== "string" || !isAbsolute(details.managedSessionCwd))
+            continue;
+        if (getAgentBrowserSessionIdentityKey(details.sessionName, typeof details.namespace === "string" ? details.namespace : undefined) === key)
+            return details.managedSessionCwd;
+    }
+    return fallback;
+}

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

@@ -1,218 +1,7 @@
 import { isRecord } from "../parsing.js";
 import { summarizeNetworkFailures } from "../results/network.js";
-import { getBatchResultItems, getCommandNameFromBatchItem, getSelectValues } from "./shared.js";
-import { compileAgentBrowserSemanticAction } from "./semantic-action.js";
-import { AGENT_BROWSER_JOB_STEP_ACTIONS, AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS, AGENT_BROWSER_QA_LOAD_STATES, } from "./types.js";
-function getRequiredJobString(step, field, action) {
-    const value = step[field];
-    if (typeof value !== "string" || value.trim().length === 0) {
-        return { error: `job step ${action} requires a non-empty ${field} string.` };
-    }
-    return { value };
-}
-function compileJobClickOrFillStep(step, action) {
-    const hasSelector = typeof step.selector === "string" && step.selector.trim().length > 0;
-    const hasLocator = step.locator !== undefined || step.role !== undefined || step.name !== undefined || step.value !== undefined;
-    if (hasSelector && hasLocator) {
-        return { error: `job step ${action} must use either selector or semantic locator fields, not both.` };
-    }
-    if (hasSelector) {
-        if (action === "click")
-            return { args: ["click", step.selector] };
-        const text = getRequiredJobString(step, "text", action);
-        if (text.error)
-            return { error: text.error };
-        return { args: ["fill", step.selector, text.value] };
-    }
-    if (!hasLocator) {
-        return { error: `job step ${action} requires either a non-empty selector string or semantic locator fields.` };
-    }
-    const compiled = compileAgentBrowserSemanticAction({
-        action,
-        locator: step.locator,
-        name: step.name,
-        role: step.role,
-        text: step.text,
-        value: step.value,
-    });
-    if (compiled.error)
-        return { error: compiled.error.replaceAll("semanticAction", `job step ${action}`) };
-    return { args: compiled.compiled?.args };
-}
-function getUnsupportedJobStepField(step, allowedFields) {
-    return Object.keys(step).find((field) => !allowedFields.has(field));
-}
-function getUnsupportedJobStepFieldError(step, action, allowedFields) {
-    const unsupportedField = getUnsupportedJobStepField(step, allowedFields);
-    if (!unsupportedField)
-        return undefined;
-    const supportedFields = [...allowedFields].filter((field) => field !== "action");
-    const supportedText = supportedFields.length > 0 ? `supported fields are ${supportedFields.join(", ")}.` : "no additional fields are supported.";
-    return `job step ${action} does not support ${unsupportedField}; ${supportedText}`;
-}
-const JOB_STEP_ALLOWED_FIELDS = {
-    assertText: new Set(["action", "text"]),
-    assertUrl: new Set(["action", "url"]),
-    click: new Set(["action", "locator", "name", "role", "selector", "value"]),
-    fill: new Set(["action", "locator", "name", "role", "selector", "text", "value"]),
-    open: new Set(["action", "loadState", "url"]),
-    screenshot: new Set(["action", "path"]),
-    select: new Set(["action", "selector", "value", "values"]),
-    snapshot: new Set(["action"]),
-    type: new Set(["action", "delayMs", "press", "selector", "text"]),
-    wait: new Set(["action", "milliseconds"]),
-    waitForDownload: new Set(["action", "path"]),
-};
-function compileJobTypeSteps(step) {
-    const text = getRequiredJobString(step, "text", "type");
-    if (text.error)
-        return { error: text.error };
-    const selector = step.selector;
-    if (selector !== undefined && (typeof selector !== "string" || selector.trim().length === 0)) {
-        return { error: "job step type selector must be a non-empty string when provided." };
-    }
-    const delayMs = step.delayMs;
-    if (delayMs !== undefined && (typeof delayMs !== "number" || !Number.isInteger(delayMs) || delayMs <= 0)) {
-        return { error: "job step type delayMs must be a positive integer when provided." };
-    }
-    const press = step.press;
-    if (press !== undefined && (typeof press !== "string" || press.trim().length === 0)) {
-        return { error: "job step type press must be a non-empty key string when provided." };
-    }
-    const typedText = text.value;
-    const typedChars = Array.from(typedText);
-    if (typedChars.length === 0)
-        return { error: "job step type requires non-empty text." };
-    if (delayMs !== undefined && typedChars.length > AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS) {
-        return { error: `job step type delayMs supports at most ${AGENT_BROWSER_JOB_TYPE_DELAYED_TEXT_MAX_CHARACTERS} characters; split longer text into shorter calls or omit delayMs.` };
-    }
-    const compiledSteps = [];
-    if (delayMs === undefined) {
-        compiledSteps.push({ action: "type", args: typeof selector === "string" ? ["type", selector, typedText] : ["keyboard", "type", typedText] });
-    }
-    else {
-        if (typeof selector === "string")
-            compiledSteps.push({ action: "type", args: ["focus", selector], generatedFrom: "type.selector" });
-        for (const [index, char] of typedChars.entries()) {
-            compiledSteps.push({ action: "type", args: ["keyboard", "type", char], generatedFrom: "type.delayMs" });
-            if (index < typedChars.length - 1)
-                compiledSteps.push({ action: "wait", args: ["wait", String(delayMs)], generatedFrom: "type.delayMs" });
-        }
-    }
-    if (typeof press === "string")
-        compiledSteps.push({ action: "type", args: ["press", press], generatedFrom: "type.press" });
-    return { steps: compiledSteps };
-}
-function compileOpenJobStep(step, index) {
-    const result = getRequiredJobString(step, "url", "open");
-    if (result.error)
-        return { error: result.error };
-    const extraSteps = [];
-    if (step.loadState !== undefined) {
-        if (typeof step.loadState !== "string" || !AGENT_BROWSER_QA_LOAD_STATES.includes(step.loadState)) {
-            return { error: `job.steps[${index}].loadState must be one of: ${AGENT_BROWSER_QA_LOAD_STATES.join(", ")}.` };
-        }
-        extraSteps.push({ action: "wait", args: ["wait", "--load", step.loadState], generatedFrom: "open.loadState" });
-    }
-    return { args: ["open", result.value], extraSteps };
-}
-function compileClickJobStep(step) {
-    return compileJobClickOrFillStep(step, "click");
-}
-function compileFillJobStep(step) {
-    return compileJobClickOrFillStep(step, "fill");
-}
-function compileTypeJobStep(step) {
-    const result = compileJobTypeSteps(step);
-    if (result.error)
-        return { error: result.error };
-    const [firstStep, ...extraSteps] = result.steps;
-    return { args: firstStep.args, extraSteps, generatedFrom: firstStep.generatedFrom };
-}
-function compileSelectJobStep(step, index) {
-    const selector = getRequiredJobString(step, "selector", "select");
-    if (selector.error)
-        return { error: selector.error };
-    const values = getSelectValues(step, `job.steps[${index}]`);
-    if (values.error)
-        return { error: values.error };
-    return { args: ["select", selector.value, ...values.values] };
-}
-function compileWaitJobStep(step) {
-    const milliseconds = step.milliseconds;
-    if (typeof milliseconds !== "number" || !Number.isInteger(milliseconds) || milliseconds <= 0) {
-        return { error: "job step wait requires a positive integer milliseconds value." };
-    }
-    return { args: ["wait", String(milliseconds)] };
-}
-function compileAssertTextJobStep(step) {
-    const result = getRequiredJobString(step, "text", "assertText");
-    if (result.error)
-        return { error: result.error };
-    return { args: ["wait", "--text", result.value] };
-}
-function compileAssertUrlJobStep(step) {
-    const result = getRequiredJobString(step, "url", "assertUrl");
-    if (result.error)
-        return { error: result.error };
-    return { args: ["wait", "--url", result.value] };
-}
-function compilePathArtifactJobStep(step, action) {
-    const result = getRequiredJobString(step, "path", action);
-    if (result.error)
-        return { error: result.error };
-    return { args: action === "waitForDownload" ? ["wait", "--download", result.value] : ["screenshot", result.value] };
-}
-// ponytail: allowedFields for each action live in JOB_STEP_ALLOWED_FIELDS (same key
-// alignment enforced by Record<AgentBrowserJobStepAction, …>), so the compiler map no
-// longer mirrors that set per entry; the call site looks it up by action.
-const JOB_STEP_COMPILERS = {
-    assertText: compileAssertTextJobStep,
-    assertUrl: compileAssertUrlJobStep,
-    click: compileClickJobStep,
-    fill: compileFillJobStep,
-    open: compileOpenJobStep,
-    screenshot: (step) => compilePathArtifactJobStep(step, "screenshot"),
-    select: compileSelectJobStep,
-    snapshot: () => ({ args: ["snapshot", "-i"] }),
-    type: compileTypeJobStep,
-    wait: compileWaitJobStep,
-    waitForDownload: (step) => compilePathArtifactJobStep(step, "waitForDownload"),
-};
-export function compileAgentBrowserJob(input) {
-    if (!isRecord(input)) {
-        return { error: "job must be an object." };
-    }
-    const rawFailFast = input.failFast;
-    if (rawFailFast !== undefined && typeof rawFailFast !== "boolean") {
-        return { error: "job.failFast must be a boolean when provided." };
-    }
-    const failFast = rawFailFast !== false;
-    const rawSteps = input.steps;
-    if (!Array.isArray(rawSteps) || rawSteps.length === 0) {
-        return { error: "job.steps must be a non-empty array." };
-    }
-    const steps = [];
-    for (const [index, rawStep] of rawSteps.entries()) {
-        if (!isRecord(rawStep)) {
-            return { error: `job.steps[${index}] must be an object.` };
-        }
-        const action = rawStep.action;
-        if (typeof action !== "string" || !AGENT_BROWSER_JOB_STEP_ACTIONS.includes(action)) {
-            return { error: `job.steps[${index}].action must be one of: ${AGENT_BROWSER_JOB_STEP_ACTIONS.join(", ")}.` };
-        }
-        const jobAction = action;
-        const compile = JOB_STEP_COMPILERS[jobAction];
-        const unsupportedFieldError = getUnsupportedJobStepFieldError(rawStep, jobAction, JOB_STEP_ALLOWED_FIELDS[jobAction]);
-        if (unsupportedFieldError)
-            return { error: `job.steps[${index}]: ${unsupportedFieldError}` };
-        const compiledStep = compile(rawStep, index);
-        if (compiledStep.error)
-            return { error: compiledStep.error.startsWith(`job.steps[${index}]`) ? compiledStep.error : `job.steps[${index}]: ${compiledStep.error}` };
-        steps.push({ action: jobAction, args: compiledStep.args, generatedFrom: compiledStep.generatedFrom }, ...(compiledStep.extraSteps ?? []));
-    }
-    return { compiled: { args: failFast ? ["batch", "--bail"] : ["batch"], failFast, stdin: JSON.stringify(steps.map((step) => step.args)), steps } };
-}
+import { getBatchResultItems, getCommandNameFromBatchItem } from "./shared.js";
+import { AGENT_BROWSER_QA_LOAD_STATES, } from "./types.js";
 function describeQaChecksRun(checks) {
     const parts = [`load:${checks.loadState}`];
     if (checks.expectedText.length > 0)

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

@@ -232,7 +232,7 @@ export async function analyzeSourceLookupResults(data, compiled, cwd, context) {
     const electronContext = status === "no-candidates" ? context?.electronContext : undefined;
     const workspaceRoot = context?.workspaceRoot ?? cwd;
     if (electronContext) {
-        limitations.push(`Workspace source scan is limited to the Pi tool session cwd: ${workspaceRoot}.`, "Packaged Electron app code may live inside installed app resources or app.asar outside the workspace; the wrapper does not unpack asar files or scan app bundle resources.");
+        limitations.push(`Workspace source scan is limited to the captured execution directory: ${workspaceRoot}.`, "Packaged Electron app code may live inside installed app resources or app.asar outside the workspace; the wrapper does not unpack asar files or scan app bundle resources.");
     }
     return {
         candidates,