pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/browser-session-conversion-stream.js

@@ -1,217 +0,0 @@
-import { createHash } from "node:crypto";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import tokenizeJson from "stream-json/parser.js";
-import ignoreJson from "stream-json/filters/ignore.js";
-import stringifyJson from "stream-json/stringer.js";
-import disassembleJson from "stream-json/disassembler.js";
-import { BROWSER_RESULT_TOOLS, BROWSER_STATE_FIELDS, BROWSER_TRANSITION_ENTRY, } from "./browser-transcript-contracts.js";
-import { projectJson, readRange, } from "./browser-journal-reader.js";
-import { isRecord } from "./parsing.js";
-import { convertLegacyBrowserEntry, emptyProjection, } from "./browser-legacy-projection.js";
-const DETAILS_FIELDS = [
-    ...BROWSER_STATE_FIELDS,
-    "browserEventVersion",
-    "electron",
-    "compiledNetworkSourceLookup",
-    "sessionTabTarget",
-    "sessionTabTargetUnknown",
-    "sessionTabReopenPending",
-    "refSnapshot",
-    "refSnapshotInvalidation",
-    "artifactManifest",
-    "error",
-    "summary",
-];
-const LEGACY_FIELDS = [
-    ["data", "event"],
-    ["data", "snapshot"],
-    ["data", "cleanup"],
-    ["data", "sessionName"],
-    ["data", "closeCommandArgs"],
-    ["data", "launchAttempted"],
-    ["data", "toolCallId"],
-    ["data", "isError"],
-    ["message", "toolName"],
-    ["message", "toolCallId"],
-    ["message", "isError"],
-    ...["data", "message"].flatMap((root) => DETAILS_FIELDS.map((field) => [root, "details", field])),
-    ...["data", "message"].flatMap((root) => ["command", "success", "lifecycle"]
-        .map((field) => [root, "details", "batchSteps", "*", field])
-        .concat([
-        ["data", "lifecycle"],
-        ["result", "lifecycle"],
-    ].map((field) => [root, "details", "batchSteps", "*"].concat(field)))),
-    ...["data", "message"].flatMap((root) => ["command", "success", "error"]
-        .map((field) => [root, "details", "data", "*", field])
-        .concat(["url", "title", "origin", "targetId"].map((field) => [
-        root,
-        "details",
-        "data",
-        "*",
-        "result",
-        field,
-    ]))),
-];
-export async function sourceChecksum(file, size) {
-    const hash = createHash("sha256");
-    for await (const chunk of readRange(file, { offset: 0, length: size })) {
-        hash.update(chunk);
-    }
-    return hash.digest("hex");
-}
-export async function writeBytes(file, 
-// The native async iterator owns its cursor; yielded byte/string contents are read, never changed.
-// oxlint-disable-next-line typescript/prefer-readonly-parameter-types
-chunks) {
-    for await (const chunk of chunks) {
-        const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-        let offset = 0;
-        while (offset < buffer.length) {
-            // Partial writes determine the offset for the next write.
-            // oxlint-disable-next-line no-await-in-loop
-            const { bytesWritten } = await file.write(buffer, offset, buffer.length - offset);
-            if (bytesWritten === 0) {
-                throw new Error("Could not write converted journal.");
-            }
-            offset += bytesWritten;
-        }
-    }
-}
-async function* decodeRange(file, range) {
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    for await (const bytes of readRange(file, range)) {
-        yield decoder.decode(bytes, { stream: true });
-    }
-    const tail = decoder.decode();
-    if (tail.length > 0) {
-        yield tail;
-    }
-}
-async function rewriteMessage(file, range, destination, record) {
-    const tokenizer = tokenizeJson.asStream({ packValues: false, packKeys: true, streamKeys: false });
-    const filter = ignoreJson.asStream({
-        filter: /^(?:data|message\.details\.(?:refSnapshot|artifactManifest|browserEventVersion))$/,
-    });
-    async function* inject(
-    // Native token iteration advances a mutable cursor; token observations themselves remain readonly.
-    // oxlint-disable-next-line typescript/prefer-readonly-parameter-types
-    tokens) {
-        let depth = 0;
-        for await (const token of tokens) {
-            if (token.name === "startObject" || token.name === "startArray") {
-                depth++;
-            }
-            if (token.name === "endObject" || token.name === "endArray") {
-                depth--;
-                if (depth === 0) {
-                    const key = { name: "keyValue", value: "data" };
-                    yield key;
-                    yield* disassembleJson({ packValues: false, packKeys: true, streamKeys: false })(record);
-                }
-            }
-            yield token;
-        }
-    }
-    const output = stringifyJson.asStream({ useKeyValues: true });
-    const processing = pipeline(Readable.from(decodeRange(file, range)), tokenizer, filter, inject, output);
-    try {
-        await Promise.all([writeBytes(destination, output), processing]);
-    }
-    finally {
-        tokenizer.destroy();
-        filter.destroy();
-        output.destroy();
-    }
-    await destination.write("\n");
-}
-function isLegacyBrowserEntry(value) {
-    if (value.type === "custom" &&
-        typeof value.customType === "string" &&
-        [BROWSER_TRANSITION_ENTRY, "agent-browser-script-session"].includes(value.customType)) {
-        return true;
-    }
-    return (isRecord(value.message) &&
-        typeof value.message.toolName === "string" &&
-        BROWSER_RESULT_TOOLS.has(value.message.toolName));
-}
-/** Owns branch projection and counters while streaming entries, never whole raw payloads. */
-export class BrowserConversionWriter {
-    file;
-    stage;
-    sessionId;
-    checksum;
-    ids = new Set();
-    states = new Map();
-    convertedRecords = 0;
-    snapshotDefinitions = 0;
-    constructor(file, stage, sessionId, checksum) {
-        this.file = file;
-        this.stage = stage;
-        this.sessionId = sessionId;
-        this.checksum = checksum;
-    }
-    get counts() {
-        return {
-            entryCount: this.ids.size,
-            convertedRecords: this.convertedRecords,
-            snapshotDefinitions: this.snapshotDefinitions,
-        };
-    }
-    async conversion(entry) {
-        if (entry.value.type === "session") {
-            return undefined;
-        }
-        const id = entry.value.id;
-        if (typeof id !== "string" || this.ids.has(id)) {
-            throw new Error("Conversion source contains a missing or duplicate native entry ID.");
-        }
-        const parentId = entry.value.parentId;
-        if (parentId !== null && (typeof parentId !== "string" || !this.ids.has(parentId))) {
-            throw new Error("Conversion source contains a missing or forward parent.");
-        }
-        this.ids.add(id);
-        const parent = typeof parentId === "string"
-            ? (this.states.get(parentId) ?? emptyProjection())
-            : emptyProjection();
-        if (!isLegacyBrowserEntry(entry.value)) {
-            this.states.set(id, parent);
-            return undefined;
-        }
-        const details = await projectJson(readRange(this.file, entry), LEGACY_FIELDS, Infinity);
-        const conversion = convertLegacyBrowserEntry({ ...entry.value, ...details }, parent, this.sessionId);
-        this.states.set(id, conversion.projection);
-        return conversion.record;
-    }
-    async write(entry, sourceSize) {
-        const record = await this.conversion(entry);
-        if (!record) {
-            await writeBytes(this.stage, readRange(this.file, entry));
-            if (entry.offset + entry.length === sourceSize) {
-                await this.completeLastLine(sourceSize);
-            }
-            return;
-        }
-        const data = {
-            ...record,
-            archive: { sourceSha256: this.checksum, offset: entry.offset, length: entry.length },
-        };
-        if (entry.value.type === "message") {
-            await rewriteMessage(this.file, entry, this.stage, data);
-        }
-        else {
-            await this.stage.write(`${JSON.stringify({ ...entry.value, customType: BROWSER_TRANSITION_ENTRY, data })}\n`);
-        }
-        this.convertedRecords++;
-        if (record.snapshot !== undefined) {
-            this.snapshotDefinitions++;
-        }
-    }
-    async completeLastLine(size) {
-        const lastByte = Buffer.alloc(1);
-        await this.file.read(lastByte, 0, 1, size - 1);
-        if (lastByte[0] !== 10) {
-            await this.stage.write("\n");
-        }
-    }
-}

