acrylblends 0.2.0 → 0.4.0

package/plugins/acryl-node-server/tests/server.spec.ts

@@ -0,0 +1,141 @@
+/** The standalone adapter over real sockets: serving, connection facts, port scan, streams, disposal, reload. */
+import { readFileSync } from 'node:fs'
+import { createServer } from 'node:http'
+import type { AddressInfo } from 'node:net'
+import { fileURLToPath } from 'node:url'
+import { Context } from '@deepseek-ai/cordis'
+import { App, apply as routerApply, connectionOf, name as routerName } from '../../acryl-router/src/index.ts'
+import { streamSSE } from '../../acryl-router/src/helpers/index.ts'
+import { afterEach, describe, expect, it } from 'vitest'
+import * as nodeServer from '../src/index.ts'
+
+const contexts: Context[] = []
+afterEach(async () => {
+  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
+})
+const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 20))
+
+async function boot(config: Partial<nodeServer.Config> = {}): Promise<Context> {
+  const ctx = new Context()
+  contexts.push(ctx)
+  ctx.plugin({ name: routerName, apply: routerApply })
+  ctx.plugin(nodeServer, config)
+  await settle()
+  return ctx
+}
+
+/** Hold a port so a server asked for it has to scan. */
+async function occupy(): Promise<{ port: number, release: () => Promise<void> }> {
+  const blocker = createServer()
+  await new Promise<void>(resolve => blocker.listen(0, '127.0.0.1', resolve))
+  return { port: (blocker.address() as AddressInfo).port, release: () => new Promise<void>(resolve => blocker.close(() => { resolve() })) }
+}
+
+const portIsFree = async (port: number): Promise<boolean> => {
+  const probe = createServer()
+  return new Promise<boolean>(resolve => {
+    probe.once('error', () => { resolve(false) })
+    probe.listen(port, '127.0.0.1', () => { probe.close(() => { resolve(true) }) })
+  })
+}
+
+describe('acryl-node-server', () => {
+  it('serves the router over a real socket with the peer and port as connection facts', async () => {
+    const ctx = await boot()
+    ctx.router.route('/', new App().get('/who', c => c.json({ peer: connectionOf(c).remoteAddress, port: connectionOf(c).localPort })))
+    const body = await (await fetch(`${ctx.nodeServer.url}/who`)).json() as { peer: string, port: number }
+    expect(ctx.nodeServer.url).toMatch(/^http:\/\/127\.0\.0\.1:\d+$/u)
+    expect(body.port).toBe(ctx.nodeServer.port)
+    expect(body.peer).toMatch(/127\.0\.0\.1/u)
+    expect((await fetch(`${ctx.nodeServer.url}/missing`)).status).toBe(404)
+  })
+
+  it('hands a request body to the handler', async () => {
+    const ctx = await boot()
+    ctx.router.route('/', new App().post('/echo', async c => c.json(await c.req.json())))
+    const response = await fetch(`${ctx.nodeServer.url}/echo`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{"n":1}' })
+    expect(await response.json()).toEqual({ n: 1 })
+  })
+
+  it('serves files from disk through a mounted app', async () => {
+    const ctx = await boot()
+    const root = fileURLToPath(new URL('./adapter/assets', import.meta.url))
+    ctx.router.route('/', new App().use('/static/*', nodeServer.serveStatic({ root })))
+    const found = await fetch(`${ctx.nodeServer.url}/static/plain.txt`)
+    expect(found.status).toBe(200)
+    expect(found.headers.get('content-type')).toBe('text/plain; charset=utf-8')
+    expect(await found.text()).toBe(readFileSync(`${root}/static/plain.txt`, 'utf8'))
+    expect((await fetch(`${ctx.nodeServer.url}/static/missing.txt`)).status).toBe(404)
+  })
+
+  it('aborts the handler signal when the client goes away', async () => {
+    const ctx = await boot()
+    let aborted!: () => void
+    const seen = new Promise<void>(resolve => { aborted = resolve })
+    ctx.router.route('/', new App().get('/wait', c => new Promise<Response>(resolve => {
+      c.req.raw.signal.addEventListener('abort', () => { aborted(); resolve(new Response(null, { status: 499 })) }, { once: true })
+    })))
+    const client = new AbortController()
+    const pending = fetch(`${ctx.nodeServer.url}/wait`, { signal: client.signal }).catch(() => undefined)
+    await settle()
+    client.abort()
+    await seen
+    await pending
+  })
+
+  it('scans to the next free port when the configured one is taken', async () => {
+    const taken = await occupy()
+    try {
+      const ctx = await boot({ port: taken.port, scan: 20 })
+      expect(ctx.nodeServer.port).toBeGreaterThan(taken.port)
+      expect(ctx.nodeServer.port).toBeLessThanOrEqual(taken.port + 20)
+    } finally {
+      await taken.release()
+    }
+  })
+
+  it('fails the plugin when no port in the scan range is free', async () => {
+    const taken = await occupy()
+    try {
+      const ctx = new Context()
+      contexts.push(ctx)
+      ctx.plugin({ name: routerName, apply: routerApply })
+      const fiber = ctx.plugin(nodeServer, { port: taken.port, scan: 0 })
+      await settle()
+      expect(fiber.state).toBe(3) // FAILED
+    } finally {
+      await taken.release()
+    }
+  })
+
+  it('on dispose ends open event streams and frees the port', async () => {
+    const ctx = await boot()
+    ctx.router.route('/', new App().get('/events', c => streamSSE(c, async stream => {
+      await stream.writeSSE({ data: 'hello' })
+      await new Promise<void>(resolve => { stream.onAbort(resolve) })
+    })))
+    const port = ctx.nodeServer.port
+    const response = await fetch(`${ctx.nodeServer.url}/events`)
+    const reader = response.body!.getReader()
+    expect(new TextDecoder().decode((await reader.read()).value)).toContain('data: hello')
+    await ctx.fiber.dispose()
+    contexts.splice(contexts.indexOf(ctx), 1)
+    const ended = await reader.read().then(result => result.done, () => true)
+    expect(ended).toBe(true)
+    expect(await portIsFree(port)).toBe(true)
+  })
+
+  it('reloads without leaking a listener', async () => {
+    const ctx = new Context()
+    contexts.push(ctx)
+    ctx.plugin({ name: routerName, apply: routerApply })
+    const ports: number[] = []
+    for (let round = 0; round < 5; round += 1) {
+      const fiber = ctx.plugin(nodeServer, {})
+      await settle()
+      ports.push(ctx.nodeServer.port)
+      await fiber.dispose()
+    }
+    for (const port of ports) expect(await portIsFree(port)).toBe(true)
+  })
+})

package/plugins/acryl-node-server/upstream.json

@@ -0,0 +1,18 @@
+{
+  "source": {
+    "repo": "acryldev/acryl",
+    "path": "plugins/acryl-node-server",
+    "commit": "df79b188398b6d4f8cceda35a72b88300a10a9ce"
+  },
+  "vendored": [
+    "src",
+    "tests",
+    "LICENSE"
+  ],
+  "rewrittenSpecifiers": 28,
+  "digest": "sha256:34c46038d5d69212247430c46ccf52c01cc6ceaf2c9c48fea39c1053de0820d2",
+  "testsNotRun": {},
+  "notice": [
+    "LICENSE"
+  ]
+}

package/plugins/acryl-router/LICENSE

@@ -0,0 +1,47 @@
+MIT License
+
+Copyright (c) 2026 WebBoxes s.r.o.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+The files under src/core are derived from Hono v4.13.13 (https://github.com/honojs/hono), used under this license:
+
+MIT License
+
+Copyright (c) 2021 - present, Yusuke Wada and Hono contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/plugins/acryl-router/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "acryl-router",
+  "description": "The router service as a Cordis plugin: Web-standard Request and Response, path parameters, middleware, helpers, an in-process fetch and request() for tests. Vendored from ACRYL.",
+  "requires": [],
+  "inject": [],
+  "provides": ["router"],
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.0.4",
+    "@deepseek-ai/schemastery": "3.18.4"
+  },
+  "mount": "root.plugin(router); then in your own plugin: inject: ['router'] and ctx.router.get('/path', (c) => c.json({ ok: true }))",
+  "omit": ["**/*.test.*", "**/*.case.ts"]
+}

