rxliuli | 琉璃修改

browser.devtools.inspectedWindow.eval(`__zenfs__.readdir('/')`)

browser.devtools.inspectedWindow.eval(`await __zenfs__.promises.readdir('/')`)

browser.devtools.inspectedWindow.eval(
`await __zenfs__.promises.readFile('/test.png')`,
)

// entrypoints/main-content.ts
import { expose, windowEndpoint } from 'comlink'

export default defineUnlistedScript(() => {
const map = new Map<string, ArrayBuffer>()

interface IFS {
readFile: (path: string) => Promise<ArrayBuffer>
writeFile: (path: string, data: ArrayBuffer) => Promise<void>
readdir: (path: string) => Promise<string[]>
  }

expose(
    {
readFile: async (path: string) => {
return map.get(path) || new Uint8Array([1, 2, 3]).buffer
      },
writeFile: async (path: string, data: ArrayBuffer) => {
        map.set(path, data)
      },
readdir: async (path: string) => {
return Array.from(map.keys()).filter((p) => p.startsWith(path))
      },
    } as IFS,
windowEndpoint(
      (document.querySelector('#inject-iframe')! as HTMLIFrameElement)
        .contentWindow!,
    ),
  )
console.log('main-content')
})

// entrypoints/iframe/main.ts
import { expose, transfer, windowEndpoint, wrap } from 'comlink'

interface IFS {
readFile: (path: string) => Promise<ArrayBuffer>
writeFile: (path: string, data: ArrayBuffer) => Promise<void>
readdir: (path: string) => Promise<string[]>
}

async function main() {
const tabId = (await browser.tabs.getCurrent())!.id
if (!tabId) {
return
  }
const ipc = wrap<IFS>(windowEndpoint(globalThis.parent))
const bc = new BroadcastChannel(
`${browser.runtime.getManifest().name}-iframe-${tabId}`,
  )
expose(
    {
readFile: async (path: string) => {
const r = await ipc.readFile(path)
// 将 ArrayBuffer 通过 transfer 传递回 devtools-panel 中
return transfer(r, [r])
      },
writeFile: async (path: string, data: ArrayBuffer) => {
// 将 ArrayBuffer 通过 transfer 传递到 content-script 中
await ipc.writeFile(path, transfer(data, [data]))
      },
readdir: async (path: string) => {
console.log('readdir', path)
return await ipc.readdir(path)
      },
    } as IFS,
    bc,
  )

console.log('iframe main')
}

main()

// entrypoints/devtools-panel/main.ts
import { PublicPath } from 'wxt/browser'

async function injectScript() {
const includeIframe = await new Promise((resolve) => {
    browser.devtools.inspectedWindow.eval(
`!!document.querySelector('#inject-iframe')`,
(result) => {
resolve(result)
      },
    )
  })
if (includeIframe) {
return
  }
const tabId = browser.devtools.inspectedWindow.tabId
if (!tabId) {
return
  }
await browser.scripting.executeScript({
target: { tabId },
files: ['/isolation-content.js' as PublicPath],
world: 'ISOLATED',
  })
await browser.scripting.executeScript({
target: { tabId },
files: ['/main-content.js' as PublicPath],
world: 'MAIN',
  })
}

// entrypoints/isolation-content.ts
function createIframeUi() {
const wrapper = document.createElement('div')
  wrapper.style.height = '0'
  wrapper.style.width = '0'
const ifr = document.createElement('iframe')
  wrapper.appendChild(ifr)
  ifr.src = browser.runtime.getURL('/iframe.html')
  ifr.style.width = '0'
  ifr.style.height = '0'
  ifr.style.zIndex = '-9999'
  ifr.style.border = 'none'
  ifr.id = 'inject-iframe'
document.body.appendChild(wrapper)
return ifr
}

export default defineUnlistedScript(() => {
console.log('isolation-content', createIframeUi())
})

// entrypoints/iframe/main.ts
import { wrap } from 'comlink'

async function main() {
// Other code...
console.log('iframe main')
await wrap<{
onReady: () => void
  }>(bc).onReady()
}

main()

