roxxie-proxy-u-prod 0.1.0

package/source/packages/cdp/src/domains/Debugger.ts

@@ -0,0 +1,25 @@
+import connector from '../lib/connector'
+import * as scriptMananger from '../lib/scriptMananger'
+import each from 'licia/each'
+import Protocol from 'devtools-protocol'
+import Debugger = Protocol.Debugger
+
+let proxy = ''
+
+export function setProxy(params: any) {
+  proxy = params.proxy
+}
+
+export function enable() {
+  each(scriptMananger.getScripts(), script => {
+    connector.trigger('Debugger.scriptParsed', script)
+  })
+}
+
+export async function getScriptSource(
+  params: Debugger.GetScriptSourceRequest
+): Promise<Debugger.GetScriptSourceResponse> {
+  return {
+    scriptSource: await scriptMananger.getScriptSource(params.scriptId, proxy),
+  }
+}

package/source/packages/cdp/src/domains/IndexedDB.ts

@@ -0,0 +1,207 @@
+import each from 'licia/each'
+import map from 'licia/map'
+import isStr from 'licia/isStr'
+import isArr from 'licia/isArr'
+import * as objManager from '../lib/objManager'
+import Protocol from 'devtools-protocol'
+import IndexedDB = Protocol.IndexedDB
+
+const indexedDB = window.indexedDB
+
+let databaseVersions: any = {}
+
+export async function requestDatabaseNames(): Promise<IndexedDB.RequestDatabaseNamesResponse> {
+  const databases = await indexedDB.databases()
+  const databaseNames: string[] = []
+
+  databaseVersions = {}
+  each(databases, database => {
+    if (!database.name) {
+      return
+    }
+    databaseVersions[database.name] = database.version
+    databaseNames.push(database.name)
+  })
+
+  return {
+    databaseNames,
+  }
+}
+
+export async function requestDatabase(
+  params: IndexedDB.RequestDatabaseRequest
+): Promise<IndexedDB.RequestDatabaseResponse> {
+  const { databaseName } = params
+  const version = databaseVersions[databaseName]
+  const objectStores: any[] = []
+
+  const db = await promisify(indexedDB.open(databaseName))
+  if (db.objectStoreNames.length) {
+    const storeList = map(db.objectStoreNames, name => {
+      return db.transaction(name, 'readonly').objectStore(name)
+    })
+    each(storeList, store => {
+      const indexes: any[] = []
+      each(store.indexNames, indexName => {
+        const index = store.index(indexName)
+        indexes.push({
+          name: index.name,
+          multiEntry: index.multiEntry,
+          keyPath: formatKeyPath(index.keyPath),
+          unique: index.unique,
+        })
+      })
+      objectStores.push({
+        name: store.name,
+        indexes,
+        keyPath: formatKeyPath(store.keyPath),
+        autoIncrement: store.autoIncrement,
+      })
+    })
+  }
+
+  return {
+    databaseWithObjectStores: {
+      name: databaseName,
+      objectStores,
+      version,
+    },
+  }
+}
+
+export async function requestData(
+  params: IndexedDB.RequestDataRequest
+): Promise<IndexedDB.RequestDataResponse> {
+  const { databaseName, objectStoreName, indexName, pageSize, skipCount } =
+    params
+
+  const db = await promisify(indexedDB.open(databaseName))
+  const objectStore = db
+    .transaction(objectStoreName, 'readonly')
+    .objectStore(objectStoreName)
+  const count = await promisify(objectStore.count())
+
+  let currentIdx = 0
+  let cursorRequest: IDBRequest<IDBCursorWithValue | null>
+  if (indexName) {
+    const index = objectStore.index(indexName)
+    cursorRequest = index.openCursor()
+  } else {
+    cursorRequest = objectStore.openCursor()
+  }
+  return new Promise((resolve, reject) => {
+    const objectStoreDataEntries: any[] = []
+    cursorRequest.addEventListener('success', () => {
+      const cursor = cursorRequest.result
+      if (cursor && currentIdx < pageSize + skipCount) {
+        if (currentIdx >= skipCount) {
+          objectStoreDataEntries.push({
+            key: objManager.wrap(cursor.key, {
+              generatePreview: true,
+            }),
+            primaryKey: objManager.wrap(cursor.primaryKey),
+            value: objManager.wrap(cursor.value, {
+              generatePreview: true,
+            }),
+          })
+        }
+        cursor.continue()
+        currentIdx++
+      } else {
+        resolve({
+          hasMore: currentIdx < count,
+          objectStoreDataEntries,
+        })
+      }
+    })
+    cursorRequest.addEventListener('error', reject)
+  })
+}
+
+export async function getMetadata(
+  params: IndexedDB.GetMetadataRequest
+): Promise<IndexedDB.GetMetadataResponse> {
+  const { databaseName, objectStoreName } = params
+
+  const objectStore = await getObjectStore(databaseName, objectStoreName)
+
+  return {
+    entriesCount: await promisify(objectStore.count()),
+    keyGeneratorValue: 1,
+  }
+}
+
+export async function deleteObjectStoreEntries(
+  params: IndexedDB.DeleteObjectStoreEntriesRequest
+) {
+  const { databaseName, objectStoreName, keyRange } = params
+
+  const objectStore = await getObjectStore(databaseName, objectStoreName)
+  await promisify(
+    objectStore.delete(
+      IDBKeyRange.bound(
+        getKeyRangeBound(keyRange.lower),
+        getKeyRangeBound(keyRange.upper),
+        keyRange.lowerOpen,
+        keyRange.upperOpen
+      )
+    )
+  )
+}
+
+export async function clearObjectStore(
+  params: IndexedDB.ClearObjectStoreRequest
+) {
+  const { databaseName, objectStoreName } = params
+
+  const objectStore = await getObjectStore(databaseName, objectStoreName)
+  await promisify(objectStore.clear())
+}
+
+export async function deleteDatabase(params: IndexedDB.DeleteDatabaseRequest) {
+  await promisify(indexedDB.deleteDatabase(params.databaseName))
+}
+
+function getKeyRangeBound(key: any) {
+  return key.number || key.string || key.date || key.array || key
+}
+
+async function getObjectStore(databaseName: string, objectStoreName: string) {
+  const db = await promisify(indexedDB.open(databaseName))
+  const objectStore = db
+    .transaction(objectStoreName, 'readwrite')
+    .objectStore(objectStoreName)
+
+  return objectStore
+}
+
+function formatKeyPath(keyPath: any) {
+  if (isStr(keyPath)) {
+    return {
+      type: 'string',
+      string: keyPath,
+    }
+  }
+
+  if (isArr(keyPath)) {
+    return {
+      type: 'array',
+      array: keyPath,
+    }
+  }
+
+  return {
+    type: 'null',
+  }
+}
+
+function promisify<T = any>(req: IDBRequest<T>): Promise<T> {
+  return new Promise((resolve, reject) => {
+    req.addEventListener('success', () => {
+      resolve(req.result)
+    })
+    req.addEventListener('error', () => {
+      reject()
+    })
+  })
+}

