ocremote 1.3.0

package/lib/rpc.mjs

@@ -0,0 +1,114 @@
+import { b64 } from './crypto.mjs'
+
+const MAX_CONCURRENT = 8
+const MAX_UPLOAD = 24 << 20
+
+export class RpcAdapter {
+  constructor({ baseUrl, authHeader, logger }) {
+    this.baseUrl = baseUrl.replace(/\/+$/, '')
+    this.authHeader = authHeader
+    this.logger = logger
+    this.active = new Map()
+  }
+
+  log(message) {
+    this.logger?.(message)
+  }
+
+  sessionMap(session) {
+    if (!this.active.has(session.id)) this.active.set(session.id, new Map())
+    return this.active.get(session.id)
+  }
+
+  cancel(session, id) {
+    const controller = this.sessionMap(session).get(id)
+    if (controller) {
+      controller.abort()
+      this.log(`rpc ${id} cancelled`)
+    }
+  }
+
+  cancelAll(session) {
+    const map = this.active.get(session.id)
+    if (!map) return
+    for (const controller of map.values()) {
+      try {
+        controller.abort()
+      } catch {}
+    }
+    this.active.delete(session.id)
+  }
+
+  async handle(session, msg) {
+    const id = msg.id
+    if (typeof id !== 'number' || typeof msg.path !== 'string') return
+    const map = this.sessionMap(session)
+    if (map.size >= MAX_CONCURRENT) {
+      session.sendSealed({ t: 'res', id, error: 'too_many_requests' })
+      return
+    }
+    if (!msg.path.startsWith('/') || msg.path.includes('..')) {
+      session.sendSealed({ t: 'res', id, error: 'bad_path' })
+      return
+    }
+
+    const controller = new AbortController()
+    map.set(id, controller)
+    const stream = msg.stream === true
+    let opened = false
+    try {
+      const url = new URL(`${this.baseUrl}${msg.path}`)
+      if (msg.query && typeof msg.query === 'object') {
+        for (const [key, value] of Object.entries(msg.query)) {
+          if (value === undefined || value === null) continue
+          url.searchParams.set(key, String(value))
+        }
+      }
+      const headers = { authorization: this.authHeader }
+      const init = { method: msg.method || 'GET', headers, signal: controller.signal }
+      if (msg.body) {
+        const body = Buffer.from(String(msg.body), 'base64')
+        if (body.length > MAX_UPLOAD) {
+          session.sendSealed({ t: 'res', id, error: 'body_too_large' })
+          return
+        }
+        init.body = body
+        headers['content-type'] = msg.contentType || 'application/json'
+      }
+
+      const res = await fetch(url, init)
+      if (!stream) {
+        const buffer = Buffer.from(await res.arrayBuffer())
+        session.sendSealed({
+          t: 'res',
+          id,
+          status: res.status,
+          contentType: res.headers.get('content-type') || '',
+          body: b64(buffer),
+        })
+        return
+      }
+
+      opened = true
+      session.sendSealed({ t: 'open', id, status: res.status, contentType: res.headers.get('content-type') || '' })
+      if (!res.body) {
+        session.sendSealed({ t: 'end', id })
+        return
+      }
+      for await (const chunk of res.body) {
+        if (controller.signal.aborted) break
+        session.sendSealed({ t: 'chunk', id, data: b64(chunk) })
+      }
+      session.sendSealed({ t: 'end', id })
+    } catch (err) {
+      if (controller.signal.aborted) {
+        session.sendSealed(opened ? { t: 'end', id, aborted: true } : { t: 'res', id, error: 'aborted' })
+      } else {
+        this.log(`rpc ${msg.method} ${msg.path} failed: ${err.message}`)
+        session.sendSealed(opened ? { t: 'end', id, error: 'stream_failed' } : { t: 'res', id, error: 'opencode_unreachable' })
+      }
+    } finally {
+      map.delete(id)
+    }
+  }
+}