@skyramp/mcp 0.2.7 → 0.2.8

package/node_modules/playwright/node_modules/playwright-core/src/server/recorder/recorderApp.ts

@@ -29,9 +29,15 @@ import { generateCode } from '../codegen/language';
 import { Recorder, RecorderEvent } from '../recorder';
 import { BrowserContext } from '../browserContext';
 import { JsonlReader } from '../codegen/skyramp/jsonlReader';
-import { ReplayEngine, StepNumberCondition, UrlPatternCondition } from './skyramp/replayEngine';
+import { ReplayEngine, UrlPatternCondition } from './skyramp/replayEngine';
+import { AliasRemapper } from './skyramp/aliasRemapper';
 import type { ReplayEngineOptions } from './skyramp/replayEngine';
 
+// Options for loading a trace and replaying a (sub-)range of it. startStep and
+// stopStep are 1-based indices into the original trace (what the step picker
+// shows); they slice the range that gets appended at the live recording cursor.
+type LoadTraceOptions = ReplayEngineOptions & { startStep?: number; stopStep?: number };
+
 import type { Page } from '../page';
 import type * as actions from '@recorder/actions';
 import type { CallLog, ElementInfo, Mode, Source } from '@recorder/recorderTypes';
@@ -134,11 +140,16 @@ export class RecorderApp {
         const deleted = this._actions[lastRealIndex];
         const { name, signals: _signals, ariaSnapshot: _aria, ...rest } = deleted.action as any;
         const summary: Record<string, unknown> = { name };
-        if (rest.selector) summary['selector'] = rest.selector;
-        if (rest.url) summary['url'] = rest.url;
-        if (rest.key) summary['key'] = rest.key;
-        if (rest.text) summary['text'] = rest.text;
-        if (rest.timestamp) summary['timestamp'] = rest.timestamp;
+        if (rest.selector)
+          summary['selector'] = rest.selector;
+        if (rest.url)
+          summary['url'] = rest.url;
+        if (rest.key)
+          summary['key'] = rest.key;
+        if (rest.text)
+          summary['text'] = rest.text;
+        if (rest.timestamp)
+          summary['timestamp'] = rest.timestamp;
         const commentAction: actions.ActionInContext = {
           frame: deleted.frame,
           startTime: deleted.startTime,
@@ -202,14 +213,35 @@ export class RecorderApp {
       this._recorder.executeScript(data.params.script);
       return;
     }
+    if (data.event === 'parseTrace') {
+      // Parse the loaded trace and push per-step previews (jsonl + ts + python)
+      // back to the step picker. Parsing goes through the same JsonlReader the
+      // replay uses, so the step indices align with the array we later slice.
+      const loadedActions = JsonlReader._parseContent(data.params.jsonlContent);
+      const steps = this._buildTraceSteps(loadedActions);
+      // Echo the request token so the UI can drop a stale response (e.g. if the
+      // user cancelled and loaded a different trace while this one was parsing).
+      this._page.mainFrame().evaluateExpression(
+          ((p: { steps: any[], token: number }) => { window.playwrightSetTraceSteps?.(p.steps, p.token); }).toString(),
+          { isFunction: true },
+          { steps, token: data.params.token },
+      ).catch(() => { });
+      return;
+    }
     if (data.event === 'loadTrace') {
+      const opts: LoadTraceOptions = {
+        startStep: data.params.startStep,
+        stopStep: data.params.stopStep,
+        stopCondition: data.params.stopUrl !== undefined ? new UrlPatternCondition(data.params.stopUrl) : undefined,
+        delayBetweenActions: data.params.delayBetweenActions,
+      };
       if (data.params.jsonlContent !== undefined) {
         // Content sent directly from the browser file picker (JSONL/TXT, or extracted from ZIP).
         const loadedActions = JsonlReader._parseContent(data.params.jsonlContent);
-        void this._runReplay(loadedActions, { stopCondition: _buildStopCondition(data.params), delayBetweenActions: data.params.delayBetweenActions });
+        void this._runReplay(loadedActions, opts);
       } else {
         // File path provided (e.g. from CLI flag).
-        void this.loadTrace(data.params.path, { stopCondition: _buildStopCondition(data.params) });
+        void this.loadTrace(data.params.path, opts);
       }
       return;
     }
@@ -380,9 +412,9 @@ export class RecorderApp {
 
       // Write JSON with pretty formatting
       fs.writeFileSync(
-        filepath,
-        JSON.stringify(action.snapshotData, null, 2),
-        'utf-8'
+          filepath,
+          JSON.stringify(action.snapshotData, null, 2),
+          'utf-8'
       );
 
       // console.log(`[RecorderApp] DOM snapshot saved successfully to: ${filepath}`);
@@ -440,39 +472,69 @@ export class RecorderApp {
     }).toString(), { isFunction: true }, { sourceId }).catch(() => { });
   }
 