package/source/packages/cdp/src/domains/Input.ts

@@ -0,0 +1,177 @@
+import isUndef from 'licia/isUndef'
+import toBool from 'licia/toBool'
+import Protocol from 'devtools-protocol'
+import Input = Protocol.Input
+
+let isClick = false
+
+export function emulateTouchFromMouseEvent(
+  params: Input.EmulateTouchFromMouseEventRequest
+) {
+  const { type, x, y, deltaX, deltaY } = params
+
+  const el = document.elementFromPoint(x, y) || document.documentElement
+
+  switch (type) {
+    case 'mousePressed':
+      isClick = true
+      triggerTouchEvent('touchstart', el, x, y)
+      break
+    case 'mouseMoved':
+      isClick = false
+      triggerTouchEvent('touchmove', el, x, y)
+      break
+    case 'mouseReleased':
+      triggerTouchEvent('touchend', el, x, y)
+      if (isClick) {
+        triggerMouseEvent('click', el, x, y)
+      }
+      isClick = false
+      break
+    case 'mouseWheel':
+      if (!isUndef(deltaX) && !isUndef(deltaY)) {
+        triggerScroll(el, deltaX, deltaY)
+      }
+      break
+  }
+}
+
+export function dispatchMouseEvent(params: Input.DispatchMouseEventRequest) {
+  const { type, x, y, deltaX, deltaY } = params
+
+  const el = document.elementFromPoint(x, y) || document.documentElement
+
+  switch (type) {
+    case 'mousePressed':
+      isClick = true
+      triggerMouseEvent('mousedown', el, x, y)
+      break
+    case 'mouseMoved':
+      isClick = false
+      triggerMouseEvent('mousemove', el, x, y)
+      break
+    case 'mouseReleased':
+      triggerMouseEvent('mouseup', el, x, y)
+      if (isClick) {
+        triggerMouseEvent('click', el, x, y)
+      }
+      isClick = false
+      break
+    case 'mouseWheel':
+      if (!isUndef(deltaX) && !isUndef(deltaY)) {
+        triggerScroll(el, deltaX, deltaY)
+      }
+      break
+  }
+}
+
+export function dispatchKeyEvent(params: Input.DispatchKeyEventRequest) {
+  let { type, text, key, code, modifiers } = params
+  modifiers ??= 0
+
+  const event = new KeyboardEvent(type, {
+    bubbles: true,
+    cancelable: true,
+    composed: true,
+    key,
+    code,
+    altKey: !!(modifiers & 1),
+    ctrlKey: !!(modifiers & 2),
+    metaKey: !!(modifiers & 4),
+    shiftKey: !!(modifiers & 8),
+  })
+
+  if (text) {
+    Object.defineProperty(event, 'data', {
+      get() {
+        return text
+      },
+    })
+  }
+  if (params.type == "keyDown") {
+    let active = document.activeElement as HTMLInputElement | HTMLTextAreaElement;
+    if (active && (active.tagName === 'INPUT' || active.tagName === 'TEXTAREA')) {
+      if (key === "Enter") {
+        if (active.form) {
+          active.form.requestSubmit();
+        }
+      }
+
+
+
+      // If the active element is an input or textarea, set the value
+      if (text) {
+        active.value += text;
+        active.dispatchEvent(new Event('input', { bubbles: true }));
+      }
+    }
+  }
+
+  document.dispatchEvent(event)
+}
+
+function triggerMouseEvent(type: string, el: Element, x: number, y: number) {
+  el.dispatchEvent(
+    new MouseEvent(type, {
+      bubbles: true,
+      cancelable: true,
+      view: window,
+      clientX: x,
+      clientY: y,
+    })
+  )
+}
+
+function triggerTouchEvent(type: string, el: Element, x: number, y: number) {
+  const touch = new Touch({
+    identifier: 0,
+    target: el,
+    clientX: x,
+    clientY: y,
+    force: 1,
+  })
+
+  el.dispatchEvent(
+    new TouchEvent(type, {
+      bubbles: true,
+      touches: [touch],
+      changedTouches: [touch],
+      targetTouches: [touch],
+    })
+  )
+}
+
+function triggerScroll(el: Element, deltaX: number, deltaY: number) {
+  el = findScrollableEl(el, deltaX, deltaY)
+  el.scrollLeft -= deltaX
+  el.scrollTop -= deltaY
+}
+
+function findScrollableEl(el: Element | null, deltaX: number, deltaY: number) {
+  while (el) {
+    if (toBool(deltaX) && isScrollable(el, 'x')) {
+      return el
+    }
+    if (toBool(deltaY) && isScrollable(el, 'y')) {
+      return el
+    }
+
+    el = el.parentElement
+  }
+
+  return el || document.documentElement
+}
+
+function isScrollable(el: Element, direction: 'x' | 'y') {
+  const computedStyle = getComputedStyle(el)
+
+  if (direction === 'x') {
+    return (
+      el.scrollWidth > el.clientWidth && computedStyle.overflowX !== 'hidden'
+    )
+  }
+
+  return (
+    el.scrollHeight > el.clientHeight && computedStyle.overflowY !== 'hidden'
+  )
+}