// entrypoints/devtools-panel/main.ts
async function main() {
await injectScript()
interface IFS {
readFile: (path: string) => Promise<ArrayBuffer>
writeFile: (path: string, data: ArrayBuffer) => Promise<void>
readdir: (path: string) => Promise<string[]>
  }
const tabId = browser.devtools.inspectedWindow.tabId
if (!tabId) {
return
  }
const bc = new BroadcastChannel(
`${browser.runtime.getManifest().name}-iframe-${tabId}`,
  )
await new Promise<void>((resolve) => expose({ onReady: resolve }, bc))
console.log('onReady')
// Test code...
const ipc = wrap<IFS>(bc)
const r = await ipc.readdir('/')
console.log(r)
const data = new Uint8Array([1, 2, 3]).buffer
await ipc.writeFile('/test.txt', transfer(data, [data]))
const r2 = await ipc.readFile('/test.txt')
console.log(r2)
}

main()

// src/index.ts
import './style.css'
import * as monaco from 'monaco-editor'
import editorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker'
import tsWorker from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker'

self.MonacoEnvironment = {
getWorker: (_: any, label: string) => {
if (label === 'typescript' || label === 'javascript') {
return new tsWorker()
    }
return new editorWorker()
  },
}

const value = `const add = (a: number, b: number) => a + b

console.log(add(1, 2))`

const editor = monaco.editor.create(document.getElementById('app')!, {
  value,
language: 'typescript',
automaticLayout: true,
})

import { initialize, transform } from 'esbuild-wasm'
import esbuildWasmUrl from 'esbuild-wasm/esbuild.wasm?url'

let isInit = false
async function compileCode(code: string): Promise<string> {
if (!isInit) {
await initialize({
wasmURL: esbuildWasmUrl,
    })
    isInit = true
  }

const result = await transform(code, {
loader: 'ts',
format: 'iife',
  })
return result.code
}

console.log(
await compileCode(`const add = (a: number, b: number) => a + b

console.log(add(1, 2))`),
)

eval(`(() => {
  const add = (a, b) => a + b;
  console.log(add(1, 2));
})();`)

const code = `(() => {
  const add = (a, b) => a + b;
  console.log(add(1, 2));
})();`
new Worker(
URL.createObjectURL(new Blob([code], { type: 'application/javascript' })),
)

// other code...

let worker: Worker
function executeCode(code: string) {
if (worker) {
    worker.terminate()
  }
const blobUrl = URL.createObjectURL(
new Blob([code], { type: 'application/javascript' }),
  )
  worker = new Worker(blobUrl)
}

window.addEventListener('keydown', async (e) => {
if ((e.ctrlKey || e.metaKey) && e.key === 's') {
    e.preventDefault()
const compiledCode = await compileCode(editor.getValue())
executeCode(compiledCode)
  }
})

import { sum } from 'https://esm.sh/lodash-es'

console.log(sum([1, 2, 3, 4]))

// src/vite-env.d.ts
declare module '@babel/standalone' {
import parser from '@babel/parser'
import * as types from '@babel/types'
import type * as t from '@babel/types'
import generator from '@babel/generator'
const packages = {
    parser,
    types,
generator: {
default: generator,
    },
  }
export { packages, t }
}

function transformImports(code: string) {
const { parser, types, generator } = packages
const ast = parser.parse(code, {
sourceType: 'module',
plugins: ['typescript'],
sourceFilename: 'example.ts',
  })

const imports = ast.program.body.filter((it) => types.isImportDeclaration(it))
if (imports.length === 0) {
return code
  }
  imports.forEach((it) => {
    it.source.value = `https://esm.sh/${it.source.value}`
  })
const newCode = generator.default(ast).code
return newCode
}

// before
import { sum } from 'https://esm.sh/lodash-es'
console.log(sum([1, 2, 3, 4]))

// after
const { sum } = await import('https://esm.sh/lodash-es')
console.log(sum([1, 2, 3, 4]))

// before
import { sum } from 'lodash-es'
console.log(sum([1, 2, 3, 4]))

// after
async function define(deps: string[], fn: (...args: any[]) => any) {
const args = await Promise.all(
    deps.map(async (dep) => {
const mod = await import('https://esm.sh/' + dep)
return 'default' in mod ? mod.default : mod
    }),
  )
return fn(...args)
}
define(['lodash-es'], ({ sum }) => {
console.log(sum([1, 2, 3, 4]))
})

import _, { sum } from 'lodash-es'

define(['lodash-es', 'lodash-es'], (_, { sum }) => {})

type ImportType = {
source: string
} & (
  | {
type: 'namespace'
name: string
    }
  | {
type: 'default'
name: string
    }
  | {
type: 'named'
imports: Record<string, string>
    }
)

