roxxie-proxy-u-prod 0.1.0

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

@@ -0,0 +1,273 @@
+import connector from '../lib/connector'
+import each from 'licia/each'
+import map from 'licia/map'
+import now from 'licia/now'
+import isStr from 'licia/isStr'
+import fnParams from 'licia/fnParams'
+import uncaught from 'licia/uncaught'
+import startWith from 'licia/startWith'
+import stackTrace from 'licia/stackTrace'
+import trim from 'licia/trim'
+import types from 'licia/types'
+import * as objManager from '../lib/objManager'
+import evaluateJs, { setGlobal } from '../lib/evaluate'
+import Protocol from 'devtools-protocol'
+import Runtime = Protocol.Runtime
+
+const executionContext = {
+  id: 1,
+  name: 'top',
+  origin: location.origin,
+}
+
+export async function callFunctionOn(
+  params: Runtime.CallFunctionOnRequest
+): Promise<Runtime.CallFunctionOnResponse> {
+  const { functionDeclaration, objectId } = params
+  let args = params.arguments || []
+
+  args = map(args, (arg: any) => {
+    const { objectId, value } = arg
+    if (objectId) {
+      const obj = objManager.getObj(objectId)
+      if (obj) return obj
+    }
+
+    return value
+  })
+
+  let ctx = null
+  if (objectId) {
+    ctx = objManager.getObj(objectId)
+  }
+
+  let object;
+  let exception;
+  let threw = false;
+  try {
+    object = await callFn(functionDeclaration, args, ctx);
+  } catch (e) {
+    exception = e;
+    threw = true;
+  }
+
+  const ret: any = {};
+
+  if (threw) {
+    console.error(exception);
+    ret.exceptionDetails = {
+      exceptionId: 1,
+      text: "Uncaught",
+      lineNumber: 0, // TODO
+      columnNumber: 0, // TODO
+      stackTrace: { callFrames: [] }, // TODO
+      exception: objManager.wrap(exception, {
+        generatePreview: true,
+      })
+    };
+  } else {
+    const result = objManager.wrap(object, {
+      generatePreview: true,
+    });
+    if (params.returnByValue) {
+      result.value  = structuredClone(object);
+    }
+
+    ret.result = result;
+  }
+
+  return ret
+}
+
+let isEnable = false
+
+
+declare var $chobitsuPageId: string;
+export function enable() {
+  isEnable = true
+  each(triggers, trigger => trigger())
+  triggers = []
+
+  trigger('Runtime.executionContextCreated', {
+    context: executionContext,
+    auxData: {
+      isDefault: true,
+      type: 'default',
+      frameId: $chobitsuPageId,
+    },
+  })
+}
+
+export function getProperties(
+  params: Runtime.GetPropertiesRequest
+): Runtime.GetPropertiesResponse {
+  return objManager.getProperties(params)
+}
+
+export function evaluate(
+  params: Runtime.EvaluateRequest
+): Runtime.EvaluateResponse {
+  const ret: any = {}
+
+  let result: any
+  try {
+    if (params.throwOnSideEffect && hasSideEffect(params.expression)) {
+      throw EvalError('Possible side-effect in debug-evaluate')
+    }
+    result = evaluateJs(params.expression)
+    setGlobal('$_', result)
+    ret.result = objManager.wrap(result, {
+      generatePreview: true,
+    })
+  } catch (e) {
+    ret.exceptionDetails = {
+      exception: objManager.wrap(e),
+      text: 'Uncaught',
+    }
+    ret.result = objManager.wrap(e, {
+      generatePreview: true,
+    })
+  }
+
+  return ret
+}
+
+export function releaseObject(params: Runtime.ReleaseObjectRequest) {
+  objManager.releaseObj(params.objectId)
+}
+
+export function globalLexicalScopeNames() {
+  return {
+    names: [],
+  }
+}
+
+declare const console: any
+
+function monitorConsole() {
+  const methods: any = {
+    log: 'log',
+    warn: 'warning',
+    error: 'error',
+    info: 'info',
+    dir: 'dir',
+    table: 'table',
+    group: 'startGroup',
+    groupCollapsed: 'startGroupCollapsed',
+    groupEnd: 'endGroup',
+    debug: 'debug',
+    clear: 'clear',
+  }
+
+  each(methods, (type, name) => {
+    if (!console[name]) {
+      return
+    }
+    const origin = console[name].bind(console)
+    console[name] = (...args: any[]) => {
+      origin(...args)
+
+      args = map(args, arg =>
+        objManager.wrap(arg, {
+          generatePreview: true,
+        })
+      )
+
+      trigger('Runtime.consoleAPICalled', {
+        type,
+        args,
+        stackTrace: {
+          callFrames:
+            type === 'error' || type === 'warning' ? getCallFrames() : [],
+        },
+        executionContextId: executionContext.id,
+        timestamp: now(),
+      })
+    }
+  })
+}
+
+const Function = window.Function
+/* eslint-disable-next-line */
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor
+
+function parseFn(fnStr: string) {
+  const result = fnParams(fnStr)
+
+  if (fnStr[fnStr.length - 1] !== '}') {
+    result.push('return ' + fnStr.slice(fnStr.indexOf('=>') + 2))
+  } else {
+    result.push(fnStr.slice(fnStr.indexOf('{') + 1, fnStr.lastIndexOf('}')))
+  }
+
+  return result
+}
+
+async function callFn(
+  functionDeclaration: string,
+  args: any[],
+  ctx: any = null
+) {
+  const fnParams = parseFn(functionDeclaration)
+  let fn
+
+  if (startWith(functionDeclaration, 'async')) {
+    fn = AsyncFunction.apply(null, fnParams)
+    return await fn.apply(ctx, args)
+  }
+
+  fn = Function.apply(null, fnParams)
+  return fn.apply(ctx, args)
+}
+
+uncaught.addListener(err => {
+  trigger('Runtime.exceptionThrown', {
+    exceptionDetails: {
+      exception: objManager.wrap(err),
+      stackTrace: { callFrames: getCallFrames(err) },
+      text: 'Uncaught',
+    },
+    timestamp: now,
+  })
+})
+
+function hasSideEffect(code: string) {
+  return !/^[a-zA-Z0-9]*$/.test(code)
+}
+
+function getCallFrames(error?: Error) {
+  let callFrames: any[] = []
+  const callSites: any = error ? error.stack : stackTrace()
+  if (isStr(callSites)) {
+    callFrames = callSites.split('\n')
+    if (!error) {
+      callFrames.shift()
+    }
+    callFrames.shift()
+    callFrames = map(callFrames, val => ({ functionName: trim(val) }))
+  } else if (callSites) {
+    callSites.shift()
+    callFrames = map(callSites, (callSite: any) => {
+      return {
+        functionName: callSite.getFunctionName(),
+        lineNumber: callSite.getLineNumber(),
+        columnNumber: callSite.getColumnNumber(),
+        url: callSite.getFileName(),
+      }
+    })
+  }
+  return callFrames
+}
+
+let triggers: types.AnyFn[] = []
+
+function trigger(method: string, params: any) {
+  if (isEnable) {
+    connector.trigger(method, params)
+  } else {
+    triggers.push(() => connector.trigger(method, params))
+  }
+}
+
+uncaught.start()
+monitorConsole()

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