package/dist/extensions/agent-browser/lib/browser-session-conversion.js

@@ -1,126 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { link, lstat, mkdir, open, unlink } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { scanJournalMetadata } from "./browser-journal-reader.js";
-import { getErrorCode } from "./process-errors.js";
-import { BrowserConversionWriter, sourceChecksum } from "./browser-session-conversion-stream.js";
-export { convertLegacyBrowserEntry, convertBrowserEntries } from "./browser-legacy-projection.js";
-async function validateConversionPaths(options) {
-    if (!options.confirmedStopped) {
-        throw new Error("Stop/quiesce the exact session writer first, then pass --confirm-stopped. Conversion never stops a session.");
-    }
-    const source = resolve(options.source);
-    const destination = resolve(options.destination);
-    if (source === destination) {
-        throw new Error("Conversion requires a separate destination; originals are never rewritten.");
-    }
-    const sourceStat = await lstat(source);
-    if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
-        throw new Error("Conversion source must be a regular file, not a symlink.");
-    }
-    const directory = dirname(destination);
-    await mkdir(directory, { mode: 0o700, recursive: true });
-    await validateDestination(directory, destination);
-    return { source, destination, directory, sourceStat };
-}
-async function validateDestination(directory, destination) {
-    const entry = await lstat(directory);
-    if (!entry.isDirectory() ||
-        entry.isSymbolicLink() ||
-        (process.platform !== "win32" &&
-            (entry.uid !== process.getuid?.() || (entry.mode & 0o077) !== 0))) {
-        throw new Error("Conversion destination must be a private current-user directory (0700 on POSIX), without symlinks.");
-    }
-    try {
-        await lstat(destination);
-        throw new Error("Conversion destination is occupied.");
-    }
-    catch (error) {
-        if (getErrorCode(error) !== "ENOENT") {
-            throw error;
-        }
-    }
-}
-async function verifySourceUnchanged(file, source, initial, checksum) {
-    const final = await file.stat();
-    const finalPath = await lstat(source);
-    if (final.dev !== initial.dev ||
-        final.ino !== initial.ino ||
-        final.size !== initial.size ||
-        final.mtimeMs !== initial.mtimeMs ||
-        finalPath.dev !== initial.dev ||
-        finalPath.ino !== initial.ino ||
-        (await sourceChecksum(file, initial.size)) !== checksum) {
-        throw new Error("Conversion source changed; no destination was published.");
-    }
-}
-async function syncPublishedDirectory(directory) {
-    const parent = await open(directory, constants.O_RDONLY);
-    try {
-        await parent.sync();
-    }
-    finally {
-        await parent.close();
-    }
-}
-/** Separate-copy publication only. The operator must quiesce the exact writer first. */
-export async function convertBrowserSession(options) {
-    const { source, destination, directory, sourceStat } = await validateConversionPaths(options);
-    const file = await open(source, constants.O_RDONLY | constants.O_NOFOLLOW);
-    const stagePath = `${destination}.${randomUUID()}.tmp`;
-    let stage;
-    let published = false;
-    try {
-        const initial = await file.stat();
-        if (initial.dev !== sourceStat.dev || initial.ino !== sourceStat.ino) {
-            throw new Error("Conversion source changed before capture.");
-        }
-        const checksum = await sourceChecksum(file, initial.size);
-        const metadata = await scanJournalMetadata(file, initial.size, true);
-        const header = metadata.at(0);
-        if (header === undefined ||
-            header.value.type !== "session" ||
-            typeof header.value.id !== "string") {
-            throw new Error("Conversion source has no native session header.");
-        }
-        stage = await open(stagePath, "wx+", 0o600);
-        const writer = new BrowserConversionWriter(file, stage, header.value.id, checksum);
-        for (const entry of metadata) {
-            // Native ancestry and output byte ordering require each entry to finish before the next.
-            // oxlint-disable-next-line no-await-in-loop
-            await writer.write(entry, initial.size);
-        }
-        await stage.sync();
-        const output = await stage.stat();
-        const destinationSha256 = await sourceChecksum(stage, output.size);
-        await verifySourceUnchanged(file, source, initial, checksum);
-        await stage.close();
-        stage = undefined;
-        await link(stagePath, destination); // Exclusive publication; never overwrite an existing destination.
-        published = true;
-        return {
-            version: 1,
-            source,
-            destination,
-            sessionId: header.value.id,
-            sourceSha256: checksum,
-            destinationSha256,
-            ...writer.counts,
-            sourceBytes: initial.size,
-            destinationBytes: output.size,
-        };
-    }
-    finally {
-        await stage?.close();
-        await file.close();
-        await unlink(stagePath).catch((error) => {
-            if (getErrorCode(error) !== "ENOENT") {
-                throw error;
-            }
-        });
-        if (published && process.platform !== "win32") {
-            await syncPublishedDirectory(directory);
-        }
-    }
-}

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