function parseImport(imp: ImportDeclaration): ImportType[] {
const { types } = packages
const specifiers = imp.specifiers
const source = imp.source.value
const isNamespace =
    specifiers.length === 1 && types.isImportNamespaceSpecifier(specifiers[0])
const includeDefault = specifiers.some((it) =>
    types.isImportDefaultSpecifier(it),
  )
if (isNamespace) {
return [
      {
type: 'namespace',
        source,
name: specifiers[0].local.name,
      },
    ]
  }
const namedImport = specifiers.filter(
(it) => !types.isImportDefaultSpecifier(it),
  )
const result: ImportType[] = []
if (namedImport.length > 0) {
    result.push({
type: 'named',
      source,
imports: namedImport.reduce((acc, it) => {
        acc[((it as ImportSpecifier).imported as Identifier).name] =
          it.local.name
return acc
      }, {} as Record<string, string>),
    } as ImportType)
  }
if (includeDefault) {
    result.push({
type: 'default',
      source,
name: specifiers[0].local.name,
    } as ImportType)
  }
return result
}

import { setupTypeAcquisition } from '@typescript/ata'
import ts from 'typescript'

function initTypeAcquisition(
  addLibraryToRuntime: (code: string, path: string) => void,
) {
return setupTypeAcquisition({
projectName: 'TypeScript Playground',
typescript: ts,
logger: console,
delegate: {
receivedFile: (code: string, path: string) => {
addLibraryToRuntime(code, path)
// console.log('Received file', code, path)
      },
progress: (dl: number, ttl: number) => {
// console.log({ dl, ttl })
      },
started: () => {
console.log('ATA start')
      },
finished: (f) => {
console.log('ATA done')
      },
    },
  })
}
const ta = initTypeAcquisition((code: string, path: string) => {
const _path = 'file://' + path
  monaco.languages.typescript.typescriptDefaults.addExtraLib(code, _path)
})
editor.onDidChangeModelContent(async () => {
// 判断是否有错误
const value = editor.getValue()
await ta(value)
})
// editor 初始化完成后，执行一次 ta
ta(editor.getValue())

const model = monaco.editor.createModel(
  value,
'typescript',
  monaco.Uri.file('example.ts'),
)
editor.setModel(model)

import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => c.text('Hello, world!'))

export default app

type BotRequest = {
version: string
type: 'query' | 'settings' | 'report_feedback' | 'report_error'
}

// 其他代码...

app.post('/', async (c) => {
const request = await c.req.json()
const { version, type } = request
function handleQuery(c: Context) {
throw new Error('Not implemented')
  }
function handleSettings(c: Context) {
throw new Error('Not implemented')
  }

switch (type) {
case 'query':
return handleQuery(c)
case 'settings':
return handleSettings(c)
default:
throw new Error('Invalid request type')
  }
})

interface SettingsResponse {
  server_bot_dependencies?: Record<string, number> // 声明依赖的其他 bot
  allow_attachments?: boolean // 是否允许附件
  introduction_message?: string // 初始化消息
  expand_text_attachments?: boolean // 是否扩展文本附件
  enable_image_comprehension?: boolean // 是否启用图像理解，如果启用，则图片会被 Poe 解析为文本传给当前 Bot
  enforce_author_role_alternation?: boolean // 是否强制交替用户/机器人角色
  enable_multi_bot_chat_prompting?: boolean
}

function handleSettings(c: Context) {
return c.json({
server_bot_dependencies: {
'GPT-4o': 1,
    },
introduction_message: 'Hello, I am a server bot.',
  })
}

type Identifier = string // Matches the identifier format described in the spec
type ContentType = 'text/markdown' | 'text/plain'
type FeedbackType = 'like' | 'dislike'
interface MessageFeedback {
type: FeedbackType
  reason?: string
}
interface Attachment {
url: string
content_type: string
name: string
  parsed_content?: string
}
interface ProtocolMessage {
role: 'system' | 'user' | 'bot'
content: string
content_type: ContentType
timestamp: number
message_id: Identifier
feedback: MessageFeedback[]
attachments: Attachment[]
}
interface QueryRequest {
query: ProtocolMessage[]
user_id: Identifier
conversation_id: Identifier
message_id: Identifier
access_key: string
  temperature?: number
  skip_system_prompt?: boolean
  logit_bias?: Record<string, number>
  stop_sequences?: string[]
  language_code?: string
}