@@ -0,0 +1,71 @@
+import each from 'licia/each'
+import rmCookie from 'licia/rmCookie'
+import safeStorage from 'licia/safeStorage'
+import connector from '../lib/connector'
+import { getCookies } from './Network'
+import Protocol from 'devtools-protocol'
+import Storage = Protocol.Storage
+
+const localStore = safeStorage('local')
+const sessionStore = safeStorage('session')
+
+export function getUsageAndQuota(): Storage.GetUsageAndQuotaResponse {
+  return {
+    quota: 0,
+    usage: 0,
+    overrideActive: false,
+    usageBreakdown: [],
+  }
+}
+
+export function clearDataForOrigin(params: Storage.ClearDataForOriginRequest) {
+  const storageTypes = params.storageTypes.split(',')
+
+  each(storageTypes, type => {
+    if (type === 'cookies') {
+      const cookies = getCookies().cookies
+      each(cookies, ({ name }) => rmCookie(name))
+    } else if (type === 'local_storage') {
+      localStore.clear()
+      sessionStore.clear()
+    }
+  })
+}
+
+export function getTrustTokens(): Storage.GetTrustTokensResponse {
+  return {
+    tokens: [],
+  }
+}
+
+export function getStorageKeyForFrame(): Storage.GetStorageKeyForFrameResponse {
+  return {
+    storageKey: location.origin,
+  }
+}
+
+export function getSharedStorageMetadata(): Storage.GetSharedStorageMetadataResponse {
+  return {
+    metadata: {
+      creationTime: 0,
+      length: 0,
+      remainingBudget: 0,
+      bytesUsed: 0,
+    },
+  }
+}
+
+export function setStorageBucketTracking() {
+  connector.trigger('Storage.storageBucketCreatedOrUpdated', {
+    bucketInfo: {
+      bucket: {
+        storageKey: location.origin,
+      },
+      durability: 'relaxed',
+      expiration: 0,
+      id: '0',
+      persistent: false,
+      quota: 0,
+    },
+  })
+}

