@poe-platform/safe-bash 0.1.744 → 0.1.746

package/dist/safe-bash/opt-in/commands/shuf/random.js

@@ -1,4 +1,3 @@
-import { randomFillSync } from "node:crypto";
 import { yieldTurn } from "@poe-platform/safe-bash/contracts/yield";
 import { Diagnostic, quote, wordMax } from "./args.js";
 import { ownedBytes, virtualPath } from "./input.js";
@@ -74,7 +73,7 @@ export class RandomIntegers {
                 this.bytes = new Uint8Array(next.value);
             }
             else {
-                this.bytes = randomFillSync(new Uint8Array(4096));
+                this.bytes = globalThis.crypto.getRandomValues(new Uint8Array(4096));
             }
             this.offset = 0;
             this.signal.throwIfAborted();
@@ -91,7 +90,7 @@ export class RandomIntegers {
                 throw new Error("shuf random source is closed");
             while (this.maximum < target) {
                 if (this.offset === this.bytes.length) {
-                    this.bytes = randomFillSync(this.bytes.length === 4096 ? this.bytes : new Uint8Array(4096));
+                    this.bytes = globalThis.crypto.getRandomValues(this.bytes.length === 4096 ? this.bytes : new Uint8Array(4096));
                     this.offset = 0;
                 }
                 this.value = ((this.value << 8n) + BigInt(this.bytes[this.offset++])) & wordMax;

package/dist/safe-bash/opt-in/shell/extensions/read/index.js

@@ -128,8 +128,7 @@ async function parse(context, validate) {
                 }
                 else {
                     options.count = number;
-                    if (flag === "N")
-                        options.exact = true;
+                    options.exact ||= flag === "N";
                 }
             }
             break;

package/dist/safe-bash/opt-in/shell/extensions/trap/index.d.ts

@@ -1,3 +1,2 @@
-import { type TrapExtensionOptions } from "@poe-platform/safe-bash/optional-host";
+export { portableTrapExtension as trapExtension } from "@poe-platform/safe-bash/optional-host";
 export type { TrapExtensionOptions, TrapSignalHost } from "@poe-platform/safe-bash/optional-host";
-export declare function trapExtension(configuration?: TrapExtensionOptions): import("@poe-platform/safe-bash/optional-host").ShellExtension;

package/dist/safe-bash/opt-in/shell/extensions/trap/index.js

@@ -1,8 +1 @@
-import { constants, platform } from "node:os";
-import { portableTrapExtension } from "@poe-platform/safe-bash/optional-host";
-export function trapExtension(configuration = {}) {
-    return portableTrapExtension({
-        ...configuration,
-        signalNames: configuration.signalNames ?? { ...constants.signals, ...(platform() === "darwin" ? { SIGEMT: 7 } : {}) },
-    });
-}
+export { portableTrapExtension as trapExtension } from "@poe-platform/safe-bash/optional-host";

package/dist/safe-bash/playwright/adapter.d.ts

@@ -108,6 +108,7 @@ export interface PlaywrightFrame {
     evaluate?<Result, Argument>(callback: (argument: Argument) => Result, argument: Argument): Promise<Result>;
     evaluateHandle?(callback: (input: FrameSnapshotInput) => FrameSnapshotCapsule, input: FrameSnapshotInput): Promise<PlaywrightSnapshotHandle>;
     locator(selector: string): {
+        click?(options?: PlaywrightActionOptions): Promise<void>;
         elementHandles?: () => Promise<PlaywrightElementHandle[]>;
         evaluate?: (callback: (node: SnapshotNode) => string) => Promise<string>;
     };
@@ -172,6 +173,7 @@ export interface PlaywrightPage {
         timeout?: number;
     }): Promise<unknown>;
     title?(): Promise<string>;
+    content?(): Promise<string>;
     hideHighlight?(): Promise<void>;
     waitForTimeout?(milliseconds: number): Promise<void>;
     setViewportSize?(size: {

package/dist/safe-bash/playwright/capability-events.d.ts

@@ -2,6 +2,13 @@ import type { PlaywrightAbility } from './abilities.js';
 import type { PlaywrightContext, PlaywrightPage } from './adapter.js';
 import type { PlaywrightCommand } from './catalog.js';
 import type { PlaywrightSessionConfiguration } from './session-configuration.js';
+export interface PlaywrightNavigationSummary {
+    readonly url: string;
+    readonly status?: number;
+    readonly headers?: Readonly<Record<string, string>>;
+}
+/** Read retained navigation metadata without browser I/O; absent after eviction or cleanup. */
+export declare function getPlaywrightMainFrameNavigation(context: PlaywrightContext, page: PlaywrightPage): PlaywrightNavigationSummary | undefined;
 export declare function observePlaywrightCapabilities(context: PlaywrightContext, registerCleanup: (cleanup: () => Promise<void>) => void, limits: {
     maxCommandBytes: number;
     maxArtifactBytes: number;

package/dist/safe-bash/playwright/capability-events.js

@@ -1,6 +1,13 @@
 import { PlaywrightResourceLimitError } from './resource-limit.js';
 import { capabilityArtifact, capabilityArtifactName, capabilityResult, numeric, requirePage, requireSession, unsupported } from './capability-result.js';
 const states = new WeakMap();
+/** Read retained navigation metadata without browser I/O; absent after eviction or cleanup. */
+export function getPlaywrightMainFrameNavigation(context, page) {
+    const record = states.get(context)?.pages.get(pageIdentity(page))?.requests[0];
+    if (!record?.mainFrameNavigation)
+        return undefined;
+    return { url: record.url, ...(record.response ? { status: record.response.status, headers: record.response.headers } : {}) };
+}
 // A host may wrap Page navigation methods while native events retain the raw Page.
 // Playwright's main frame remains stable across those wrappers and navigations.
 function pageIdentity(page) { return page.mainFrame?.() ?? page; }
@@ -60,7 +67,8 @@ export function observePlaywrightCapabilities(context, registerCleanup, limits)
         } // Worker-only requests have no selected page.
         const page = frame.page();
         const events = pageEvents(page);
-        if (native.isNavigationRequest() && frame.parentFrame() === null) {
+        const mainFrameNavigation = native.isNavigationRequest() && frame.parentFrame() === null;
+        if (mainFrameNavigation) {
             for (const record of [...events.requests])
                 forget(record);
             events.nextRequestIndex = 0;
@@ -69,7 +77,7 @@ export function observePlaywrightCapabilities(context, registerCleanup, limits)
             delete events.log;
             events.consoleCursor = events.nextConsoleIndex;
         }
-        const record = { index: ++events.nextRequestIndex, native, url: native.url(), method: native.method(), type: native.resourceType(), headers: { ...native.headers() } };
+        const record = { index: ++events.nextRequestIndex, native, url: native.url(), method: native.method(), type: native.resourceType(), headers: { ...native.headers() }, mainFrameNavigation };
         requests.set(native, record);
         events.requests.push(record);
         // Keep native body access lazy: copying postData here turns uploads into a
@@ -83,7 +91,7 @@ export function observePlaywrightCapabilities(context, registerCleanup, limits)
         const record = requests.get(native.request());
         if (!record)
             return;
-        const response = { native, status: native.status(), statusText: native.statusText(), headers: { ...native.headers() } };
+        const response = { native, status: native.status(), statusText: native.statusText(), headers: Object.freeze({ ...native.headers() }) };
         record.response = response;
         const retained = history.get(record);
         retain(record, retained.bytes + byteLength(JSON.stringify({ status: response.status, statusText: response.statusText, headers: response.headers })), retained.evict);

package/dist/safe-bash/playwright/controller.d.ts

@@ -1,13 +1,27 @@
 import type { PlaywrightAdapter, PlaywrightContext, PlaywrightContextOptions, PlaywrightLease, PlaywrightPage } from './adapter.js';
 import { type PlaywrightInvocation } from './invocation.js';
 import { type PlaywrightAbilities } from './abilities.js';
+import { type PlaywrightNavigationSummary } from './capability-events.js';
 import { type PlaywrightSessionConfiguration } from './session-configuration.js';
 import { type PlaywrightCheckpointOutcome } from './checkpoint.js';
 import { type PlaywrightOperationOutcome, type PlaywrightRecoveryResult } from './recovery.js';
+export interface PlaywrightSnapshotHookContext<TSnapshot> {
+    readonly command: string;
+    readonly format: 'yaml' | 'json';
+    readonly context: PlaywrightContext;
+    readonly page: PlaywrightPage;
+    readonly snapshot: TSnapshot;
+    readonly navigation?: PlaywrightNavigationSummary;
+    readonly signal: AbortSignal;
+    recapture(): Promise<TSnapshot>;
+}
+export type PlaywrightSnapshotHook = <TSnapshot>(request: PlaywrightSnapshotHookContext<TSnapshot>) => Promise<TSnapshot>;
 export interface PlaywrightControllerOptions {
     /** Clock for fallback operation receipts, retained for at most 24 hours across 16 aliases. */
     readonly operationClock?: () => number;
     readonly adapter?: PlaywrightAdapter;
+    /** Runs inside the command queue after capture. Recapture does not invoke the hook again. */
+    readonly onSnapshot?: PlaywrightSnapshotHook;
     readonly abilities?: PlaywrightAbilities;
     readonly persistence?: PlaywrightSessionPersistence;
     /** Opt in only when this controller and persistence are bound to one authenticated owner. */

package/dist/safe-bash/playwright/controller.js

@@ -9,7 +9,7 @@ import { PlaywrightReportedError, playwrightCliCompatibilityVersion, playwrightC
 import { capabilityArtifactName } from './capability-result.js';
 import { isPlaywrightSnapshotRef, resolvePlaywrightTarget } from './targets.js';
 import { capturePlaywrightTargetScreenshot } from './target-screenshot.js';
-import { flushPlaywrightConsole, observePlaywrightCapabilities } from './capability-events.js';
+import { flushPlaywrightConsole, getPlaywrightMainFrameNavigation, observePlaywrightCapabilities } from './capability-events.js';
 import { getPlaywrightModal, observePlaywrightModals, onPlaywrightModal } from './modal-capabilities.js';
 import { findPlaywrightSnapshot } from './find.js';
 import { collectPlaywrightDownloads, observePlaywrightDownloads } from './download-capabilities.js';
@@ -30,8 +30,10 @@ export function createPlaywrightController(options = {}) {
         throw new TypeError('Invalid Playwright configuration');
     if (options.adapter !== undefined && (!options.adapter || typeof options.adapter.acquire !== 'function'))
         throw new TypeError('An injected Playwright adapter is required');
-    if (Object.keys(options).some(key => !['adapter', 'abilities', 'limits', 'billing', 'persistence', 'namedSessionAttachment', 'operationClock'].includes(key)))
+    if (Object.keys(options).some(key => !['adapter', 'abilities', 'limits', 'billing', 'persistence', 'namedSessionAttachment', 'operationClock', 'onSnapshot'].includes(key)))
         throw new TypeError('Unsupported Playwright configuration');
+    if (options.onSnapshot !== undefined && typeof options.onSnapshot !== 'function')
+        throw new TypeError('Invalid Playwright snapshot hook');
     if (options.operationClock !== undefined && typeof options.operationClock !== 'function')
         throw new TypeError('Invalid Playwright operation clock');
     if (options.namedSessionAttachment !== undefined && typeof options.namedSessionAttachment !== 'boolean')
@@ -966,10 +968,7 @@ export function createPlaywrightController(options = {}) {
                 if (consoleLink)
                     sections.push({ title: 'Events', content: `- New console entries: ${consoleLink}` });
             }
-            if (parsed.command !== 'snapshot' || !parsed.json) {
-                const title = await page.title?.();
-                sections.push({ title: 'Page', content: `- Page URL: ${page.url()}${title === undefined ? '' : `\n- Page Title: ${title}`}` });
-            }
+            const pageSectionIndex = sections.length;
             if (snapshot !== 'none' && (page.frames || page.ariaSnapshot || page._snapshotForAI || page.ariaSnapshotJSON || session.lease?.captureSnapshotJSON)) {
                 const snapshotOptions = { timeout: sessionSnapshotTimeout(session), ...(session.configuration?.snapshot?.boxes === undefined ? {} : { boxes: session.configuration.snapshot.boxes }), ...(session.lease?.captureSnapshotReferences ? { captureReferences: session.lease.captureSnapshotReferences } : {}) };
                 if (parsed.command === 'snapshot') {
@@ -984,16 +983,40 @@ export function createPlaywrightController(options = {}) {
                     if (parsed.args[0])
                         snapshotOptions.root = await resolveTarget(session, parsed.args[0]);
                 }
+                const captureWithHook = async (format, capture) => {
+                    let active = true;
+                    const recapture = async () => {
+                        if (!active)
+                            throw new Error('Playwright snapshot hook has completed');
+                        check();
+                        const value = await capture();
+                        check();
+                        return value;
+                    };
+                    try {
+                        const initial = await recapture();
+                        if (!options.onSnapshot)
+                            return initial;
+                        const navigation = getPlaywrightMainFrameNavigation(session.lease.context, page);
+                        const result = await options.onSnapshot({ command: parsed.command, format, context: session.lease.context, page,
+                            snapshot: initial, ...(navigation ? { navigation } : {}), signal: local.signal, recapture });
+                        check();
+                        return result;
+                    }
+                    finally {
+                        active = false;
+                    }
+                };
                 retained = false;
                 if (parsed.command === 'snapshot' && parsed.json && filename === undefined) {
-                    const tree = await session.snapshot.captureJSON(page, local.signal, { ...snapshotOptions, ...(session.lease?.captureSnapshotJSON ? { captureJSON: session.lease.captureSnapshotJSON } : {}) });
+                    const tree = await captureWithHook('json', () => session.snapshot.captureJSON(page, local.signal, { ...snapshotOptions, ...(session.lease?.captureSnapshotJSON ? { captureJSON: session.lease.captureSnapshotJSON } : {}) }));
                     check();
                     retained = parsed.command === 'snapshot';
                     sections.push({ title: 'Snapshot', content: { json: tree }, codeframe: 'json' });
                     return { sections };
                 }
                 retained = false;
-                const text = await session.snapshot.capture(page, local.signal, snapshotOptions);
+                const text = await captureWithHook('yaml', () => session.snapshot.capture(page, local.signal, snapshotOptions));
                 check();
                 retained = parsed.command === 'snapshot';
                 if (filename !== undefined || snapshot === 'file' && invocation.writeArtifact) {
@@ -1009,6 +1032,11 @@ export function createPlaywrightController(options = {}) {
                 else
                     sections.push({ title: 'Snapshot', content: text.trimEnd(), codeframe: 'yaml' });
             }
+            if (parsed.command !== 'snapshot' || !parsed.json) {
+                const title = await page.title?.();
+                check();
+                sections.splice(pageSectionIndex, 0, { title: 'Page', content: `- Page URL: ${page.url()}${title === undefined ? '' : `\n- Page Title: ${title}`}` });
+            }
             return { sections };
         };
         const checkSession = (session) => {

package/dist/safe-bash/playwright/index.d.ts

@@ -2,6 +2,7 @@ export * from './adapter.js';
 export { parseBrowserProfile, encodeBrowserProfile, restoreBrowserProfile, checkpointBrowserProfile, type BrowserProfile, type BrowserProfileLimits, type BrowserProfileContext } from './profile.js';
 export * from './billing.js';
 export * from './controller.js';
+export { getPlaywrightMainFrameNavigation, type PlaywrightNavigationSummary } from './capability-events.js';
 export { parsePlaywrightOperationOutcome, type PlaywrightRecoveryResult, type PlaywrightOperationOutcome } from './recovery.js';
 export * from './catalog.js';
 export * from './network-policy.js';

package/dist/safe-bash/playwright/index.js

@@ -2,6 +2,7 @@ export * from './adapter.js';
 export { parseBrowserProfile, encodeBrowserProfile, restoreBrowserProfile, checkpointBrowserProfile } from './profile.js';
 export * from './billing.js';
 export * from './controller.js';
+export { getPlaywrightMainFrameNavigation } from './capability-events.js';
 export { parsePlaywrightOperationOutcome } from './recovery.js';
 export * from './catalog.js';
 export * from './network-policy.js';

package/dist/safe-bash/playwright/private-target-transport.d.ts

@@ -5,6 +5,7 @@ export interface PlaywrightCDPTransport {
     onmessage?: ((message: object) => void) | undefined;
     onclose?: ((reason?: string) => void) | undefined;
 }
+/** Omitted limits and Infinity are unlimited; positive finite values opt into budgets. */
 export interface PlaywrightPrivateTargetTransportLimits {
     maxMessageBytes?: number;
     maxGraphNodes?: number;

package/dist/safe-bash/playwright/private-target-transport.js

@@ -5,7 +5,7 @@ function identity(value) {
     return typeof value === 'string' && value.length > 0 && value.length <= 1024 && !value.includes('\0');
 }
 const admittedGraphs = new WeakMap();
-function preflightProtocolJson(text, maxBytes, maxNodes = 100_000, maxDepth = 64, byteErrorMessage = 'CDP message byte limit exceeded') {
+function preflightProtocolJson(text, maxBytes, maxNodes = Infinity, maxDepth = Infinity, byteErrorMessage = 'CDP message byte limit exceeded') {
     let bytes = 0;
     let nodes = 0;
     let depth = 0;
@@ -110,8 +110,8 @@ function freezeProtocolGraph(root) {
 }
 export function admitPlaywrightProtocolFrame(data, options = {}) {
     const maxBytes = options.maxBytes ?? Infinity;
-    const maxGraphNodes = options.maxGraphNodes ?? 100_000;
-    const maxGraphDepth = options.maxGraphDepth ?? 64;
+    const maxGraphNodes = options.maxGraphNodes ?? Infinity;
+    const maxGraphDepth = options.maxGraphDepth ?? Infinity;
     if (typeof data !== 'string')
         throw new Error('Private browser frame limit or type violation');
     const stats = preflightProtocolJson(data, maxBytes, maxGraphNodes, maxGraphDepth, 'Private browser frame limit or type violation');
@@ -123,29 +123,25 @@ export function admitPlaywrightProtocolFrame(data, options = {}) {
     return value;
 }
 export function createPlaywrightPrivateTargetTransport(upstream, options = {}) {
+    for (const [name, value] of Object.entries(options)) {
+        if (value !== undefined && value !== Infinity && (!Number.isSafeInteger(value) || value <= 0 || (name.endsWith('TimeoutMs') && value > 2147483647))) {
+            throw new TypeError(`Invalid private transport limit: ${name}`);
+        }
+    }
     const limits = {
-        maxGraphNodes: 100_000,
-        maxGraphDepth: 64,
-        maxQueuedCommands: 16384,
-        maxBufferedMessages: 512,
-        maxPrivateTargets: 256,
-        maxPrivateSessions: 1024,
-        creationTimeoutMs: 2000,
-        commandTimeoutMs: 10000,
-        ...options,
+        maxGraphNodes: options.maxGraphNodes ?? Infinity,
+        maxGraphDepth: options.maxGraphDepth ?? Infinity,
+        maxQueuedCommands: options.maxQueuedCommands ?? Infinity,
+        maxBufferedMessages: options.maxBufferedMessages ?? Infinity,
+        maxPrivateTargets: options.maxPrivateTargets ?? Infinity,
+        maxPrivateSessions: options.maxPrivateSessions ?? Infinity,
+        creationTimeoutMs: options.creationTimeoutMs ?? Infinity,
+        commandTimeoutMs: options.commandTimeoutMs ?? Infinity,
         maxMessageBytes: options.maxMessageBytes ?? Infinity,
         maxPendingBytes: options.maxPendingBytes ?? Infinity,
         maxBufferedBytes: options.maxBufferedBytes ?? Infinity,
         maxPendingCommands: options.maxPendingCommands ?? Infinity,
     };
-    for (const [name, value] of Object.entries(limits)) {
-        if (['maxPendingCommands', 'maxMessageBytes', 'maxPendingBytes', 'maxBufferedBytes'].includes(name) && options[name] === undefined)
-            continue;
-        if (!Number.isSafeInteger(value) || value <= 0 || (name.endsWith('TimeoutMs') && value > 2147483647)) {
-            throw new TypeError(`Invalid private transport limit: ${name}`);
-        }
-    }
-    const encoder = new TextEncoder();
     const targets = new Set();
     const sessions = new Map();
     const retiredTargets = new Set();
@@ -166,6 +162,8 @@ export function createPlaywrightPrivateTargetTransport(upstream, options = {}) {
     let commandTimer;
     let timedCommandId;
     function scheduleCommandDeadline() {
+        if (!Number.isFinite(limits.commandTimeoutMs))
+            return;
         // Uniform deadlines and monotonic insertion order keep the oldest command
         // first, even when replies arrive out of order. Only that command needs a timer.
         const first = pending.entries().next().value;
@@ -550,7 +548,9 @@ export function createPlaywrightPrivateTargetTransport(upstream, options = {}) {
             if (targets.size >= limits.maxPrivateTargets)
                 throw new Error('Private target identity capacity exceeded');
             const entry = { active: true, failed: false,
-                timer: setTimeout(() => retire(new Error('Native target creation identity timed out')), limits.creationTimeoutMs) };
+                timer: Number.isFinite(limits.creationTimeoutMs)
+                    ? setTimeout(() => retire(new Error('Native target creation identity timed out')), limits.creationTimeoutMs)
+                    : undefined };
             creation = entry;
             return {
                 commit(targetId) { finish(entry, true, targetId); },

package/dist/safe-bash/shell/runtime.d.ts

@@ -322,7 +322,6 @@ interface InvokeOutcomeRecord {
     consumed: boolean;
     selection?: CancellationSelection<CommandResult> | undefined;
 }
-/** Internal to the shell/runtime pair; it is not exported by the package root. */
 export declare class RuntimeCancellationState {
     private _records;
     private _diagnostics;
@@ -506,6 +505,7 @@ export declare class Runtime {
     private trySyncScript;
     private isPureSyncValueWord;
     private extractPosixBracketCondExpr;
+    private execSyncUnsetStep;
     private extractSyncUnsetVars;
     private extractSyncShiftCount;
     private extractSyncLocalDeclStep;
@@ -514,6 +514,7 @@ export declare class Runtime {
     private evalSyncNestedForWords;
     private isSyncEchoCallOk;
     private extractSyncReadHereStringSpec;
+    private isPureSyncSubIfOrCase;
     private canSyncLoopBody;
     private extractIntLoopStep;
     private buildSyncLoopBody;
@@ -524,13 +525,22 @@ export declare class Runtime {
     private evalSyncRedirectWord;
     private evalSyncRedirectSuffix;
     private encodeSyncRedirectWordsToScratch;
+    private _activePrintfInductionName;
+    private _activeLoopBodyScript;
+    private _activeLoopCondScript;
+    private _activeLoopVarName;
+    private isVarUnmutatedInScript;
+    private isVarUnmutatedInActiveLoop;
+    private isFileReadOnlyScript;
+    private extractLoopInvariantJqInput;
     private canSyncPrintfInductionBody;
     private isSyncPrintfCallOk;
     private isSimpleRedirectEchoWord;
+    private syncStringLength;
+    private execSyncReadHereStringStep;
     private splitSyncReadLine;
     private execSyncLocalDeclStep;
     private _syncTouchedPositionals;
-    private _syncPendingVarAttrs;
     private flushSyncPositionals;
     private execSyncShiftStep;
     private evalSyncPrintfStep;
@@ -666,6 +676,28 @@ export declare class Runtime {
     }>, value: ShellValue, state: State, io: IO, hereString: boolean): Promise<ShellValue>;
     word(word: Word, state: State, io: IO, split?: boolean, pattern?: boolean, hereString?: boolean, conditionalPattern?: boolean, regexAppend?: (text: string, literal: boolean, value: ShellValue) => void): Promise<string[]>;
     private fastValueWord;
+    private expandSyncTrCharArray;
+    private evalSyncTr;
+    private evalSyncJqPathOps;
+    private evalSyncJq;
+    private evalSyncDirname;
+    private evalSyncBasename;
+    private parseSyncCutSpec;
+    private evalSyncCut;
+    private evalSyncSed;
+    private evalSyncGrep;
+    private evalSyncAwk;
+    private formatSyncTransformQ;
+    private wcMaxLineWidth;
+    private compareSyncVersion;
+    private evalSyncNl;
+    private evalSyncPaste;
+    private evalSyncNumfmt;
+    private evalSyncSort;
+    private normalizeSyncWcFlag;
+    private evalSyncUniq;
+    private sortSyncLines;
+    private translateSyncTr;
     private expandSyncTrCharSet;
     private syncBase64Encode;
     private syncBase64DecodeBytes;