interface MetaMessage {
event: 'meta'
data: {
    content_type?: 'text/markdown' | 'text/plain' // 内容类型，默认为 text/markdown
    suggested_replies?: boolean // Poe 是否显示建议的回复，默认为 false
  }
}

interface TextMessage {
event: 'text'
data: {
text: string
  }
}
interface ReplaceMessage {
event: 'replace_response'
data: {
text: string
  }
}

interface JsonMessage {
event: 'json'
data: Record<string, any>
}
interface SuggestedReplyMessage {
event: 'suggested_reply'
data: {
text: string
  }
}

interface ErrorMessage {
event: 'error'
data: {
allow_retry: boolean
text: string
raw_response: string
error_type: string
  }
}
interface DoneMessage {
event: 'done'
data: {}
}

function handleQuery(c: Context) {
return streamSSE(c, async (stream) => {
const writeSSE = (
      message:
        | MetaMessage
        | TextMessage
        | ReplaceMessage
        | JsonMessage
        | SuggestedReplyMessage
        | ErrorMessage
        | DoneMessage,
    ) => {
      stream.writeSSE({
event: message.event,
data: JSON.stringify(message.data),
      })
    }
writeSSE({
event: 'meta',
data: { content_type: 'text/markdown', suggested_replies: true },
    })
writeSSE({ event: 'text', data: { text: 'Hello, World!' } })
writeSSE({ event: 'done', data: {} })
  })
}

type Bindings = {
ACCESS_KEY: string
}
// 声明环境变量绑定
const app = new Hono<{ Bindings: Bindings }>()

app.post('/', async (c) => {
const request = await c.req.json()
const authHeader = c.req.header().authorization
if (authHeader !== `Bearer ${c.env.ACCESS_KEY}`) {
return c.text('Unauthorized', 401)
  }
// 其他代码...
})

function handleSettings(c: Context) {
return c.json({
server_bot_dependencies: {
'Claude-3.5-Sonnet': 1,
    },
  })
}

async function syncBotSettings(
  botName: string,
  accessKey: string = '',
): Promise<void> {
const PROTOCOL_VERSION = '1.0'
const baseUrl = 'https://api.poe.com/bot/fetch_settings'
const resp = await fetch(
`${baseUrl}/${botName}/${accessKey}/${PROTOCOL_VERSION}`,
    { method: 'post' },
  )
const text = await resp.text()
if (!resp.ok) {
throw new Error(`Error fetching settings for bot ${botName}: ${text}`)
  }
console.log(text)
}

app.get('/sync-bot-settings', async (c) => {
await syncBotSettings('BotT6R4NKNGZ9', c.env.ACCESS_KEY)
return c.text('Synced')
})

async function* requestStream(
request: QueryRequest,
botName: string,
accessKey: string,
): AsyncGenerator<{
event: 'text'
data: any
}> {
// region 解析 SSE 流
const response = await fetch(`https://api.poe.com/bot/${botName}`, {
method: 'post',
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${accessKey}`,
Accept: 'text/event-stream',
'Cache-Control': 'no-cache',
    },
body: JSON.stringify(request),
  })
if (!response.ok || !response.body) {
console.error(response.statusText)
throw new Error(`HTTP error! status: ${response.status}`)
  }
const reader = response.body!.pipeThrough(new TextDecoderStream()).getReader()
let chunk = await reader.read()
while (!chunk.done) {
console.log('chunk: ', chunk.value)
    chunk = await reader.read()
  }
// endregion
}

function handleQuery(c: Context<{ Bindings: Bindings }>) {
return streamSSE(c, async (stream) => {
const writeSSE = (
      message:
        | MetaMessage
        | TextMessage
        | ReplaceMessage
        | JsonMessage
        | SuggestedReplyMessage
        | ErrorMessage
        | DoneMessage,
    ) => {
      stream.writeSSE({
event: message.event,
data: JSON.stringify(message.data),
      })
    }
writeSSE({
event: 'meta',
data: { content_type: 'text/markdown', suggested_replies: true },
    })
for await (const chunk of requestStream(
      request,
'GPT-4o',
      c.env.ACCESS_KEY,
    )) {
if (chunk.event === 'text') {
writeSSE(chunk)
      }
    }
writeSSE({ event: 'done', data: {} })
  })
}