-  async loadTrace(zipOrJsonlPath: string, opts: ReplayEngineOptions = {}) {
+  async loadTrace(zipOrJsonlPath: string, opts: LoadTraceOptions = {}) {
     const loadedActions = zipOrJsonlPath.endsWith('.zip')
       ? await JsonlReader.fromZip(zipOrJsonlPath)
       : JsonlReader.fromFile(zipOrJsonlPath);
     await this._runReplay(loadedActions, opts);
   }
 
-  private async _runReplay(loadedActions: actions.ActionInContext[], opts: ReplayEngineOptions = {}) {
+  private async _runReplay(loadedActions: actions.ActionInContext[], opts: LoadTraceOptions = {}) {
     if (!loadedActions.length)
       return;
 
-    // Reset current actions and switch to replaying mode so user capture is
-    // suppressed while the engine drives the browser.
-    this._actions = [];
-    this._updateActions();
+    // Slice the trace to the chosen [startStep, stopStep] range (1-based, inclusive).
+    // startStep lets the user skip a stale prefix (e.g. an old login page) and
+    // append only the still-valid tail onto the current recording.
+    const startIndex = opts.startStep ? Math.max(0, opts.startStep - 1) : 0;
+    const endIndex = opts.stopStep ? Math.min(loadedActions.length, opts.stopStep) : loadedActions.length;
+    const replayActions = loadedActions.slice(startIndex, endIndex);
+    if (!replayActions.length) {
+      // Out-of-range or start>stop produced an empty range. The picker UI clamps
+      // these, so this only arises from a bad programmatic/CLI call — surface it
+      // rather than silently doing nothing.
+      this._page.mainFrame().evaluateExpression(
+          ((msg: string) => { window.playwrightSetReplayError?.(msg); }).toString(),
+          { isFunction: true },
+          `Nothing to replay: the selected step range is empty (trace has ${loadedActions.length} steps; start=${opts.startStep ?? 1}, stop=${opts.stopStep ?? loadedActions.length}).`,
+      ).catch(() => { });
+      return;
+    }
+
+    // Remap the fragment's page aliases (page/page1/page2...) onto the live
+    // session so a multi-tab fragment can be appended mid-recording. Seed from
+    // the last already-recorded action's page alias — the best available proxy
+    // for where recording left off (it is a live alias, recorded this session) —
+    // or 'page' from an empty start. NOTE: this is the last *recorded* tab, which
+    // may differ from the visually-focused tab if the user switched tabs without
+    // recording an action there; the manual recorder exposes no focused-tab signal.
+    const seedLiveAlias = this._actions.length ? this._actions[this._actions.length - 1].frame.pageAlias : 'page';
+    const aliasRemapper = new AliasRemapper(this._recorder.pageAliases(), replayActions, seedLiveAlias);
+
+    // Append onto the existing recording (no wipe): replayed actions are pushed
+    // after whatever the user has already recorded, then they continue from here.
+    // From an empty recording this is identical to a clean load.
     this._recorder.setMode('replaying');
 
+    const total = replayActions.length;
     const engine = new ReplayEngine(
-      this._recorder.pageAliases(),
-      loadedActions,
-      (action, index) => {
-        this._actions.push(action);
-        this._updateActions('reveal');
-        // Notify the UI of replay progress.
-        this._page.mainFrame().evaluateExpression(
-          ((p: { completed: number, total: number }) => {
-            window.playwrightSetReplayProgress?.(p.completed, p.total);
-          }).toString(),
-          { isFunction: true },
-          { completed: index + 1, total: loadedActions.length },
-        ).catch(() => { });
-      },
-      opts,
+        this._recorder.pageAliases(),
+        replayActions,
+        (action, index) => {
+          this._actions.push(action);
+          this._updateActions('reveal');
+          // Notify the UI of replay progress.
+          this._page.mainFrame().evaluateExpression(
+              ((p: { completed: number, total: number }) => {
+                window.playwrightSetReplayProgress?.(p.completed, p.total);
+              }).toString(),
+              { isFunction: true },
+              { completed: index + 1, total },
+          ).catch(() => { });
+        },
+        // Pass only ReplayEngineOptions fields — opts is LoadTraceOptions, whose
+        // startStep/stopStep have already been applied via the slice above.
+        { onProgress: opts.onProgress, stopCondition: opts.stopCondition, delayBetweenActions: opts.delayBetweenActions, aliasRemapper },
     );
     this._replayEngine = engine;
 
@@ -482,9 +544,9 @@ export class RecorderApp {
         const { message, actionName, stepIndex } = result.error;
         const errorMsg = `Replay stopped at step ${stepIndex} (${actionName}): ${message}\n\nYou can continue recording from this point.`;
         this._page.mainFrame().evaluateExpression(
-          ((msg: string) => { window.playwrightSetReplayError?.(msg); }).toString(),
-          { isFunction: true },
-          errorMsg,
+            ((msg: string) => { window.playwrightSetReplayError?.(msg); }).toString(),
+            { isFunction: true },
+            errorMsg,
         ).catch(() => { });
       }
     } finally {
@@ -493,6 +555,38 @@ export class RecorderApp {
     }
   }
 
+  // Build per-step previews for the load-trace step picker. Each step carries
+  // the source line in jsonl/ts/python so the picker can toggle languages. The
+  // array is index-aligned with the parsed actions (one entry per action, even
+  // if a generator emits no text), so picker indices map 1:1 to replay slicing.
+  private _buildTraceSteps(loadedActions: actions.ActionInContext[]) {
+    const wanted = [
+      { key: 'jsonl', id: 'jsonl' },
+      { key: 'ts', id: 'playwright-test' },
+      { key: 'python', id: 'python' },
+    ] as const;
+    const generators = wanted.map(w => ({ key: w.key, gen: [...languageSet()].find(g => g.id === w.id) }));
+
+    return loadedActions.map((action, i) => {
+      const code: Record<string, string> = {};
+      for (const { key, gen } of generators)
+        code[key] = (gen?.generateAction(action) || '').trim();
+      // Tabs this action opens (popup signals). The picker uses these to detect,
+      // as the user drags the range, whether a step targets a tab the range never
+      // opens (its opener step was skipped) - which would fail at replay time.
+      const opensAliases = action.action.signals
+          .filter((s): s is actions.PopupSignal => s.name === 'popup')
+          .map(s => s.popupAlias);
+      return {
+        index: i + 1,
+        name: action.action.name,
+        pageAlias: action.frame.pageAlias,
+        opensAliases,
+        code,
+      };
+    });
+  }
+
   private _updateActions(reveal?: 'reveal') {
     const recorderSources = [];
     const actions = collapseActions(this._actions);
@@ -571,12 +665,4 @@ function findPageByGuid(context: BrowserContext, guid: string) {
   return context.pages().find(p => p.guid === guid);
 }
 
-function _buildStopCondition(params: any) {
-  if (params?.stopStep !== undefined)
-    return new StepNumberCondition(params.stopStep);
-  if (params?.stopUrl !== undefined)
-    return new UrlPatternCondition(params.stopUrl);
-  return undefined;
-}
-
 const recorderAppSymbol = Symbol('recorderApp');

package/node_modules/playwright/node_modules/playwright-core/src/server/recorder/skyramp/aliasRemapper.ts

@@ -0,0 +1,119 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { Page } from '../../page';
+import type * as actions from '@recorder/actions';
+
+/**
+ * Remaps the page aliases of a loaded trace fragment onto the live recording
+ * session, so a multi-tab fragment can be replayed and appended mid-recording.
+ *
+ * The problem: a fragment's actions carry the aliases they were recorded with
+ * (page, page1, page2...). Replay resolves those against the recorder's LIVE
+ * `_pageAliases` map. On a clean load this lines up by construction (replay
+ * starts blank, so the live alias counter advances in lockstep with the trace).
+ * Mid-recording the live session may already have tabs open, so the fragment's
+ * aliases collide with the live ones.
+ *
+ * The fix: bind fragment aliases to live aliases lazily.
+ *  - Seed: the fragment's primary alias (its first action's page) maps to the
+ *    tab the user is currently on.
+ *  - Popups: when a replayed action opens a popup (carries a `popup` signal),
+ *    the recorder assigns the new tab a fresh live alias; we bind the
+ *    fragment's popup alias to it and rewrite the signal so generated code is
+ *    coherent.
+ *
+ * Both `frame.pageAlias` (what tab an action targets) and popup signal
+ * `popupAlias` (what tab an action opens) are rewritten in place on the action
+ * objects, which are the same objects fed into codegen.
+ */
+export class AliasRemapper {
+  private readonly _pageAliases: Map<Page, string>;
+  // fragment alias -> live alias
+  private readonly _bindings = new Map<string, string>();
+  // live aliases already claimed by a fragment alias (so a later popup doesn't reuse one)
+  private readonly _claimedLiveAliases = new Set<string>();
+  // Live aliases present right before the current action executes; used to spot
+  // the fresh alias a popup-opening action creates.
+  private _liveBefore = new Set<string>();
+
+  constructor(pageAliases: Map<Page, string>, fragmentActions: actions.ActionInContext[], seedLiveAlias: string) {
+    this._pageAliases = pageAliases;
+    // Seed: the fragment's primary alias is whatever its first action targets.
+    const primaryFragmentAlias = fragmentActions[0]?.frame.pageAlias ?? 'page';
+    // Guard against a stale seed: if the last-recorded tab was closed,
+    // seedLiveAlias may no longer exist live, which would fail the first action
+    // with "page not found". Fall back to the main 'page' tab, else any live tab.
+    const liveAliases = new Set(pageAliases.values());
+    const seed = liveAliases.has(seedLiveAlias)
+      ? seedLiveAlias
+      : (liveAliases.has('page') ? 'page' : [...liveAliases][0]);
+    if (seed) {
+      this._bindings.set(primaryFragmentAlias, seed);
+      this._claimedLiveAliases.add(seed);
+    }
+  }
+
+  /** Rewrite the action's target tab to a live alias before it executes. */
+  beforeAction(action: actions.ActionInContext): void {
+    this._liveBefore = new Set(this._pageAliases.values());
+    const live = this._bindings.get(action.frame.pageAlias);
+    if (!live) {
+      // The action targets a tab whose opener was not in the replayed range
+      // (e.g. it was in a skipped prefix). We cannot reconstruct it.
+      throw new Error(`Cannot replay fragment: it acts on tab '${action.frame.pageAlias}' but the step that opened that tab is outside the selected range. Include the step that opens it, or choose a range that stays on one tab.`);
+    }
+    action.frame.pageAlias = live;
+    // Keep pageGuid consistent with the remapped alias: the JSONL export spreads
+    // the whole frame (incl. pageGuid), so a stale trace guid would leak into the
+    // combined recording. Point it at the live page now bound to this alias.
+    const livePage = [...this._pageAliases.entries()].find(([, a]) => a === live)?.[0];
+    if (livePage)
+      action.frame.pageGuid = livePage.guid;
+  }
+
+  /**
+   * After the action executes, bind any popup it opened and rewrite the popup
+   * signal's alias to the live one. Waits briefly for the new tab to register.
+   */
+  async afterAction(action: actions.ActionInContext): Promise<void> {
+    for (const signal of action.action.signals) {
+      if (signal.name !== 'popup')
+        continue;
+      const fresh = await this._waitForFreshLiveAlias();
+      if (!fresh)
+        continue;
+      this._bindings.set(signal.popupAlias, fresh);
+      this._claimedLiveAliases.add(fresh);
+      signal.popupAlias = fresh;
+    }
+  }
+
+  /** Poll the live alias map for a tab that appeared since beforeAction and is unclaimed. */
+  private async _waitForFreshLiveAlias(): Promise<string | undefined> {
+    for (let attempt = 0; attempt < 100; attempt++) {
+      const fresh = [...this._pageAliases.values()].find(a => !this._liveBefore.has(a) && !this._claimedLiveAliases.has(a));
+      if (fresh)
+        return fresh;
+      await new Promise<void>(resolve => setTimeout(resolve, 50));
+    }
+    // The expected popup never opened. Return undefined rather than guessing an
+    // unrelated unclaimed tab — binding to the wrong page would silently run
+    // later actions against it. Leaving the alias unbound makes the next action
+    // on it fail deterministically via beforeAction's guard.
+    return undefined;
+  }
+}

package/node_modules/playwright/node_modules/playwright-core/src/server/recorder/skyramp/replayEngine.ts

@@ -17,6 +17,7 @@
 import { urlMatches } from '../../../utils/isomorphic/urlMatch';
 import { performAction } from '../recorderRunner';
 
+import type { AliasRemapper } from './aliasRemapper';
 import type { Page } from '../../page';
 import type * as actions from '@recorder/actions';
 
@@ -81,6 +82,8 @@ export type ReplayEngineOptions = {
   stopCondition?: StopCondition;
   /** Delay in ms between actions. Default: 0 (no artificial delay). */
   delayBetweenActions?: number;
+  /** Optional page-alias remapper for replaying a fragment mid-recording (multi-tab). */
+  aliasRemapper?: AliasRemapper;
 };
 
 export class ReplayEngine {
@@ -95,10 +98,10 @@ export class ReplayEngine {
   delayBetweenActions: number;
 
   constructor(
-      pageAliases: Map<Page, string>,
-      actions: actions.ActionInContext[],
-      onActionCompleted: (action: actions.ActionInContext, index: number) => void,
-      opts: ReplayEngineOptions = {},
+    pageAliases: Map<Page, string>,
+    actions: actions.ActionInContext[],
+    onActionCompleted: (action: actions.ActionInContext, index: number) => void,
+    opts: ReplayEngineOptions = {},
   ) {
     this._pageAliases = pageAliases;
     this._actions = actions;
@@ -128,10 +131,25 @@ export class ReplayEngine {
       action.startTime = replayStart;
       (action.action as any).timestamp = replayStart.toString();
 
+      // Remap the action's target tab onto the live session before executing.
+      // Done for every action (incl. metadata-only ones like openPage) so the
+      // appended action objects carry live aliases for coherent codegen.
+      try {
+        this._opts.aliasRemapper?.beforeAction(action);
+      } catch (e) {
+        return {
+          completedCount,
+          stopReason: 'error',
+          error: { message: (e as Error).message, actionName: action.action.name, stepIndex: i + 1 },
+        };
+      }
+
       if (!_METADATA_ONLY_ACTIONS.has(action.action.name)) {
         try {
           await performAction(this._pageAliases, action, 30000);
           action.endTime = Date.now();
+          // Bind any popup this action opened to its fresh live alias.
+          await this._opts.aliasRemapper?.afterAction(action);
         } catch (e) {
           // Stop replay and surface the error so the user can take over.
           return {
@@ -156,8 +174,10 @@ export class ReplayEngine {
       });
 
       // Check stop condition AFTER executing so URL-based conditions fire
-      // right after the navigate that brought us to the target page.
-      const currentUrl = this._currentUrl();
+      // right after the navigate that brought us to the target page. Use the
+      // tab this action ran on (its alias is already remapped to a live alias),
+      // so URL stops work even when a fragment is remapped onto a non-'page' tab.
+      const currentUrl = this._currentUrl(action.frame.pageAlias);
       if (this._opts.stopCondition?.shouldStop(action, i, currentUrl))
         return { completedCount, stopReason: 'condition' };
 
@@ -176,9 +196,12 @@ export class ReplayEngine {
     return { completedCount, stopReason: 'done' };
   }
 
-  private _currentUrl(): string {
-    // Return the URL of the first (main) page.
-    const firstPage = [...this._pageAliases.keys()].find(p => this._pageAliases.get(p) === 'page');
-    return firstPage?.mainFrame().url() ?? '';
+  private _currentUrl(alias: string): string {
+    // URL of the tab the current action ran on; fall back to the main 'page'
+    // tab if that alias can't be resolved (e.g. it was closed).
+    const pages = [...this._pageAliases.keys()];
+    const page = pages.find(p => this._pageAliases.get(p) === alias)
+        ?? pages.find(p => this._pageAliases.get(p) === 'page');
+    return page?.mainFrame().url() ?? '';
   }
 }

package/node_modules/playwright/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/playwright",
-  "version": "1.58.2-skyramp.8.9.6",
+  "version": "1.58.2-skyramp.8.10.0",
   "description": "Skyramp's fork of Playwright with trace recording for UI test generation",
   "publishConfig": {
     "access": "public"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",
@@ -10,6 +10,10 @@
       "types": "./build/workspace/index.d.ts",
       "default": "./build/workspace/index.js"
     },
+    "./types": {
+      "types": "./build/types/index.d.ts",
+      "default": "./build/types/index.js"
+    },
     "./build/*": "./build/*"
   },
   "type": "module",
@@ -17,9 +21,12 @@
     "mcp": "./build/index.js"
   },
   "scripts": {
+    "prepare": "npm run build",
     "clean-build": "rm -rf build && npm run build",
     "build": "tsc && chmod 755 build/index.js",
     "build:prod": "tsc --sourceMap false && chmod 755 build/index.js",
+    "swap-core": "node scripts/swap-modified-core.mjs",
+    "prepack": "node scripts/swap-modified-core.mjs",
     "pack": "npm run build:prod && npm pack",
     "start": "node build/index.js",
     "test:startup": "time node build/index.js --help",
@@ -60,11 +67,11 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.3",
     "@playwright/test": "^1.55.0",
-    "@skyramp/skyramp": "1.3.28",
+    "@skyramp/skyramp": "1.3.29",
     "dockerode": "^5.0.0",
     "fast-glob": "^3.3.3",
     "js-yaml": "^4.1.1",
-    "playwright": "file:vendor/skyramp-playwright-1.58.2-skyramp.8.9.6.tgz",
+    "playwright": "file:vendor/skyramp-playwright-1.58.2-skyramp.8.10.0.tgz",
     "simple-git": "^3.30.0",
     "typescript": "^5.8.3",
     "zod": "^3.25.3"

package/node_modules/playwright/node_modules/playwright-core/bundles/mcp/node_modules/.bin/node-which

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-var which = require("../")
-if (process.argv.length < 3)
-  usage()
-
-function usage () {
-  console.error('usage: which [-as] program ...')
-  process.exit(1)
-}
-
-var all = false
-var silent = false
-var dashdash = false
-var args = process.argv.slice(2).filter(function (arg) {
-  if (dashdash || !/^-/.test(arg))
-    return true
-
-  if (arg === '--') {
-    dashdash = true
-    return false
-  }
-
-  var flags = arg.substr(1).split('')
-  for (var f = 0; f < flags.length; f++) {
-    var flag = flags[f]
-    switch (flag) {
-      case 's':
-        silent = true
-        break
-      case 'a':
-        all = true
-        break
-      default:
-        console.error('which: illegal option -- ' + flag)
-        usage()
-    }
-  }
-  return false
-})
-
-process.exit(args.reduce(function (pv, current) {
-  try {
-    var f = which.sync(current, { all: all })
-    if (all)
-      f = f.join('\n')
-    if (!silent)
-      console.log(f)
-    return pv;
-  } catch (e) {
-    return 1;
-  }
-}, 0))

package/node_modules/playwright/node_modules/playwright-core/bundles/utils/node_modules/.bin/is-docker

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-const isDocker = require('.');
-
-process.exitCode = isDocker() ? 0 : 2;

package/node_modules/playwright/node_modules/playwright-core/bundles/utils/node_modules/.bin/mime

@@ -1,46 +0,0 @@
-#!/usr/bin/env node
-
-'use strict';
-
-process.title = 'mime';
-let mime = require('.');
-let pkg = require('./package.json');
-let args = process.argv.splice(2);
-
-if (args.includes('--version') || args.includes('-v') || args.includes('--v')) {
-  console.log(pkg.version);
-  process.exit(0);
-} else if (args.includes('--name') || args.includes('-n') || args.includes('--n')) {
-  console.log(pkg.name);
-  process.exit(0);
-} else if (args.includes('--help') || args.includes('-h') || args.includes('--h')) {
-  console.log(pkg.name + ' - ' + pkg.description + '\n');
-  console.log(`Usage:
-
-  mime [flags] [path_or_extension]
-
-  Flags:
-    --help, -h                     Show this message
-    --version, -v                  Display the version
-    --name, -n                     Print the name of the program
-
-  Note: the command will exit after it executes if a command is specified
-  The path_or_extension is the path to the file or the extension of the file.
-
-  Examples:
-    mime --help
-    mime --version
-    mime --name
-    mime -v
-    mime src/log.js
-    mime new.py
-    mime foo.sh
-  `);
-  process.exit(0);
-}
-
-let file = args[0];
-let type = mime.getType(file);
-
-process.stdout.write(type + '\n');
-

package/node_modules/playwright/node_modules/playwright-core/bundles/utils/node_modules/.bin/yaml

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-
-import { UserError, cli, help } from './dist/cli.mjs'
-
-cli(process.stdin, error => {
-  if (error instanceof UserError) {
-    if (error.code === UserError.ARGS) console.error(`${help}\n`)
-    console.error(error.message)
-    process.exitCode = error.code
-  } else if (error) throw error
-})