@poe-platform/safe-bash 0.1.744 → 0.1.745

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/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/shell/runtime.d.ts

@@ -506,6 +506,7 @@ export declare class Runtime {
     private trySyncScript;
     private isPureSyncValueWord;
     private extractPosixBracketCondExpr;
+    private execSyncUnsetStep;
     private extractSyncUnsetVars;
     private extractSyncShiftCount;
     private extractSyncLocalDeclStep;
@@ -514,6 +515,7 @@ export declare class Runtime {
     private evalSyncNestedForWords;
     private isSyncEchoCallOk;
     private extractSyncReadHereStringSpec;
+    private isPureSyncSubIfOrCase;
     private canSyncLoopBody;
     private extractIntLoopStep;
     private buildSyncLoopBody;
@@ -527,10 +529,10 @@ export declare class Runtime {
     private canSyncPrintfInductionBody;
     private isSyncPrintfCallOk;
     private isSimpleRedirectEchoWord;
+    private execSyncReadHereStringStep;
     private splitSyncReadLine;
     private execSyncLocalDeclStep;
     private _syncTouchedPositionals;
-    private _syncPendingVarAttrs;
     private flushSyncPositionals;
     private execSyncShiftStep;
     private evalSyncPrintfStep;
@@ -666,6 +668,17 @@ 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 evalSyncJq;
+    private parseSyncCutSpec;
+    private evalSyncCut;
+    private evalSyncSed;
+    private evalSyncGrep;
+    private evalSyncAwk;
+    private formatSyncTransformQ;
+    private sortSyncLines;
+    private translateSyncTr;
     private expandSyncTrCharSet;
     private syncBase64Encode;
     private syncBase64DecodeBytes;