pi-agent-browser-native 0.9.5 → 0.9.6

package/dist/extensions/agent-browser/lib/browser-journal-replay.js

@@ -1,246 +0,0 @@
-import { constants } from "node:fs";
-import { open, stat } from "node:fs/promises";
-import { BROWSER_TRANSITION_ENTRY, BROWSER_RESULT_TOOLS, applyArtifactChanges, getBrowserRecord, snapshotFromDefinition, } from "./browser-transcript.js";
-import { isRecord } from "./parsing.js";
-import { getErrorCode } from "./process-errors.js";
-import { projectJson, readRange, scanJournalMetadata, } from "./browser-journal-reader.js";
-const REPLAY_CUSTOM_TYPES = new Set([
-    BROWSER_TRANSITION_ENTRY,
-    "agent-browser-recording-reservation",
-    "agent-browser-script-session",
-]);
-function branchEntries(entries, selectedLeaf) {
-    const byId = new Map();
-    for (const entry of entries) {
-        const id = entry.value.id;
-        if (typeof id !== "string" || byId.has(id)) {
-            throw new Error("Journal has a missing or duplicate native entry identity.");
-        }
-        byId.set(id, entry);
-    }
-    const branch = [];
-    const seen = new Set();
-    let leaf = selectedLeaf;
-    while (leaf !== null) {
-        if (seen.has(leaf)) {
-            throw new Error("Journal ancestry contains a cycle.");
-        }
-        seen.add(leaf);
-        const entry = byId.get(leaf);
-        if (!entry) {
-            throw new Error(`Selected journal entry ${leaf} is not persisted; browser work requires a committed conversation.`);
-        }
-        const parent = entry.value.parentId;
-        if (parent !== null && typeof parent !== "string") {
-            throw new Error("Invalid journal parent identity.");
-        }
-        branch.push(entry);
-        leaf = parent;
-    }
-    return branch.reverse();
-}
-function canonicalVersion(entry) {
-    return isRecord(entry.data) && isRecord(entry.data.event) && entry.data.event.version === 1;
-}
-function legacyCustom(entry) {
-    return (entry.type === "custom" &&
-        (entry.customType === BROWSER_TRANSITION_ENTRY ||
-            entry.customType === "agent-browser-script-session") &&
-        !canonicalVersion(entry));
-}
-function browserMessage(entry) {
-    const message = isRecord(entry.message) ? entry.message : undefined;
-    return message &&
-        typeof message.toolName === "string" &&
-        BROWSER_RESULT_TOOLS.has(message.toolName)
-        ? message
-        : undefined;
-}
-function legacyBrowserResult(entry) {
-    const message = browserMessage(entry);
-    if (!message ||
-        !isRecord(message.details) ||
-        message.details.browserEventVersion === 1 ||
-        canonicalVersion(entry)) {
-        return false;
-    }
-    return (message.details.sessionName !== undefined ||
-        message.details.artifactManifest !== undefined ||
-        message.details.electron !== undefined);
-}
-function validateMemoryEntry(entry) {
-    if (!isRecord(entry)) {
-        return;
-    }
-    if (legacyCustom(entry) && !getBrowserRecord(entry)) {
-        throw new Error("Legacy browser records require stopped separate-copy conversion before replay.");
-    }
-    const message = browserMessage(entry);
-    if (entry.type === "message" &&
-        message &&
-        isRecord(message.details) &&
-        message.details.browserEventVersion !== 1 &&
-        !getBrowserRecord(entry)) {
-        throw new Error("Legacy browser observations require stopped separate-copy conversion before replay.");
-    }
-}
-function inMemoryEntries(manager, physical) {
-    const entries = physical ? manager.getEntries() : [];
-    if (!physical) {
-        const seen = new Set();
-        let leaf = manager.getLeafId();
-        while (leaf !== null) {
-            if (seen.has(leaf)) {
-                throw new Error("In-memory journal ancestry contains a cycle.");
-            }
-            seen.add(leaf);
-            const entry = manager.getEntry(leaf);
-            if (!isRecord(entry) || (entry.parentId !== null && typeof entry.parentId !== "string")) {
-                throw new Error("In-memory journal ancestry is incomplete.");
-            }
-            entries.push(entry);
-            leaf = entry.parentId;
-        }
-        entries.reverse();
-    }
-    for (const entry of entries) {
-        validateMemoryEntry(entry);
-    }
-    return entries;
-}
-class PublishedJournalReplay {
-    file;
-    projected = [];
-    definitions = new Map();
-    constructor(file) {
-        this.file = file;
-    }
-    async project(entries) {
-        for (const entry of entries) {
-            // Preserve journal order and bound selected envelope memory during replay.
-            // oxlint-disable-next-line no-await-in-loop
-            await this.projectEntry(entry);
-        }
-    }
-    async projectEntry(entry) {
-        const { value } = entry;
-        const definition = isRecord(value.data) && isRecord(value.data.snapshot) ? value.data.snapshot.id : undefined;
-        if (typeof definition === "string") {
-            if (this.definitions.has(definition)) {
-                throw new Error("Browser snapshot identity is defined more than once on this ancestry.");
-            }
-            this.definitions.set(definition, entry);
-        }
-        if (legacyCustom(value) || legacyBrowserResult(value)) {
-            throw new Error("This session contains legacy browser records. Convert a stopped separate copy with npm exec --package pi-agent-browser-native -- pi-agent-browser-convert before resuming browser work; the original journal is retained.");
-        }
-        if (!replayRelevant(value, definition)) {
-            return;
-        }
-        const fields = value.customType === BROWSER_TRANSITION_ENTRY || value.type === "message"
-            ? [
-                ["data", "event"],
-                ["data", "snapshot", "id"],
-            ]
-            : [["data"]];
-        const body = await projectJson(readRange(this.file, entry), fields);
-        this.projected.push({ ...value, ...body });
-    }
-    async resolveWinningDefinitions(physical) {
-        const { SessionPageState } = await import("./session-page-state.js");
-        const reduced = SessionPageState.fromBranch(this.projected);
-        const winners = new Set((physical ? [] : [...reduced.views().values()]).flatMap((page) => page.refSnapshot?.snapshotId !== undefined && page.refSnapshot.snapshotId.length > 0
-            ? [page.refSnapshot.snapshotId]
-            : []));
-        for (const id of winners) {
-            // Each winning snapshot is materialized once, without retaining unrelated historical ref maps.
-            // oxlint-disable-next-line no-await-in-loop
-            await this.resolveDefinition(id);
-        }
-        let manifest;
-        for (const entry of this.projected) {
-            manifest = applyArtifactChanges(manifest, getBrowserRecord(entry)?.event.artifacts);
-        }
-        return this.projected;
-    }
-    async resolveDefinition(id) {
-        const entry = this.definitions.get(id);
-        if (!entry) {
-            throw new Error(`Browser snapshot ${id} has no ancestral definition; inspect and take a fresh snapshot.`);
-        }
-        // ponytail: a requested individual snapshot must fit the consumer's memory; upgrade with native per-value paging if needed.
-        const body = await projectJson(readRange(this.file, entry), [["data", "snapshot"]], Infinity);
-        const destination = this.projected.find((candidate) => isRecord(candidate) && candidate.id === entry.value.id);
-        if (!isRecord(destination) || !isRecord(destination.data) || !isRecord(body?.data)) {
-            throw new Error("Winning browser snapshot could not be read.");
-        }
-        destination.data.snapshot = body.data.snapshot;
-        if (!isRecord(body.data.snapshot) || body.data.snapshot.id !== id) {
-            throw new Error("Winning browser snapshot identity is invalid.");
-        }
-        snapshotFromDefinition(body.data.snapshot);
-    }
-}
-function replayRelevant(value, definition) {
-    return ((value.type === "custom" &&
-        typeof value.customType === "string" &&
-        REPLAY_CUSTOM_TYPES.has(value.customType)) ||
-        (isRecord(value.data) && isRecord(value.data.event)) ||
-        definition !== undefined);
-}
-async function verifyCapturedFile(file, path, captured) {
-    const current = await file.stat();
-    const currentPath = await stat(path);
-    if (current.dev !== captured.dev ||
-        current.ino !== captured.ino ||
-        current.size < captured.size ||
-        currentPath.dev !== captured.dev ||
-        currentPath.ino !== captured.ino) {
-        throw new Error("Pi journal replaced or truncated during replay.");
-    }
-}
-function validateJournalHeader(metadata, sessionId) {
-    const header = metadata.find((entry) => entry.value.type === "session");
-    if (header?.value.id !== sessionId) {
-        throw new Error("Pi session journal identity does not match the active session.");
-    }
-}
-async function openPublishedJournal(path) {
-    try {
-        return await open(path, constants.O_RDONLY);
-    }
-    catch (error) {
-        if (getErrorCode(error) === "ENOENT") {
-            return undefined;
-        }
-        throw error;
-    }
-}
-export async function readBrowserEntries(manager, physical = false) {
-    const path = manager.getSessionFile();
-    if (path === undefined || path.length === 0) {
-        return inMemoryEntries(manager, physical);
-    }
-    const leaf = physical ? null : manager.getLeafId();
-    const file = await openPublishedJournal(path);
-    if (!file) {
-        return inMemoryEntries(manager, physical);
-    }
-    try {
-        const captured = await file.stat();
-        if (!captured.isFile()) {
-            throw new Error("Pi session journal is not a regular file.");
-        }
-        const metadata = await scanJournalMetadata(file, captured.size);
-        validateJournalHeader(metadata, manager.getHeader()?.id ?? manager.getSessionId());
-        const records = metadata.filter((entry) => entry.value.type !== "session");
-        const replay = new PublishedJournalReplay(file);
-        await replay.project(physical ? records : branchEntries(records, leaf));
-        const entries = await replay.resolveWinningDefinitions(physical);
-        await verifyCapturedFile(file, path, captured);
-        return entries;
-    }
-    finally {
-        await file.close();
-    }
-}

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