package/source/packages/cdp/src/index.d.ts

@@ -0,0 +1,8 @@
+declare const chobitsu: {
+  domain(name: string): { [index: string]: (...args: any[]) => any }
+  sendRawMessage(message: string): void
+  sendMessage(method: string, params?: any): Promise<any>
+  setOnMessage(onMessage: (message: string) => void): void
+}
+
+export = chobitsu

package/source/packages/cdp/src/index.ts

@@ -0,0 +1,153 @@
+import 'core-js/stable/object/assign'
+import 'core-js/stable/promise'
+import 'core-js/modules/es.map'
+import Chobitsu from './Chobitsu'
+import noop from 'licia/noop'
+import * as Runtime from './domains/Runtime'
+import * as Page from './domains/Page'
+import * as DOM from './domains/DOM'
+import * as CSS from './domains/CSS'
+import * as DOMStorage from './domains/DOMStorage'
+import * as Network from './domains/Network'
+import * as Overlay from './domains/Overlay'
+import * as DOMDebugger from './domains/DOMDebugger'
+import * as Debugger from './domains/Debugger'
+import * as Storage from './domains/Storage'
+import * as CacheStorage from './domains/CacheStorage'
+import * as IndexedDB from './domains/IndexedDB'
+import * as Input from './domains/Input'
+
+const chobitsu = new Chobitsu()
+chobitsu.register('Network', {
+  ...Network,
+  setAttachDebugStack: noop,
+  clearAcceptedEncodingsOverride: noop,
+})
+chobitsu.register('Page', {
+  ...Page,
+  getManifestIcons: noop,
+  bringToFront: noop,
+  getInstallabilityErrors: noop,
+  setAdBlockingEnabled: noop,
+  getAppId: noop,
+})
+chobitsu.register('Runtime', {
+  ...Runtime,
+  getExceptionDetails: noop,
+  compileScript: noop,
+  discardConsoleEntries: noop,
+  getHeapUsage: noop,
+  getIsolateId: noop,
+  releaseObject: noop,
+  releaseObjectGroup: noop,
+  runIfWaitingForDebugger: noop,
+})
+chobitsu.register('DOM', {
+  ...DOM,
+  pushNodeByPathToFrontend: noop,
+  getNodeId: DOM.getDOMNodeId,
+  getNode: DOM.getDOMNode,
+  markUndoableState: noop,
+  undo: noop,
+  getBoxModel: noop,
+})
+chobitsu.register('CSS', {
+  ...CSS,
+  getPlatformFontsForNode: noop,
+  trackComputedStyleUpdates: noop,
+  takeComputedStyleUpdates: noop,
+})
+chobitsu.register('Debugger', {
+  ...Debugger,
+  getPossibleBreakpoints: noop,
+  setBreakpointByUrl: noop,
+  setBreakpointsActive: noop,
+  setAsyncCallStackDepth: noop,
+  setBlackboxPatterns: noop,
+  setPauseOnExceptions: noop,
+})
+chobitsu.register('Overlay', {
+  ...Overlay,
+  setPausedInDebuggerMessage: noop,
+  highlightFrame: noop,
+  setShowGridOverlays: noop,
+  setShowFlexOverlays: noop,
+  setShowScrollSnapOverlays: noop,
+  setShowContainerQueryOverlays: noop,
+  setShowIsolatedElements: noop,
+})
+chobitsu.register('Profiler', {
+  enable: noop,
+})
+chobitsu.register('Log', {
+  clear: noop,
+  enable: noop,
+  startViolationsReport: noop,
+})
+chobitsu.register('Emulation', {
+  setEmulatedMedia: noop,
+  setAutoDarkModeOverride: noop,
+  setEmulatedVisionDeficiency: noop,
+  setFocusEmulationEnabled: noop,
+  setTouchEmulationEnabled: noop,
+  setEmitTouchEventsForMouse: noop,
+})
+chobitsu.register('Audits', {
+  enable: noop,
+})
+chobitsu.register('ServiceWorker', {
+  enable: noop,
+})
+chobitsu.register('Inspector', {
+  enable: noop,
+})
+chobitsu.register('Target', {
+  setAutoAttach: noop,
+  setDiscoverTargets: noop,
+  setRemoteLocations: noop,
+})
+chobitsu.register('DOMDebugger', {
+  ...DOMDebugger,
+  setBreakOnCSPViolation: noop,
+})
+chobitsu.register('Database', {
+  enable: noop,
+})
+chobitsu.register('CacheStorage', {
+  ...CacheStorage,
+})
+chobitsu.register('Storage', {
+  ...Storage,
+  setInterestGroupTracking: noop,
+  setSharedStorageTracking: noop,
+  trackIndexedDBForStorageKey: noop,
+  untrackCacheStorageForOrigin: noop,
+  untrackIndexedDBForOrigin: noop,
+  trackCacheStorageForOrigin: noop,
+  trackIndexedDBForOrigin: noop,
+})
+chobitsu.register('DOMStorage', {
+  ...DOMStorage,
+})
+chobitsu.register('IndexedDB', {
+  enable: noop,
+  ...IndexedDB,
+})
+chobitsu.register('ApplicationCache', {
+  enable: noop,
+  getFramesWithManifests: noop,
+})
+chobitsu.register('BackgroundService', {
+  startObserving: noop,
+})
+chobitsu.register('HeapProfiler', {
+  enable: noop,
+})
+chobitsu.register('Input', {
+  ...Input,
+})
+chobitsu.register('Autofill', {
+  enable: noop,
+})
+
+export default chobitsu

