@roj-ai/standalone-server 0.1.11 → 0.1.13

package/src/server.ts

@@ -12,7 +12,7 @@
  *   GET  /health                                  — health check
  */
 
-import type { Config, LLMMiddleware, Logger, Preset, SessionId, SessionManager } from '@roj-ai/sdk'
+import type { Config, LLMMiddleware, LocalResource, Logger, Preset, SessionId, SessionManager } from '@roj-ai/sdk'
 import { bootstrap, createSystemFromServices, loadConfig, validateConfig } from '@roj-ai/sdk'
 import { createApp } from '@roj-ai/sdk/transport/http/app'
 import { createAgentTransport, ServerAdapter } from '@roj-ai/sdk/transport/adapter'
@@ -20,9 +20,14 @@ import { createBunPlatform } from '@roj-ai/sdk/bun-platform'
 import { createBunWebSocketHandlers } from '@roj-ai/transport/bun'
 import { Hono } from 'hono'
 import { cors } from 'hono/cors'
+import { createFilesUploadRoute } from './files-upload-route.js'
+import { GitInstanceFs } from './git-instance-fs.js'
 import { createInstance, type InstanceState } from './instance.js'
+import { LocalRegistry } from './local-registry.js'
 import { createPlatformApi } from './platform-api.js'
 import { proxyPreview } from './preview-proxy.js'
+import { createSessionFileRoute } from './session-file-route.js'
+import { generateTokenSecret } from './signed-token.js'
 
 export interface StartStandaloneOptions {
 	presets: Preset[]
@@ -30,6 +35,12 @@ export interface StartStandaloneOptions {
 	instanceId?: string
 	instanceName?: string
 	llmMiddleware?: LLMMiddleware[]
+	/**
+	 * Local resource registry — files (typically ZIPs) on disk addressable by slug.
+	 * Injected into new sessions via `resources.inject` whenever the preset's
+	 * `defaultResourceSlugs` (or input.resourceIds) match a slug here.
+	 */
+	localResources?: LocalResource[]
 	onShutdown?: () => Promise<void> | void
 	onBeforeStart?: (ctx: { config: Config; logger: Logger }) => void | Promise<void>
 }
@@ -87,7 +98,29 @@ export async function startStandaloneServer(options: StartStandaloneOptions): Pr
 		sessionRuntime: sessionManager,
 	})
 
-	const platformApp = createPlatformApi({ instance, sessionManager, logger })
+	const tokenSecret = generateTokenSecret()
+	const publicHost = config.host === '0.0.0.0' ? 'localhost' : config.host
+	const publicBaseUrl = `http://${publicHost}:${config.port}`
+
+	const registry = new LocalRegistry(config.dataPath, logger)
+	await registry.init()
+	if (options.localResources?.length) {
+		await registry.bootstrapLocalResources(options.localResources)
+	}
+
+	const gitFs = new GitInstanceFs(config.dataPath, logger)
+	await gitFs.initInstance(instance.id)
+
+	const platformApp = createPlatformApi({
+		instance,
+		sessionManager,
+		logger,
+		presets,
+		registry,
+		gitFs,
+		tokenSecret,
+		publicBaseUrl,
+	})
 
 	const outerApp = new Hono()
 	// Reflect the request origin and allow credentials — the SPA uses
@@ -96,6 +129,11 @@ export async function startStandaloneServer(options: StartStandaloneOptions): Pr
 	outerApp.use('*', cors({ origin: (origin) => origin ?? '*', credentials: true }))
 
 	outerApp.get('/health', (c) => c.json({ status: 'ok', timestamp: Date.now() }))
+
+	// Multipart file upload — must be registered BEFORE the /api/v1 RPC mount
+	// so it isn't treated as JSON RPC.
+	outerApp.post('/api/v1/files/upload', createFilesUploadRoute({ registry }))
+
 	outerApp.route('/api/v1', platformApp)
 
 	// Path-based preview proxy (must come BEFORE the catch-all instance route)
@@ -105,6 +143,13 @@ export async function startStandaloneServer(options: StartStandaloneOptions): Pr
 		return proxyPreview(c.req.raw, prefix, sessionManager, logger)
 	})
 
+	// Token-authenticated download URL minted by `sessionFiles.createDownloadUrl`.
+	// Must come BEFORE the agent catch-all so the token gate runs.
+	outerApp.get(
+		'/api/v1/instances/:id/sessions/:sid/files/:scope{workspace|session}/*',
+		createSessionFileRoute({ tokenSecret, agentApp, logger }),
+	)
+
 	// Noop auth-exchange (platform has real cookies; standalone is open)
 	outerApp.post('/api/v1/instances/:id/exchange', (c) => c.json({ ok: true }))
 

package/src/session-file-route.ts

