acrylblends 1.0.0 → 1.0.2

package/templates/chat/src/access.ts

@@ -0,0 +1,110 @@
+import { createHash, timingSafeEqual } from 'node:crypto'
+import { connectionOf, createMiddleware } from '../plugins/acryl-router/src/helpers/index.ts'
+import type { Context } from '../plugins/acryl-router/src/index.ts'
+import { basicAuth } from '../plugins/acryl-router/src/middleware/index.ts'
+
+/** Who may use the chat, and what the app prints about it at start. */
+export type Access =
+  /** Development, and every test: no gate. */
+  | { kind: 'open' }
+  /** Production with `ACRYL_PRODUCTION_KEEP=chat`: anyone, with a per-IP rate limit. */
+  | { kind: 'public'; perMinute: number; trustProxy: boolean }
+  /** Production with `CHAT_ACCESS_TOKEN`: the browser asks for it (any user name, the token as the password). */
+  | { kind: 'token'; token: string }
+  /** Production with neither: every route but `/health` answers 503. */
+  | { kind: 'closed' }
+
+export interface Decision {
+  readonly access: Access
+  /** Lines to print at start (a `WARNING` for a public chat, the reason for a closed one). */
+  readonly notices: readonly string[]
+}
+
+/**
+ * Anyone who can reach the chat spends the model key, so in production it is closed by default. Name the chat in `ACRYL_PRODUCTION_KEEP` to make it public
+ * (loudly, with a rate limit), or set `CHAT_ACCESS_TOKEN` to ask for a shared token.
+ */
+export function chatAccess(env: Readonly<Record<string, string | undefined>>): Decision {
+  if (env.NODE_ENV !== 'production') return { access: { kind: 'open' }, notices: [] }
+  const keep = (env.ACRYL_PRODUCTION_KEEP ?? '')
+    .split(',')
+    .map((name) => name.trim())
+    .filter(Boolean)
+  if (keep.includes('chat')) {
+    const perMinute = Number(env.CHAT_RATE_PER_MINUTE)
+    return {
+      access: {
+        kind: 'public',
+        perMinute: Number.isInteger(perMinute) && perMinute > 0 ? perMinute : 20,
+        trustProxy: env.TRUST_PROXY === '1',
+      },
+      notices: [
+        'WARNING: the chat is public in production because ACRYL_PRODUCTION_KEEP names "chat": anyone who can reach it spends your model key (each address is limited to a few messages a minute). Put your own login in front of it, or set CHAT_ACCESS_TOKEN instead.',
+      ],
+    }
+  }
+  const token = env.CHAT_ACCESS_TOKEN?.trim()
+  if (token) return { access: { kind: 'token', token }, notices: [] }
+  return {
+    access: { kind: 'closed' },
+    notices: [
+      'The chat is closed: with NODE_ENV=production it needs CHAT_ACCESS_TOKEN (the browser asks for it) or ACRYL_PRODUCTION_KEEP=chat to be public. Every route but /health answers 503 until then.',
+    ],
+  }
+}
+
+const digest = (text: string) => createHash('sha256').update(text).digest()
+
+/** The middleware for an access mode, mounted before the routes. `/health` is always open. */
+export function accessGate(access: Access) {
+  if (access.kind === 'open') return undefined
+  if (access.kind === 'closed')
+    return createMiddleware(async (c, next) => {
+      if (c.req.path === '/health') return next()
+      return c.json(
+        {
+          error:
+            'The chat is closed. Set CHAT_ACCESS_TOKEN, or ACRYL_PRODUCTION_KEEP=chat to make it public.',
+        },
+        503,
+      )
+    })
+  if (access.kind === 'token') {
+    const expected = digest(access.token)
+    const ask = basicAuth({
+      realm: 'chat',
+      verifyUser: (_user, password) => timingSafeEqual(digest(password), expected),
+    })
+    return createMiddleware(async (c, next) => (c.req.path === '/health' ? next() : ask(c, next)))
+  }
+  return rateLimit(access.perMinute, access.trustProxy)
+}
+
+/** At most `perMinute` messages a minute from one address (`POST /api/chat`); the table forgets an address a minute after its last message. */
+function rateLimit(perMinute: number, trustProxy: boolean) {
+  const seen = new Map<string, number[]>()
+  const addressOf = (c: Context) => {
+    if (trustProxy) {
+      const forwarded = c.req.header('x-forwarded-for')?.split(',').at(-1)?.trim()
+      if (forwarded) return forwarded
+    }
+    return connectionOf(c).remoteAddress ?? 'unknown'
+  }
+  return createMiddleware(async (c, next) => {
+    if (c.req.method !== 'POST' || c.req.path !== '/api/chat') return next()
+    const now = Date.now()
+    for (const [address, times] of seen)
+      if (now - (times.at(-1) ?? 0) > 60_000) seen.delete(address)
+    const address = addressOf(c)
+    const recent = (seen.get(address) ?? []).filter((time) => now - time < 60_000)
+    if (recent.length >= perMinute) {
+      seen.set(address, recent)
+      const wait = Math.ceil((60_000 - (now - (recent[0] ?? now))) / 1000)
+      c.header('retry-after', String(wait))
+      return c.json({ error: 'Too many messages. Try again in a minute.' }, 429)
+    }
+    recent.push(now)
+    seen.set(address, recent)
+    return next()
+  })
+}

