Skip to content

A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.

5.9 KB
Raw Blame
// The child process side of browser_exec. The script runs in a fresh vm context that
// has only the JavaScript built-ins: no process, require, import(), fetch or timers of
// this realm. This realm does have Node, so no object of it may ever reach the script:
// the context gets only the two functions `call` and `finish`, they take and hand back
// strings and null only, and they never throw, because an exception would carry this
// realm's constructors back into the script. The prelude keeps its own copies of the
// built-ins it uses, so a script that rewrites JSON or String cannot feed the bridge
// something else. It is a process and not a worker thread because a worker that runs
// out of heap in one large allocation aborts the whole host; this process only ends
// itself, and the host can kill it when the script never returns.
import vm from 'node:vm'

const PRELUDE = `'use strict';
(function (call, finish, namesJson, body) {
  const { parse, stringify } = JSON
  const toText = String
  const PromiseOf = Promise
  const ErrorOf = Error
  const names = parse(namesJson)
  // No stack hook: V8 would hand it call sites of whatever is on the stack.
  Object.defineProperty(ErrorOf, 'prepareStackTrace', { value: undefined, writable: false, configurable: false })
  // Frames would show this process's file paths; the script has no use for them.
  Object.defineProperty(ErrorOf, 'stackTraceLimit', { value: 0, writable: false, configurable: false })
  const describe = error => {
    try { return toText(error !== null && typeof error === 'object' && 'message' in error ? error.message : error) } catch { return 'Script failed.' }
  }
  const ask = name => (...args) => new PromiseOf((resolve, reject) => {
    // JSON turns a trailing undefined into null, which would defeat a helper's default.
    while (args.length > 0 && args[args.length - 1] === undefined) args.length -= 1
    const json = stringify(args)
    // Several copies of a huge argument would exhaust this process's heap mid-call.
    if (typeof json === 'string' && json.length > 4_000_000) {
      reject(new ErrorOf('Helper arguments are larger than 4 MB.'))
      return
    }
    call(name, json, value => {
      try { resolve(value === null ? undefined : parse(value)) } catch (error) { reject(error) }
    }, message => reject(new ErrorOf(message)))
  })
  const helpers = []
  for (let index = 0; index < names.length; index += 1) helpers[index] = ask(names[index])
  let answer
  const done = value => { answer = value }
  const timers = new Set()
  let lastTimer = 0
  const setTimeout = (fn, ms, ...rest) => {
    const id = ++lastTimer
    timers.add(id)
    call('wait', stringify([+ms || 0]), () => { if (timers.delete(id) && typeof fn === 'function') fn(...rest) }, () => {})
    return id
  }
  const clearTimeout = id => { timers.delete(id) }
  const noop = () => {}
  const console = { log: noop, info: noop, warn: noop, error: noop, debug: noop }
  const settle = value => {
    let text = null
    try { text = value === undefined ? null : toText(value) } catch (error) { finish(null, describe(error)); return }
    finish(text, null)
  }
  let run
  try {
    const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor
    run = new AsyncFunction(...names, 'done', 'setTimeout', 'clearTimeout', 'console', '"use strict";\\n' + body)
  } catch (error) {
    finish(null, describe(error))
    return
  }
  run(...helpers, done, setTimeout, clearTimeout, console).then(value => settle(answer ?? value), error => finish(null, describe(error)))
})`

const waiting = new Map()
let lastCall = 0
let waitLimit = 0

// Calls a function of the context with plain arguments and no `this`; what it throws
// is the context's own and stays here.
const invoke = (fn, value) => {
  try { if (typeof fn === 'function') fn(value) } catch {}
}

const send = message => {
  try { process.send(message) } catch {}
}

const call = (name, args, resolve, reject) => {
  try {
    if (typeof name !== 'string' || typeof args !== 'string') {
      invoke(reject, 'Helper arguments must be plain JSON values.')
      return
    }
    if (name === 'wait') {
      let ms = 0
      try { ms = Number(JSON.parse(args)[0]) } catch {}
      setTimeout(() => invoke(resolve, null), Number.isFinite(ms) ? Math.min(Math.max(ms, 0), waitLimit) : 0)
      return
    }
    const id = ++lastCall
    waiting.set(id, { resolve, reject })
    send({ type: 'call', id, name, args })
  } catch {
    invoke(reject, 'The helper call failed.')
  }
}

const finish = (answer, error) => {
  const valid = (typeof answer === 'string' || answer === null) && (typeof error === 'string' || error === null)
  send(valid ? { type: 'done', answer, error } : { type: 'done', answer: null, error: 'Script produced an answer that is not text.' })
}

const start = ({ body, names, wait }) => {
  waitLimit = wait
  const context = vm.createContext(Object.create(null), { codeGeneration: { strings: true, wasm: false } })
  const install = new vm.Script(PRELUDE, { filename: 'browser_exec' }).runInContext(context)
  install(call, finish, JSON.stringify(names), body)
}

let started = false
process.on('message', message => {
  if (message?.type === 'start') {
    if (started || typeof message.body !== 'string' || !Array.isArray(message.names)) return
    started = true
    start(message)
    return
  }
  const waiter = waiting.get(message?.id)
  if (waiter === undefined) return
  waiting.delete(message.id)
  const ok = message.ok === true && (typeof message.value === 'string' || message.value === null)
  if (ok) invoke(waiter.resolve, message.value)
  else invoke(waiter.reject, typeof message.error === 'string' ? message.error : 'The helper failed.')
})
// The host went away: nothing is left to answer the script.
process.on('disconnect', () => process.exit(0))
// A helper promise the script never awaited can reject; its reason belongs to the
// context and needs no handling here, and it must not end the run.
process.on('unhandledRejection', () => {})