package/source/packages/cdp/src/lib/connector.ts

@@ -0,0 +1,15 @@
+import Emitter from 'licia/Emitter'
+
+class Connector extends Emitter {
+  trigger(method: string, params: any) {
+    this.emit(
+      'message',
+      JSON.stringify({
+        method,
+        params,
+      })
+    )
+  }
+}
+
+export default new Connector()

package/source/packages/cdp/src/lib/constants.ts

@@ -0,0 +1 @@
+export const MAIN_FRAME_ID = '1'

package/source/packages/cdp/src/lib/evaluate.ts

@@ -0,0 +1,59 @@
+import isStr from 'licia/isStr'
+import copy from 'licia/copy'
+import toArr from 'licia/toArr'
+import keys from 'licia/keys'
+import xpath from 'licia/xpath'
+import each from 'licia/each'
+
+const global: any = {
+  copy(value: any) {
+    if (!isStr(value)) value = JSON.stringify(value, null, 2)
+    copy(value)
+  },
+  $(selector: string) {
+    return document.querySelector(selector)
+  },
+  $$(selector: string) {
+    return toArr(document.querySelectorAll(selector))
+  },
+  $x(path: string) {
+    return xpath(path)
+  },
+  keys,
+}
+
+declare const window: any
+
+function injectGlobal() {
+  each(global, (val, name) => {
+    if (window[name]) return
+
+    window[name] = val
+  })
+}
+
+function clearGlobal() {
+  each(global, (val, name) => {
+    if (window[name] && window[name] === val) {
+      delete window[name]
+    }
+  })
+}
+
+export function setGlobal(name: string, val: any) {
+  global[name] = val
+}
+
+export default function evaluate(expression: string) {
+  let ret
+
+  injectGlobal()
+  try {
+    ret = eval.call(window, `(${expression})`)
+  } catch (e) {
+    ret = eval.call(window, expression)
+  }
+  clearGlobal()
+
+  return ret
+}

package/source/packages/cdp/src/lib/mutationObserver.ts

@@ -0,0 +1,39 @@
+import Emitter from 'licia/Emitter'
+import each from 'licia/each'
+
+class Observer extends Emitter {
+  private observer: MutationObserver
+  constructor() {
+    super()
+    this.observer = new MutationObserver(mutations => {
+      each(mutations, mutation => this.handleMutation(mutation))
+    })
+  }
+  observe(node: Node) {
+    this.observer.observe(node, {
+      attributes: true,
+      childList: true,
+      characterData: true,
+      subtree: true,
+    })
+  }
+  disconnect() {
+    this.observer.disconnect()
+  }
+  private handleMutation(mutation: MutationRecord) {
+    if (mutation.type === 'attributes') {
+      this.emit('attributes', mutation.target, mutation.attributeName)
+    } else if (mutation.type === 'childList') {
+      this.emit(
+        'childList',
+        mutation.target,
+        mutation.addedNodes,
+        mutation.removedNodes
+      )
+    } else if (mutation.type === 'characterData') {
+      this.emit('characterData', mutation.target)
+    }
+  }
+}
+
+export default new Observer()