Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import type { NextFunction, Response } from 'express'
import { Router } from 'express'
import { ControlApiError, controlApiRequest, controlApiStreamRequest } from '../controlApiClient.js'
import { type AuthedRequest, extractAuthToken, requireAuth } from '../middleware/auth.js'
/**
* Read-only end-user access to SharedFileSystems referenced by a Context.
* Mirrors the control-api `/external/contexts/:id/shared-filesystems` router.
*
* GET /api/v1/me/contexts/:contextId/shared-filesystems
* GET /api/v1/me/contexts/:contextId/shared-filesystems/:sfsName/proxy/*
*
* Anything but GET/HEAD is rejected at this layer too — defense in depth, so
* a misconfigured client cannot even attempt an upload through here.
*/
export type ContextSharedFilesystemSummary = {
name: string
mountPath: string
phase: string | null
pvcName: string | null
message: string | null
}
const PROPAGATED_STATUSES = new Set([400, 403, 404, 409, 410, 422])
const PASSTHROUGH_HEADERS = [
'retry-after',
'ratelimit',
'ratelimit-policy',
'x-ratelimit-limit',
'x-ratelimit-remaining',
'x-ratelimit-reset',
'x-request-id',
] as const
function forwardControlApiError(error: unknown, res: Response, next: NextFunction): void {
if (error instanceof ControlApiError && PROPAGATED_STATUSES.has(error.status)) {
const body =
error.body && typeof error.body === 'object' ? error.body : { error: String(error.message) }
res.status(error.status).json(body)
return
}
next(error)
}
export function createContextSharedFilesystemsRouter(): Router {
const router = Router()
router.use(
'/me/contexts/:contextId/shared-filesystems',
requireAuth,
(req: AuthedRequest, res, next) => {
if (req.method === 'GET' || req.method === 'HEAD') {
next()
return
}
res.setHeader('Allow', 'GET, HEAD')
res.status(405).json({ error: 'Method Not Allowed' })
}
)
router.get(
'/me/contexts/:contextId/shared-filesystems',
async (req: AuthedRequest, res: Response, next: NextFunction) => {
try {
const sessionToken = extractAuthToken(req)
const data = await controlApiRequest<{ items: ContextSharedFilesystemSummary[] }>(
'GET',
`/external/contexts/${encodeURIComponent(req.params.contextId)}/shared-filesystems`,
{ userSessionToken: sessionToken }
)
res.status(200).json(data)
} catch (error) {
forwardControlApiError(error, res, next)
}
}
)
router.get(
'/me/contexts/:contextId/shared-filesystems/:sfsName/proxy/*',
async (req: AuthedRequest, res, next) => {
try {
const sessionToken = extractAuthToken(req)
const subPath = req.params[0] ? `/${req.params[0]}` : '/'
const queryString = (() => {
const idx = req.originalUrl.indexOf('?')
return idx === -1 ? '' : req.originalUrl.slice(idx)
})()
const upstreamRes = await controlApiStreamRequest(
req.method === 'HEAD' ? 'HEAD' : 'GET',
`/external/contexts/${encodeURIComponent(req.params.contextId)}` +
`/shared-filesystems/${encodeURIComponent(req.params.sfsName)}/proxy${subPath}${queryString}`,
{
userSessionToken: sessionToken,
throwOnHttpError: false,
}
)
res.status(upstreamRes.status)
for (const name of PASSTHROUGH_HEADERS) {
const value = upstreamRes.headers.get(name)
if (value) res.setHeader(name, value)
}
const ct = upstreamRes.headers.get('content-type')
if (ct) res.setHeader('content-type', ct)
const cd = upstreamRes.headers.get('content-disposition')
if (cd) res.setHeader('content-disposition', cd)
const cl = upstreamRes.headers.get('content-length')
if (cl) res.setHeader('content-length', cl)
// HEAD is metadata-only. Do not consume the upstream stream: a large
// shared filesystem object must never be downloaded just to suppress
// its body at the public Express boundary.
if (req.method === 'HEAD') {
// Fetch normally exposes a null body for HEAD, but cancel an unusual
// non-null stream explicitly so a custom upstream cannot retain a
// connection after the metadata response is complete.
if (upstreamRes.body) void upstreamRes.body.cancel().catch(() => undefined)
res.end()
return
}
if (!upstreamRes.body) {
res.end()
return
}
const reader = upstreamRes.body.getReader()
try {
for (;;) {
const { done, value } = await reader.read()
if (done) break
if (value) res.write(Buffer.from(value))
}
res.end()
} catch {
if (!res.headersSent) res.status(502).json({ error: 'upstream error' })
else res.end()
}
} catch (error) {
next(error)
}
}
)
return router
}