@@ -0,0 +1,99 @@
+/**
+ * Token-authenticated session file download route.
+ *
+ * GET /api/v1/instances/:id/sessions/:sid/files/:scope/{path}?token=...
+ *
+ * Validates the HMAC token minted by `sessionFiles.createDownloadUrl` against
+ * the URL's (instanceId, sessionId, scope, path), then proxies to the SDK's
+ * existing `/sessions/:sid/workspace/*` or `/sessions/:sid/files/*` route on
+ * the agent app — same shape as roj-platform's `session-file-route.ts`, just
+ * served in-process.
+ */
+
+import type { Logger } from '@roj-ai/sdk'
+import type { Context } from 'hono'
+import { verifyFileToken } from './signed-token.js'
+
+// Decoupled from Hono's exact type so the SDK's hono and standalone-server's
+// hono — which the workspace can resolve to slightly different versions —
+// don't fight over generics. We only need fetch.
+interface AgentAppLike {
+	fetch: (req: Request) => Response | Promise<Response>
+}
+
+interface Deps {
+	tokenSecret: string
+	agentApp: AgentAppLike
+	logger: Logger
+}
+
+const SCOPE_TO_SDK_PREFIX: Record<'workspace' | 'session', string> = {
+	workspace: 'workspace',
+	session: 'files',
+}
+
+export function createSessionFileRoute(deps: Deps) {
+	return async (c: Context) => {
+		const instanceId = c.req.param('id')
+		const sessionId = c.req.param('sid')
+		const scope = c.req.param('scope') as 'workspace' | 'session'
+		const url = new URL(c.req.url)
+
+		const tokenStr = url.searchParams.get('token')
+		if (!tokenStr) {
+			return c.json({ error: { type: 'unauthorized', message: 'Missing token' } }, 401)
+		}
+
+		const verified = verifyFileToken(deps.tokenSecret, tokenStr)
+		if (!verified.ok) {
+			return c.json({ error: { type: 'unauthorized', message: `Invalid token (${verified.error})` } }, 401)
+		}
+
+		// Recover the file path the token was signed for. Hono `*` capture is
+		// available via the URL pathname; decode each segment back to its
+		// original form so the comparison against the signed payload is exact.
+		const pathPrefix = `/api/v1/instances/${instanceId}/sessions/${sessionId}/files/${scope}/`
+		if (!url.pathname.startsWith(pathPrefix)) {
+			return c.json({ error: { type: 'invalid_request', message: 'Path mismatch' } }, 400)
+		}
+		const requestedPath = url.pathname
+			.slice(pathPrefix.length)
+			.split('/')
+			.map(seg => decodeURIComponent(seg))
+			.join('/')
+
+		const p = verified.payload
+		if (
+			p.instanceId !== instanceId ||
+			p.sessionId !== sessionId ||
+			p.scope !== scope ||
+			p.path !== requestedPath
+		) {
+			return c.json(
+				{ error: { type: 'unauthorized', message: 'Token does not match requested file' } },
+				401,
+			)
+		}
+
+		// Proxy to the SDK's underlying file route. Note the path/scope mapping:
+		// public `workspace` → SDK `/sessions/:sid/workspace/*`,
+		// public `session`   → SDK `/sessions/:sid/files/*`.
+		const sdkPrefix = SCOPE_TO_SDK_PREFIX[scope]
+		const innerUrl = `${url.origin}/sessions/${sessionId}/${sdkPrefix}/${encodePathSegments(requestedPath)}`
+		try {
+			return await deps.agentApp.fetch(new Request(innerUrl, { method: 'GET' }))
+		} catch (err) {
+			deps.logger.error('Session file proxy failed', err instanceof Error ? err : new Error(String(err)), {
+				instanceId,
+				sessionId,
+				scope,
+				path: requestedPath,
+			})
+			return c.json({ error: { type: 'proxy_error', message: 'File proxy failed' } }, 502)
+		}
+	}
+}
+
+function encodePathSegments(path: string): string {
+	return path.split('/').map(seg => encodeURIComponent(seg)).join('/')
+}

package/src/signed-token.ts