package/source/packages/cdp/src/domains/Network.ts

@@ -0,0 +1,251 @@
+import trim from 'licia/trim'
+import each from 'licia/each'
+import decodeUriComponent from 'licia/decodeUriComponent'
+import types from 'licia/types'
+import connector from '../lib/connector'
+import Protocol from 'devtools-protocol'
+import Network = Protocol.Network
+import { contain, convertBin, isBlob, isStr, isUndef, now } from 'licia'
+import { createId } from '../lib/util'
+
+export function getCookies(): Network.GetCookiesResponse {
+  const cookies: any[] = []
+
+  const cookie = document.cookie
+  if (trim(cookie) !== '') {
+    each(cookie.split(';'), function (value: any) {
+      value = value.split('=')
+      const name = trim(value.shift())
+      value = decodeUriComponent(value.join('='))
+      cookies.push({
+        name,
+        value,
+      })
+    })
+  }
+
+  return { cookies }
+}
+
+let isEnable = false
+
+export const enable = function () {
+  isEnable = true
+  each(triggers, trigger => trigger())
+  triggers = []
+}
+
+function enableWebSocket() {
+  const origWebSocket = window.WebSocket
+  function WebSocket(url: string, protocols?: string | string[]) {
+    const ws = new origWebSocket(url, protocols)
+
+    if (!isValidUrl(url)) {
+      return ws
+    }
+
+    const requestId = createId()
+
+    trigger('Network.webSocketCreated', {
+      requestId,
+      url,
+    })
+
+    ws.addEventListener('open', function () {
+      trigger('Network.webSocketWillSendHandshakeRequest', {
+        requestId,
+        timestamp: now() / 1000,
+        request: {
+          headers: {},
+        },
+      })
+      trigger('Network.webSocketHandshakeResponseReceived', {
+        requestId,
+        timeStamp: now() / 1000,
+        response: {
+          status: 101,
+          statusText: 'Switching Protocols',
+        },
+      })
+    })
+
+    ws.addEventListener('message', async function (e) {
+      let payloadData = e.data
+      if (isUndef(payloadData)) {
+        return
+      }
+
+      let opcode = 1
+      if (!isStr(payloadData)) {
+        opcode = 2
+        if (isBlob(payloadData)) {
+          payloadData = await convertBin.blobToArrBuffer(payloadData)
+        }
+        payloadData = convertBin(payloadData, 'base64')
+      }
+
+      trigger('Network.webSocketFrameReceived', {
+        requestId,
+        timestamp: now() / 1000,
+        response: {
+          opcode,
+          payloadData,
+        },
+      })
+    })
+
+    const origSend = ws.send
+    ws.send = function (data: any) {
+      if (!isUndef(data)) {
+        frameSent(data)
+      }
+
+      return origSend.call(this, data)
+    }
+
+    async function frameSent(data: any) {
+      let opcode = 1
+      let payloadData = data
+      if (!isStr(data)) {
+        opcode = 2
+        if (isBlob(payloadData)) {
+          payloadData = await convertBin.blobToArrBuffer(payloadData)
+        }
+        payloadData = convertBin(data, 'base64')
+      }
+
+      trigger('Network.webSocketFrameSent', {
+        requestId,
+        timestamp: now() / 1000,
+        response: {
+          opcode,
+          payloadData,
+        },
+      })
+    }
+
+    ws.addEventListener('close', function () {
+      trigger('Network.webSocketClosed', {
+        requestId,
+        timestamp: now() / 1000,
+      })
+    })
+
+    ws.addEventListener('error', function () {
+      trigger('Network.webSocketFrameError', {
+        requestId,
+        timestamp: now() / 1000,
+        errorMessage: 'WebSocket error',
+      })
+    })
+
+    return ws
+  }
+  WebSocket.prototype = origWebSocket.prototype
+  WebSocket.CLOSED = origWebSocket.CLOSED
+  WebSocket.CLOSING = origWebSocket.CLOSING
+  WebSocket.CONNECTING = origWebSocket.CONNECTING
+  WebSocket.OPEN = origWebSocket.OPEN
+  window.WebSocket = WebSocket as any
+}
+
+function isValidUrl(url: string) {
+  return !contain(url, '__chobitsu-hide__=true')
+}
+
+let triggers: types.AnyFn[] = []
+
+function trigger(method: string, params: any) {
+  if (isEnable) {
+    connector.trigger(method, params)
+  } else {
+    triggers.push(() => connector.trigger(method, params))
+  }
+}
+
+enableWebSocket()
+
+// TODO: this is horrible, there should only be one chobitsu
+// @ts-expect-error
+if (document.currentScript!.src!.includes("chii")) {
+  // TODO: this needs to get the message from the parent somehow
+  (self as any)[Symbol.for("scramjet client global")].serviceWorker.addEventListener("message", async (event: any) => {
+    if (event.data.type === "scramjet-request") {
+      let requestData = event.data.data;
+      if (requestData.body && requestData.body instanceof ReadableStream) {
+      	try {
+      		const reader = requestData.body.getReader();
+      		const chunks = [];
+      		let done, value;
+
+      		while (!done) {
+      			({ done, value } = await reader.read());
+      			if (value) {
+      				chunks.push(value);
+      			}
+      		}
+
+      		// Convert chunks to text
+      		const blob = new Blob(chunks);
+      		requestData.payload = await blob.text();
+      	} catch (error) {
+      		console.error("Error reading request body stream:", error);
+      		requestData.payload = "[Error reading request body]";
+      	}
+      }
+
+
+      trigger("Network.requestWillBeSent", {
+        requestId: "1." + String(requestData.id),
+        type: "Fetch",
+        request: {
+          method: requestData.method,
+          url: requestData.url,
+          headers: {},
+        },
+        timestamp: now() / 1000,
+      })
+
+    } else if (event.data.type === "scramjet-response") {
+      // Check if there's a transferred stream in the message
+      let responseData = event.data.data;
+      console.log(responseData);
+
+      // Handle transferred stream for response body
+      // The stream is included directly in the data object
+      if (responseData.body && responseData.body instanceof ReadableStream) {
+        try {
+          const reader = responseData.body.getReader();
+          const chunks = [];
+          let done, value;
+
+          while (!done) {
+            ({ done, value } = await reader.read());
+            if (value) {
+              chunks.push(value);
+            }
+          }
+
+          // Convert chunks to text
+          const blob = new Blob(chunks);
+          responseData.responseBody = await blob.text();
+          responseData.responseSize = responseData.responseBody.length;
+        } catch (error) {
+          console.error("Error reading response body stream:", error);
+          responseData.responseBody = "[Error reading response body]";
+        }
+      }
+
+      connector.trigger("Network.responseReceived", {
+        requestId: responseData.id,
+        type: "Fetch",
+        response: {
+          status: responseData.status,
+          headers: responseData.resHeaders,
+        },
+        timestamp: responseData.time / 1000,
+      });
+    }
+  });
+
+}