package/templates/chat/src/chat-app.ts

@@ -5,6 +5,7 @@ import {
   streamSSE,
 } from '../plugins/acryl-router/src/helpers/index.ts'
 import { Acryl } from '../plugins/acryl-router/src/index.ts'
+import { type Access, accessGate } from './access.ts'
 import { chatStore } from './db.ts'
 import { type Llm, openAiCompatible } from './llm.ts'
 import { chatPage } from './page.tsx'
@@ -32,9 +33,14 @@ const ChatSchema: StandardSchema<ChatInput> = {
   },
 }
 
-export function createApp(db: Db, llm: Llm = openAiCompatible) {
+/** `access` is who may use the chat (default: anyone, as in development and in the tests); see `src/access.ts`. */
+export function createApp(db: Db, llm: Llm = openAiCompatible, access: Access = { kind: 'open' }) {
   const store = chatStore(db)
   const app = new Acryl()
+  const gate = accessGate(access)
+  if (gate) app.use(gate)
+
+  app.get('/health', (c) => c.json({ ok: true }))
 
   app.get('/', async (c) => {
     const id = Number(c.req.query('c'))

package/templates/chat/src/routes.ts

@@ -1,5 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis'
 import type {} from '../plugins/acryl-db/src/cordis.ts'
+import { chatAccess } from './access.ts'
 import { createApp } from './chat-app.ts'
 import { openAiCompatible } from './llm.ts'
 import { createClient } from './runtime.ts'
@@ -9,7 +10,10 @@ export const routes = {
   name: 'routes',
   inject: ['router', 'db'],
   apply(ctx: Context) {
-    ctx.router.route('/', createApp(ctx.db, openAiCompatible))
+    // In production the chat is closed unless it has a token or is made public on purpose: anyone who reaches it spends the model key.
+    const { access, notices } = chatAccess(process.env)
+    for (const line of notices) console.warn(line)
+    ctx.router.route('/', createApp(ctx.db, openAiCompatible, access))
     ctx.router.route('/client', createClient())
   },
 }

package/templates/chat/test/chat.test.ts

@@ -7,6 +7,7 @@ import { fileURLToPath } from 'node:url'
 import type {} from '../plugins/acryl-db/src/cordis.ts'
 import type { Db } from '../plugins/acryl-db/src/index.ts'
 import { pinnedInstance, withPort } from '../plugins/instance/index.ts'
+import { chatAccess } from '../src/access.ts'
 import { createApp as boot } from '../src/app.ts'
 import { createApp } from '../src/chat-app.ts'
 import type { Llm } from '../src/llm.ts'
@@ -196,3 +197,67 @@ test('the chat page loads its client component, served by the running app', asyn
   assert.match(module.headers.get('content-type') ?? '', /javascript/)
   assert.equal((await running.root.router.request('/client/@acrylblends/jsx-dom.js')).status, 200)
 })
+
+const production = (env: Record<string, string> = {}) =>
+  chatAccess({ NODE_ENV: 'production', ...env })
+
+test('in development the chat is open and prints nothing', () => {
+  const { access, notices } = chatAccess({})
+  assert.equal(access.kind, 'open')
+  assert.deepEqual(notices, [])
+})
+
+test('in production the chat is closed until it has a token or is made public on purpose', async () => {
+  const closed = production()
+  assert.equal(closed.access.kind, 'closed')
+  assert.match(closed.notices.join(), /closed/)
+  const { llm, asked } = mock(['x'])
+  const app = createApp(await memoryDb(), llm, closed.access)
+  for (const path of ['/', '/api/conversations'])
+    assert.equal((await app.request(path)).status, 503, path)
+  assert.equal((await app.request('/api/chat', post({ message: 'hi' }))).status, 503)
+  assert.equal((await app.request('/health')).status, 200)
+  assert.equal(asked.length, 0)
+})
+
+test('with CHAT_ACCESS_TOKEN the browser must send it, as the password of a basic login', async () => {
+  const gated = production({ CHAT_ACCESS_TOKEN: 'a-long-shared-token' })
+  assert.equal(gated.access.kind, 'token')
+  assert.deepEqual(gated.notices, [])
+  const { llm, asked } = mock(['ok'])
+  const app = createApp(await memoryDb(), llm, gated.access)
+  const login = (password: string) => ({
+    ...post({ message: 'hi' }),
+    headers: {
+      'content-type': 'application/json',
+      authorization: `Basic ${Buffer.from(`me:${password}`).toString('base64')}`,
+    },
+  })
+  assert.equal((await app.request('/api/chat', post({ message: 'hi' }))).status, 401)
+  assert.equal((await app.request('/api/chat', login('wrong'))).status, 401)
+  assert.equal((await app.request('/health')).status, 200)
+  assert.equal(asked.length, 0)
+  const ok = await app.request('/api/chat', login('a-long-shared-token'))
+  assert.equal(ok.status, 200)
+  assert.deepEqual(
+    events(await ok.text()).map(([e]) => e),
+    ['meta', 'token', 'done'],
+  )
+})
+
+test('ACRYL_PRODUCTION_KEEP=chat makes the chat public with a loud WARNING and a per-address rate limit', async () => {
+  const open = production({ ACRYL_PRODUCTION_KEEP: 'agent, chat', CHAT_RATE_PER_MINUTE: '2' })
+  assert.equal(open.access.kind, 'public')
+  assert.match(open.notices.join(), /^WARNING: the chat is public in production/)
+  const { llm, asked } = mock(['ok'])
+  const app = createApp(await memoryDb(), llm, open.access)
+  const send = () => app.request('/api/chat', post({ message: 'hi' }))
+  assert.equal((await (await send()).text()).includes('event: done'), true)
+  assert.equal((await send()).status, 200)
+  const limited = await send()
+  assert.equal(limited.status, 429)
+  assert.ok(Number(limited.headers.get('retry-after')) > 0)
+  assert.equal(asked.length, 2)
+  // Other routes are not counted.
+  assert.equal((await app.request('/api/conversations')).status, 200)
+})

package/templates/notes/test/notes.test.ts

@@ -62,7 +62,7 @@ test('the home page sends a visitor to the notes, which send them to log in', as
 test('sign up validates, refuses a duplicate, and starts a session', async () => {
   const app = createApp(await memoryDb())
   assert.match(await (await app.request('/signup')).text(), /Create account/)
-  const bad = await app.request('/signup', form({ email: 'nope', password: 'short' }))
+  const bad = await app.request('/signup', form({ email: 'nope', password: 'no way' }))
   assert.equal(bad.status, 400)
   const text = await bad.text()
   assert.match(text, /valid email/)

package/templates/todo/src/main.ts

@@ -9,6 +9,8 @@ const chosen = selectInstance({
 })
 const app = await createApp(chosen)
 console.log(`${APP_NAME} listening on ${app.url} (data in ${chosen.home})`)
+// The list is served under /todo, not at the address above: say where to open it.
+console.log(`open ${app.url}/todo`)
 
 const stop = async () => {
   await app.stop()