@@ -0,0 +1,68 @@
+/**
+ * Tiny HMAC-signed download token used by `sessionFiles.createDownloadUrl`.
+ *
+ * The token binds (instanceId, sessionId, scope, path, expiresAt) so a leaked
+ * URL can only fetch the exact file it was minted for, and only briefly. Same
+ * shape as roj-platform's `session-file-token.ts`, just pruned for local use.
+ */
+
+import { randomBytes, createHmac, timingSafeEqual } from 'node:crypto'
+
+export interface SignedFilePayload {
+	instanceId: string
+	sessionId: string
+	scope: 'workspace' | 'session'
+	path: string
+	expiresAt: number
+}
+
+export function generateTokenSecret(): string {
+	return randomBytes(32).toString('hex')
+}
+
+export function signFileToken(secret: string, payload: SignedFilePayload): string {
+	const body = base64UrlEncode(Buffer.from(JSON.stringify(payload), 'utf8'))
+	const sig = base64UrlEncode(hmac(secret, body))
+	return `${body}.${sig}`
+}
+
+export type VerifyResult =
+	| { ok: true; payload: SignedFilePayload }
+	| { ok: false; error: 'malformed' | 'bad_signature' | 'expired' }
+
+export function verifyFileToken(secret: string, token: string): VerifyResult {
+	const dot = token.indexOf('.')
+	if (dot < 0) return { ok: false, error: 'malformed' }
+	const body = token.slice(0, dot)
+	const sigEncoded = token.slice(dot + 1)
+
+	const expectedSig = hmac(secret, body)
+	const givenSig = base64UrlDecode(sigEncoded)
+	if (givenSig.length !== expectedSig.length || !timingSafeEqual(givenSig, expectedSig)) {
+		return { ok: false, error: 'bad_signature' }
+	}
+
+	let payload: SignedFilePayload
+	try {
+		payload = JSON.parse(base64UrlDecode(body).toString('utf8'))
+	} catch {
+		return { ok: false, error: 'malformed' }
+	}
+	if (typeof payload.expiresAt !== 'number' || payload.expiresAt < Date.now()) {
+		return { ok: false, error: 'expired' }
+	}
+	return { ok: true, payload }
+}
+
+function hmac(secret: string, body: string): Buffer {
+	return createHmac('sha256', secret).update(body).digest()
+}
+
+function base64UrlEncode(buf: Buffer): string {
+	return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+function base64UrlDecode(s: string): Buffer {
+	const pad = '='.repeat((4 - (s.length % 4)) % 4)
+	return Buffer.from(s.replace(/-/g, '+').replace(/_/g, '/') + pad, 'base64')
+}

package/src/user-config-loader.ts

@@ -5,10 +5,10 @@
  * runtime-specific I/O) and out of `@roj-ai/sandbox-runtime` (Bun-specific).
  */
 
-import type { Preset, RojConfig } from '@roj-ai/sdk'
+import type { LocalResource, Preset, RojConfig } from '@roj-ai/sdk'
 import { validatePreset } from '@roj-ai/sdk'
 import { existsSync } from 'node:fs'
-import { resolve } from 'node:path'
+import { dirname, isAbsolute, resolve } from 'node:path'
 
 export async function loadUserConfig(configPath: string): Promise<RojConfig> {
 	const absolutePath = resolve(process.cwd(), configPath)
@@ -63,9 +63,48 @@ export async function loadUserConfig(configPath: string): Promise<RojConfig> {
 		throw new Error(`Duplicate preset IDs: ${[...new Set(duplicates)].join(', ')}`)
 	}
 
+	const configDir = dirname(absolutePath)
+	const localResources = parseLocalResources(typedConfig.localResources, configDir, absolutePath)
+
 	return {
 		presets,
 		sandboxed: typedConfig.sandboxed as boolean | undefined,
 		snapshotter: typedConfig.snapshotter as RojConfig['snapshotter'],
+		localResources,
+	}
+}
+
+function parseLocalResources(raw: unknown, configDir: string, configPath: string): LocalResource[] | undefined {
+	if (raw === undefined) return undefined
+	if (!Array.isArray(raw)) {
+		throw new Error(`'localResources' must be an array: ${configPath}`)
 	}
+
+	const seen = new Set<string>()
+	return raw.map((entry, i) => {
+		if (typeof entry !== 'object' || entry === null) {
+			throw new Error(`localResources[${i}] must be an object: ${configPath}`)
+		}
+		const r = entry as Record<string, unknown>
+		if (typeof r.slug !== 'string' || !r.slug) {
+			throw new Error(`localResources[${i}] missing required 'slug': ${configPath}`)
+		}
+		if (typeof r.path !== 'string' || !r.path) {
+			throw new Error(`localResources[${i}] missing required 'path': ${configPath}`)
+		}
+		if (seen.has(r.slug)) {
+			throw new Error(`Duplicate localResources slug '${r.slug}': ${configPath}`)
+		}
+		seen.add(r.slug)
+
+		const resolvedPath = isAbsolute(r.path) ? r.path : resolve(configDir, r.path)
+		if (!existsSync(resolvedPath)) {
+			throw new Error(`localResources[${i}] file not found: ${resolvedPath} (config: ${configPath})`)
+		}
+		return {
+			slug: r.slug,
+			path: resolvedPath,
+			name: typeof r.name === 'string' ? r.name : undefined,
+		}
+	})
 }