@@ -1,148 +0,0 @@
-import { constants, openSync, closeSync, fstatSync } from "node:fs";
-import { open, stat } from "node:fs/promises";
-import { BROWSER_TRANSITION_ENTRY } from "./browser-transcript-contracts.js";
-import { isRecord } from "./parsing.js";
-import { journalRanges, projectJson, readRange } from "./browser-journal-reader.js";
-export { journalRanges, projectJson, readRange, scanJournalMetadata, } from "./browser-journal-reader.js";
-export { readBrowserEntries } from "./browser-journal-replay.js";
-/** A filename is not durability evidence on official Pi before its first conversation. */
-export function requirePublishedBrowserJournal(manager) {
-    const path = manager.getSessionFile();
-    if (path === undefined || path.length === 0) {
-        throw new Error("Browser code requires a published Pi conversation; relaunch without --no-session.");
-    }
-    let fd;
-    try {
-        fd = openSync(path, constants.O_RDONLY);
-        const entry = fstatSync(fd);
-        if (!entry.isFile() || entry.size === 0) {
-            throw new Error("Pi conversation has not been published yet.");
-        }
-    }
-    catch (error) {
-        throw new Error("Browser work requires an actually published Pi conversation before dispatch; send a user message first.", { cause: error });
-    }
-    finally {
-        if (fd !== undefined) {
-            closeSync(fd);
-        }
-    }
-}
-/** Observation-only artifact receipts are optional until Pi publishes its journal. */
-export function hasPublishedBrowserJournal(manager) {
-    try {
-        requirePublishedBrowserJournal(manager);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export { captureBrowserBranch } from "./browser-journal-branch.js";
-const RECEIPT_FIELDS = [
-    ["type"],
-    ["id"],
-    ["customType"],
-    ...["version", "operationId", "phase", "toolCallId", "commandIndex"].map((field) => [
-        "data",
-        "event",
-        field,
-    ]),
-];
-function matchesReceipt(value, receipt) {
-    if (value.id !== receipt.nativeId ||
-        value.type !== "custom" ||
-        value.customType !== BROWSER_TRANSITION_ENTRY ||
-        !isRecord(value.data) ||
-        !isRecord(value.data.event)) {
-        return false;
-    }
-    const event = value.data.event;
-    const expected = receipt.expected.event;
-    const identity = {
-        operationId: expected.operationId,
-        phase: expected.phase,
-        toolCallId: expected.toolCallId,
-        commandIndex: expected.commandIndex,
-    };
-    return (event.version === 1 &&
-        Object.entries(identity).every(([key, fieldValue]) => event[key] === fieldValue));
-}
-async function countPublishedReceipts(file, journal, receipt) {
-    let matches = 0;
-    for await (const range of journalRanges(file, journal.after.size, false, journal.start)) {
-        const value = await projectJson(readRange(file, range), RECEIPT_FIELDS);
-        if (!value) {
-            continue;
-        }
-        if (value.type === "session" && value.id !== journal.sessionId) {
-            throw new Error("Pi repaired journal identity differs from the active session.");
-        }
-        if (matchesReceipt(value, receipt)) {
-            matches++;
-        }
-    }
-    return matches;
-}
-function appendToBranch(manager, append, branch) {
-    append();
-    if (branch.anchorId === null) {
-        branch.anchorId = manager.getLeafId();
-    }
-}
-async function verifyAppend(file, path, before, receipt) {
-    const after = await file.stat();
-    const sameFile = after.dev === before.dev && after.ino === before.ino;
-    if (!after.isFile() || (sameFile && after.size <= before.size)) {
-        throw new Error("Pi did not publish the browser event.");
-    }
-    const matches = await countPublishedReceipts(file, { after, start: sameFile ? before.size : 0, sessionId: receipt.sessionId }, receipt);
-    const current = await stat(path);
-    if (matches !== 1 ||
-        current.dev !== after.dev ||
-        current.ino !== after.ino ||
-        current.size < after.size) {
-        throw new Error("Pi browser append has no matching published journal receipt.");
-    }
-}
-async function appendPublishedRecord(manager, path, operation) {
-    const beforeFile = await open(path, constants.O_RDONLY);
-    let file;
-    try {
-        const before = await beforeFile.stat();
-        // Native navigation changes the leaf before its awaited session_tree handlers.
-        if (!operation.branch.isCurrent()) {
-            return false;
-        }
-        appendToBranch(manager, operation.append, operation.branch);
-        const nativeId = manager.getLeafId();
-        // Native repair may flush several records or replace the file. Reopen and frame the actual journal.
-        file = await open(path, constants.O_RDONLY);
-        await verifyAppend(file, path, before, {
-            nativeId,
-            expected: operation.expected,
-            sessionId: manager.getHeader()?.id ?? manager.getSessionId(),
-        });
-    }
-    finally {
-        await file?.close();
-        await beforeFile.close();
-    }
-    return operation.branch.isCurrent();
-}
-/** A withdrawn branch returns false; required publication faults still throw. */
-export async function appendBrowserRecord(manager, append, expected, branch) {
-    if ((manager.getSessionFile() ?? "").length === 0) {
-        if (!branch.isCurrent()) {
-            return false;
-        }
-        appendToBranch(manager, append, branch);
-        return branch.isCurrent();
-    }
-    requirePublishedBrowserJournal(manager);
-    const path = manager.getSessionFile();
-    if (path === undefined || path.length === 0) {
-        throw new Error("Pi conversation has no published journal locator.");
-    }
-    return appendPublishedRecord(manager, path, { append, expected, branch });
-}

package/dist/extensions/agent-browser/lib/browser-legacy-pages.js

@@ -1,220 +0,0 @@
-import { createHash } from "node:crypto";
-import { snapshotDefinition, } from "./browser-transcript.js";
-import { browserStringArray } from "./browser-value-parsing.js";
-import { isRecord } from "./parsing.js";
-import { isReadOnlyDiagnosticSessionTargetCommand } from "./command-taxonomy.js";
-import { normalizeSessionTabTarget, extractSessionTabTargetFromBatchResults, isNoActivePageSnapshotFailure, buildNoActivePageRefSnapshotInvalidation, } from "./session-page-observation.js";
-function legacyTarget(value) {
-    return normalizeSessionTabTarget({
-        url: typeof value.url === "string" ? value.url : undefined,
-        title: typeof value.title === "string" ? value.title : undefined,
-        targetId: typeof value.targetId === "string" ? value.targetId : undefined,
-    });
-}
-function legacySnapshot(value, id) {
-    if (!isRecord(value) || !Array.isArray(value.refIds)) {
-        return undefined;
-    }
-    const refIds = browserStringArray(value.refIds).filter((ref) => /^e\d+$/.test(ref));
-    const sourceRefs = isRecord(value.refs) ? value.refs : {};
-    return snapshotDefinition({
-        snapshotId: typeof value.snapshotId === "string" ? value.snapshotId : id,
-        refIds,
-        generation: typeof value.generation === "string" ? value.generation : undefined,
-        refs: Object.fromEntries(refIds.flatMap((refId) => {
-            const ref = sourceRefs[refId];
-            if (!isRecord(ref) || typeof ref.name !== "string" || typeof ref.role !== "string") {
-                return [];
-            }
-            return [
-                [
-                    refId,
-                    {
-                        name: ref.name,
-                        role: ref.role,
-                        ...(typeof ref.isEditable === "boolean" ? { isEditable: ref.isEditable } : {}),
-                        ...(typeof ref.isContentEditable === "boolean"
-                            ? { isContentEditable: ref.isContentEditable }
-                            : {}),
-                    },
-                ],
-            ];
-        })),
-        target: isRecord(value.target) ? legacyTarget(value.target) : undefined,
-    });
-}
-function snapshotDigest(definition) {
-    return createHash("sha256")
-        .update(JSON.stringify({
-        refs: definition.refs,
-        target: definition.target,
-        generation: definition.generation,
-    }))
-        .digest("hex");
-}
-export function canonicalPage(prior, canonical, page) {
-    const definition = isRecord(canonical.snapshot) ? canonical.snapshot : undefined;
-    const digest = definition !== undefined && Boolean(definition.refs)
-        ? snapshotDigest(definition)
-        : (prior.snapshot?.digest ?? "");
-    let snapshot;
-    if (page.refs.kind === "replace" || page.refs.kind === "reuse") {
-        snapshot = { id: page.refs.snapshotId, digest, usable: true, candidate: false };
-    }
-    else if (prior.snapshot) {
-        snapshot = { ...prior.snapshot, usable: false, candidate: canonical.event.phase === "begin" };
-    }
-    return {
-        target: page.target,
-        unknown: page.unknown,
-        reopenPending: page.reopenPending,
-        snapshot,
-        pending: canonical.event.phase === "begin"
-            ? {
-                operationId: canonical.event.operationId,
-                toolCallId: canonical.event.toolCallId,
-                index: canonical.event.commandIndex,
-            }
-            : undefined,
-    };
-}
-function parseInvalidation(value, fallbackSummary) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    if (value.reason !== "no-active-page" && value.reason !== "page-transition") {
-        throw new Error("Invalid legacy browser ref invalidation.");
-    }
-    if (typeof value.summary === "string") {
-        return { reason: value.reason, summary: value.summary };
-    }
-    if (fallbackSummary) {
-        return {
-            reason: value.reason,
-            summary: "The prior refs were invalidated; take a fresh snapshot.",
-        };
-    }
-    throw new Error("Invalid legacy browser ref invalidation summary.");
-}
-function observedInvalidation(ctx) {
-    const value = ctx.details.refSnapshotInvalidation;
-    if (isRecord(value) &&
-        (value.reason === "no-active-page" || value.reason === "page-transition")) {
-        return parseInvalidation(value, true);
-    }
-    let error;
-    if (typeof ctx.details.error === "string") {
-        error = ctx.details.error;
-    }
-    else if (typeof ctx.details.summary === "string") {
-        error = ctx.details.summary;
-    }
-    return isNoActivePageSnapshotFailure(ctx.command, error)
-        ? buildNoActivePageRefSnapshotInvalidation()
-        : undefined;
-}
-function snapshotReusable(page, details, digest) {
-    return (page.snapshot?.digest === digest &&
-        (page.snapshot.usable || page.snapshot.candidate) &&
-        (!isRecord(details.refSnapshot) ||
-            typeof details.refSnapshot.snapshotId !== "string" ||
-            details.refSnapshot.snapshotId === page.snapshot.id));
-}
-/** One legacy entry owns a shallow page draft; previous snapshots and parent views are never mutated. */
-export class LegacyPageConversion {
-    ctx;
-    page;
-    definition;
-    constructor(ctx, prior) {
-        this.ctx = ctx;
-        this.page = { ...prior };
-    }
-    knownTarget() {
-        const { details, command, subcommand } = this.ctx;
-        if (!isRecord(details.compiledNetworkSourceLookup) &&
-            !isReadOnlyDiagnosticSessionTargetCommand(command, subcommand) &&
-            isRecord(details.sessionTabTarget)) {
-            this.page.target = legacyTarget(details.sessionTabTarget) ?? this.page.target;
-        }
-        else if (command === "batch" && !isRecord(details.compiledNetworkSourceLookup)) {
-            this.page.target = extractSessionTabTargetFromBatchResults(details.data) ?? this.page.target;
-        }
-        if (this.page.target) {
-            this.page.unknown = undefined;
-        }
-        if (typeof details.sessionTabReopenPending === "boolean") {
-            this.page.reopenPending = details.sessionTabReopenPending;
-        }
-    }
-    knownRefs() {
-        const invalidation = observedInvalidation(this.ctx);
-        const candidate = invalidation
-            ? undefined
-            : legacySnapshot(this.ctx.details.refSnapshot, `snapshot-${this.ctx.nativeId}`);
-        if (candidate) {
-            const digest = snapshotDigest(candidate);
-            let refs;
-            if (snapshotReusable(this.page, this.ctx.details, digest) && this.page.snapshot) {
-                refs = { kind: "reuse", snapshotId: this.page.snapshot.id };
-            }
-            else {
-                this.definition = candidate;
-                refs = { kind: "replace", snapshotId: candidate.id };
-            }
-            this.page.snapshot = { id: refs.snapshotId, digest, usable: true, candidate: false };
-            return refs;
-        }
-        if (invalidation) {
-            this.disableSnapshot(false);
-            return { kind: "invalidate", invalidation };
-        }
-        return this.page.snapshot?.usable === true
-            ? { kind: "reuse", snapshotId: this.page.snapshot.id }
-            : { kind: "invalidate" };
-    }
-    disableSnapshot(candidate) {
-        if (this.page.snapshot) {
-            this.page.snapshot = { ...this.page.snapshot, usable: false, candidate };
-        }
-    }
-    change(key) {
-        const ctx = this.ctx;
-        if (ctx.begin) {
-            this.page.target = undefined;
-            this.page.unknown = true;
-            this.page.snapshot = ctx.prior.snapshot
-                ? { ...ctx.prior.snapshot, usable: false, candidate: true }
-                : undefined;
-            this.page.pending = {
-                toolCallId: ctx.toolCallId,
-                operationId: ctx.operationId,
-                index: ctx.commandIndex,
-            };
-            return { key, refs: { kind: "unknown" }, unknown: true };
-        }
-        if (ctx.details.sessionTabTargetUnknown === true) {
-            this.page.target = undefined;
-            this.page.unknown = true;
-            this.page.pending = undefined;
-            this.disableSnapshot(false);
-            return {
-                key,
-                refs: {
-                    kind: "unknown",
-                    invalidation: parseInvalidation(ctx.details.refSnapshotInvalidation, false),
-                },
-                unknown: true,
-            };
-        }
-        this.knownTarget();
-        const refs = this.knownRefs();
-        this.page.pending = undefined;
-        return {
-            key,
-            target: this.page.target,
-            unknown: this.page.unknown,
-            reopenPending: this.page.reopenPending,
-            refs,
-        };
-    }
-}