package/plugins/acryl-router/src/client.ts

@@ -0,0 +1,2 @@
+/** The typed client for an `App`: request it with the route types the server declared. Runs in a browser or any fetch runtime, without Cordis. */
+export * from './core/client/index.ts'

package/plugins/acryl-router/src/connection.ts

@@ -0,0 +1,42 @@
+/**
+ * Transport facts: who is on the other end of the socket and which local port it reached. The caller of `router.fetch` supplies them
+ * (an HTTP adapter passes the socket's peer address and real port); they travel in `c.env.connection`, beside the request and never in a header.
+ */
+
+import { isIP } from 'node:net'
+import type { Context } from './core/context.ts'
+import type { ConnInfo, GetConnInfo } from './core/helper/conninfo/types.ts'
+
+/** An in-process caller (the terminal UI, a test) passes nothing, so a handler that needs a trusted peer must refuse an empty one. */
+export interface ConnectionInfo {
+  /** The peer address of the socket, when the request came over one (for example `127.0.0.1`). */
+  readonly remoteAddress?: string | undefined
+  /** The local port the socket is connected to, the real one a `Host` header should be checked against. */
+  readonly localPort?: number | undefined
+}
+
+/** What the router puts in `c.env`. */
+export interface RouterBindings {
+  readonly connection: ConnectionInfo
+}
+
+/** The `Env` of an `App` that wants `c.env.connection` typed: `new App<RouterEnv>()`. */
+export interface RouterEnv {
+  Bindings: RouterBindings
+}
+
+const NONE: ConnectionInfo = Object.freeze({})
+
+/** The transport facts of this request; empty for an in-process call or an `App` run outside the router. */
+export function connectionOf(c: Context): ConnectionInfo {
+  const env = c.env as Partial<RouterBindings> | undefined
+  return env?.connection ?? NONE
+}
+
+/** The peer in the core's conninfo shape, for middleware written against it (for example `ipRestriction`). */
+export const getConnInfo: GetConnInfo = (c): ConnInfo => {
+  const { remoteAddress } = connectionOf(c)
+  if (remoteAddress === undefined) return { remote: {} }
+  const family = isIP(remoteAddress.replace(/^\[|\]$/gu, ''))
+  return { remote: { transport: 'tcp', address: remoteAddress, addressType: family === 6 ? 'IPv6' : family === 4 ? 'IPv4' : undefined } }
+}