@@ -1,35 +0,0 @@
-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",
-]);
-export const BROWSER_STATE_FIELDS = [
-    "args",
-    "command",
-    "subcommand",
-    "sessionName",
-    "namespace",
-    "sessionMode",
-    "usedImplicitSession",
-    "managedSessionSocketDir",
-    "managedSessionDaemon",
-    "ownerSessionId",
-    "agentBrowserStarted",
-    "resultCategory",
-    "exitCode",
-    "closeAllApplied",
-    "attachedBrowserSession",
-    "readConfirmation",
-    "compatibilityWorkaround",
-    "managedSessionHeadedAutosaveDisabled",
-    "managedSessionHeadedAutosaveInterval",
-    "managedSessionOutcome",
-    "managedSessionCwd",
-    "managedSessionRestoreDisabled",
-    "nativeSucceeded",
-];

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

@@ -1,166 +0,0 @@
-import { isRecord } from "./parsing.js";
-import { isBrowserStringArray } from "./browser-value-parsing.js";
-import { isSessionArtifactManifest } from "./results/artifact-manifest.js";
-import { normalizeSessionTabTarget, } from "./session-page-observation.js";
-function validRefText(value) {
-    return ((value.role === undefined || typeof value.role === "string") &&
-        (value.name === undefined || typeof value.name === "string"));
-}
-function validRefFlags(value) {
-    return ((value.isEditable === undefined || typeof value.isEditable === "boolean") &&
-        (value.isContentEditable === undefined || typeof value.isContentEditable === "boolean"));
-}
-export function isBrowserSnapshotReference(value) {
-    return isRecord(value) && validRefText(value) && validRefFlags(value);
-}
-export function isNamedBrowserSnapshotReference(value) {
-    return (isBrowserSnapshotReference(value) &&
-        typeof value.name === "string" &&
-        typeof value.role === "string");
-}
-function invalidEvent() {
-    throw new Error("Invalid browser event; inspect or convert the retained session before browser work.");
-}
-function invalidPage() {
-    throw new Error("Invalid browser page disposition; refs cannot be restored.");
-}
-function parseInvalidation(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!isRecord(value) ||
-        (value.reason !== "page-transition" && value.reason !== "no-active-page") ||
-        typeof value.summary !== "string") {
-        return invalidPage();
-    }
-    return { ...value, reason: value.reason, summary: value.summary };
-}
-function parseRefs(value) {
-    if (!isRecord(value)) {
-        return invalidPage();
-    }
-    if (value.kind === "reuse" || value.kind === "replace") {
-        if (typeof value.snapshotId !== "string" || value.snapshotId.length === 0) {
-            return invalidPage();
-        }
-        return { ...value, kind: value.kind, snapshotId: value.snapshotId };
-    }
-    if (value.kind !== "unknown" && value.kind !== "invalidate") {
-        return invalidPage();
-    }
-    const invalidation = parseInvalidation(value.invalidation);
-    return { ...value, kind: value.kind, ...(invalidation ? { invalidation } : {}) };
-}
-export function decodeBrowserTarget(value) {
-    if (!isRecord(value) || typeof value.url !== "string") {
-        return undefined;
-    }
-    if ((value.title !== undefined && typeof value.title !== "string") ||
-        (value.targetId !== undefined && typeof value.targetId !== "string")) {
-        return undefined;
-    }
-    const target = { ...value, url: value.url };
-    return normalizeSessionTabTarget(target) === undefined ? undefined : target;
-}
-function parseBrowserTarget(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    return decodeBrowserTarget(value) ?? invalidPage();
-}
-function pageScalarsValid(value) {
-    return ((value.confirmActions === undefined ||
-        value.confirmActions === null ||
-        typeof value.confirmActions === "string") &&
-        (value.unknown === undefined || value.unknown === true) &&
-        (value.clear === undefined || value.clear === true));
-}
-function pagePolicyValid(value) {
-    return ((value.reopenPending === undefined || typeof value.reopenPending === "boolean") &&
-        (value.pinningReason === undefined ||
-            value.pinningReason === "restore" ||
-            value.pinningReason === "drift"));
-}
-function parsePage(value) {
-    if (!isRecord(value) ||
-        typeof value.key !== "string" ||
-        !pageScalarsValid(value) ||
-        !pagePolicyValid(value)) {
-        return invalidPage();
-    }
-    const target = parseBrowserTarget(value.target);
-    return { ...value, key: value.key, refs: parseRefs(value.refs), ...(target ? { target } : {}) };
-}
-function parsePages(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!Array.isArray(value)) {
-        return invalidPage();
-    }
-    const pages = value;
-    return pages.map(parsePage);
-}
-function parseArtifacts(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!isRecord(value) || !isBrowserStringArray(value.removals)) {
-        throw new Error("Invalid browser artifact changes; inspect the retained journal.");
-    }
-    const manifest = {
-        version: 1,
-        entries: value.upserts,
-        maxEntries: value.maxEntries,
-        updatedAtMs: value.updatedAtMs,
-        liveCount: 0,
-        evictedCount: 0,
-    };
-    if (!isSessionArtifactManifest(manifest)) {
-        throw new Error("Invalid browser artifact changes; inspect the retained journal.");
-    }
-    return {
-        ...value,
-        upserts: manifest.entries,
-        removals: value.removals,
-        maxEntries: manifest.maxEntries,
-        updatedAtMs: manifest.updatedAtMs,
-    };
-}
-function eventIdentity(value) {
-    if (typeof value.operationId !== "string" ||
-        typeof value.toolCallId !== "string" ||
-        typeof value.commandIndex !== "number" ||
-        !Number.isSafeInteger(value.commandIndex) ||
-        value.commandIndex < 0 ||
-        typeof value.isError !== "boolean") {
-        return invalidEvent();
-    }
-    return {
-        operationId: value.operationId,
-        toolCallId: value.toolCallId,
-        commandIndex: value.commandIndex,
-        isError: value.isError,
-    };
-}
-export function parseBrowserEvent(value) {
-    const phase = value.phase;
-    if (phase !== "begin" && phase !== "finish" && phase !== "state") {
-        return invalidEvent();
-    }
-    if (!isRecord(value.state)) {
-        return invalidEvent();
-    }
-    const identity = eventIdentity(value);
-    const pages = parsePages(value.pages);
-    const artifacts = parseArtifacts(value.artifacts);
-    return {
-        ...value,
-        ...identity,
-        version: 1,
-        phase,
-        state: value.state,
-        ...(pages ? { pages } : {}),
-        ...(artifacts ? { artifacts } : {}),
-    };
-}