@roj-ai/standalone-server 0.1.11 → 0.1.12

package/src/platform-api.ts

@@ -14,14 +14,23 @@
  * - instances.archive  — no-op; shutdown the server instead
  */
 
-import type { Logger, SessionManager } from '@roj-ai/sdk'
+import type { Logger, Preset, SessionManager } from '@roj-ai/sdk'
+import { SessionId } from '@roj-ai/sdk'
 import { Hono } from 'hono'
 import type { InstanceState } from './instance.js'
+import type { LocalRegistry } from './local-registry.js'
+import { signFileToken } from './signed-token.js'
 
 interface Deps {
 	instance: InstanceState
 	sessionManager: SessionManager
 	logger: Logger
+	presets: Preset[]
+	registry: LocalRegistry
+	/** HMAC secret for signing download tokens (`sessionFiles.createDownloadUrl`). */
+	tokenSecret: string
+	/** Externally-reachable base URL (e.g. `http://localhost:8765`) used when minting download URLs. */
+	publicBaseUrl: string
 }
 
 interface RpcEnvelope {
@@ -77,11 +86,167 @@ async function dispatch(
 
 type Handler = (deps: Deps, input: any) => Promise<unknown>
 
+interface AutoCreateSessionInput {
+	presetId: string
+	initialPrompt?: string
+	resourceIds?: string[]
+	fileIds?: string[]
+	blocking?: boolean
+}
+
+// Shared by `instances.create.autoCreateSession` and `sessions.create`. Creates
+// a session via the SDK session manager, injects any matching local resources,
+// then (if set) pushes `initialPrompt` as a user-chat message — order matters:
+// resources must land in the workspace before the agent's first inference so
+// the agent sees a non-empty workspace. Mirrors roj-platform's project-init
+// (inject-resources → activatePendingSession with initialPrompt).
+async function startSession(
+	deps: Deps,
+	input: { presetId: string; initialPrompt?: string; resourceIds?: string[] },
+): Promise<{ sessionId: string }> {
+	const created = await deps.sessionManager.callManagerMethod('sessions.create', {
+		presetId: input.presetId,
+	})
+	if (!created.ok) throw new Error(created.error.message)
+	const { sessionId } = created.value as { sessionId: string }
+
+	const resources = resolveSessionResources(deps, input.presetId, input.resourceIds)
+	for (const resource of resources) {
+		await injectRegistryResource(deps, sessionId, resource)
+	}
+
+	if (input.initialPrompt) {
+		const sent = await deps.sessionManager.callPluginMethod(SessionId(sessionId), 'user-chat.sendMessage', {
+			content: input.initialPrompt,
+		})
+		if (!sent.ok) {
+			deps.logger.warn('Failed to deliver initialPrompt', {
+				sessionId,
+				error: sent.error,
+			})
+		}
+	}
+
+	return { sessionId }
+}
+
+interface ResolvedResource {
+	resourceId: string
+	slug: string
+	name: string | null
+	fileId: string
+	filename: string
+	mimeType: string
+}
+
+// Resolution mirrors roj-platform's project-init.ts:206:
+//   1. explicit input.resourceIds — matched against the local registry by ID
+//      first, then by slug (since local-dev callers often pass slugs as ids).
+//   2. fallback to preset.defaultResourceSlugs (looked up by slug).
+function resolveSessionResources(
+	deps: Deps,
+	presetId: string,
+	inputResourceIds: string[] | undefined,
+): ResolvedResource[] {
+	if (inputResourceIds && inputResourceIds.length > 0) {
+		const matched: ResolvedResource[] = []
+		const unmatched: string[] = []
+		for (const id of inputResourceIds) {
+			const resource =
+				deps.registry.getResource({ resourceId: id }) ?? deps.registry.getResource({ resourceSlug: id })
+			const resolved = toResolvedResource(resource)
+			if (resolved) matched.push(resolved)
+			else unmatched.push(id)
+		}
+		if (unmatched.length > 0) {
+			deps.logger.warn('Some input resourceIds did not match the local registry; ignoring', {
+				unmatched,
+				availableSlugs: deps.registry.listResources().map(r => r.slug),
+			})
+		}
+		if (matched.length > 0) return matched
+	}
+
+	const preset = deps.presets.find(p => p.id === presetId)
+	const slugs = preset?.defaultResourceSlugs ?? []
+	const resolved: ResolvedResource[] = []
+	const missing: string[] = []
+	for (const slug of slugs) {
+		const r = toResolvedResource(deps.registry.getResource({ resourceSlug: slug }))
+		if (r) resolved.push(r)
+		else missing.push(slug)
+	}
+	if (missing.length > 0) {
+		deps.logger.warn(
+			"Preset declares defaultResourceSlugs not present in the local registry; those slots will be skipped",
+			{ presetId, missing, availableSlugs: deps.registry.listResources().map(r => r.slug) },
+		)
+	}
+	return resolved
+}
+
+function toResolvedResource(resource: ReturnType<LocalRegistry['getResource']>): ResolvedResource | null {
+	if (!resource || !resource.latestRevision) return null
+	const file = resource.latestRevision.file
+	return {
+		resourceId: resource.id,
+		slug: resource.slug,
+		name: resource.name,
+		fileId: file.id,
+		filename: file.filename,
+		mimeType: file.mimeType,
+	}
+}
+
+async function injectRegistryResource(deps: Deps, sessionId: string, resource: ResolvedResource): Promise<void> {
+	const file = await deps.registry.readFileById(resource.fileId)
+	if (!file) {
+		throw new Error(`Registry file not found for resource ${resource.slug} (fileId=${resource.fileId})`)
+	}
+
+	const result = await deps.sessionManager.callPluginMethod(SessionId(sessionId), 'resources.inject', {
+		sessionId,
+		filename: resource.filename,
+		mimeType: resource.mimeType,
+		size: file.buffer.length,
+		fileBuffer: file.buffer,
+		metadata: { slug: resource.slug, name: resource.name ?? resource.slug },
+	})
+	if (!result.ok) {
+		deps.logger.error('Registry resource injection failed', undefined, {
+			sessionId,
+			slug: resource.slug,
+			error: result.error,
+		})
+		throw new Error(`Failed to inject resource '${resource.slug}': ${result.error.message ?? result.error.type}`)
+	}
+}
+
 const handlers: Record<string, Handler> = {
-	'instances.create': async ({ instance }) => ({
-		instanceId: instance.id,
-		status: 'ready',
-	}),
+	'instances.create': async (
+		deps,
+		input: { metadata?: Record<string, unknown>; autoCreateSession?: AutoCreateSessionInput },
+	) => {
+		if (input.metadata !== undefined) {
+			deps.instance.metadata = input.metadata
+		}
+
+		let sessionId: string | undefined
+		if (input.autoCreateSession?.presetId) {
+			const result = await startSession(deps, {
+				presetId: input.autoCreateSession.presetId,
+				initialPrompt: input.autoCreateSession.initialPrompt,
+				resourceIds: input.autoCreateSession.resourceIds,
+			})
+			sessionId = result.sessionId
+		}
+
+		return {
+			instanceId: deps.instance.id,
+			status: 'ready',
+			...(sessionId ? { sessionId } : {}),
+		}
+	},
 
 	'instances.list': async ({ instance }) => ({
 		instances: [instanceSummary(instance)],
@@ -109,13 +274,10 @@ const handlers: Record<string, Handler> = {
 
 	'instances.archive': async () => ({ ok: true }),
 
-	'sessions.create': async ({ sessionManager }, input: { presetId: string; initialPrompt?: string }) => {
-		const result = await sessionManager.callManagerMethod('sessions.create', {
-			presetId: input.presetId,
-		})
-		if (!result.ok) throw new Error(result.error.message)
-		return result.value as { sessionId: string }
-	},
+	'sessions.create': async (
+		deps,
+		input: { presetId: string; initialPrompt?: string; resourceIds?: string[] },
+	) => startSession(deps, input),
 
 	'sessions.list': async ({ sessionManager }) => {
 		const result = await sessionManager.callManagerMethod('sessions.list', {})
@@ -124,6 +286,65 @@ const handlers: Record<string, Handler> = {
 	},
 
 	'tokens.create': async () => ({ token: '' }),
+
+	'resources.create': async (
+		deps,
+		input: { slug: string; name?: string; description?: string; fileId: string; label?: string },
+	) => deps.registry.createResource(input),
+
+	'resources.addRevision': async (
+		deps,
+		input: { resourceId?: string; resourceSlug?: string; fileId: string; label?: string },
+	) => deps.registry.addRevision(input),
+
+	'resources.get': async (deps, input: { resourceId?: string; resourceSlug?: string }) => {
+		const resource = deps.registry.getResource(input)
+		if (!resource) throw new Error('Resource not found')
+		return resource
+	},
+
+	'resources.list': async (deps, _input: { limit?: number; offset?: number }) => ({
+		resources: deps.registry.listResources(),
+	}),
+
+	'resources.delete': async (deps, input: { resourceId: string }) => deps.registry.deleteResource(input.resourceId),
+
+	'sessionFiles.createDownloadUrl': async (
+		deps,
+		input: {
+			instanceId: string
+			sessionId: string
+			scope: 'workspace' | 'session'
+			path: string
+			ttlSeconds?: number
+		},
+	) => {
+		if (input.scope !== 'workspace' && input.scope !== 'session') {
+			throw new Error(`Invalid scope: ${input.scope}`)
+		}
+		if (!input.path || input.path.includes('..')) {
+			throw new Error('Path traversal not allowed')
+		}
+
+		const ttl = Math.min(Math.max(input.ttlSeconds ?? 300, 1), 3600)
+		const expiresAt = Date.now() + ttl * 1000
+
+		const token = signFileToken(deps.tokenSecret, {
+			instanceId: input.instanceId,
+			sessionId: input.sessionId,
+			scope: input.scope,
+			path: input.path,
+			expiresAt,
+		})
+
+		const encodedPath = input.path
+			.split('/')
+			.map(seg => encodeURIComponent(seg))
+			.join('/')
+		const url = `${deps.publicBaseUrl}/api/v1/instances/${input.instanceId}/sessions/${input.sessionId}/files/${input.scope}/${encodedPath}?token=${encodeURIComponent(token)}`
+
+		return { url, expiresAt: new Date(expiresAt).toISOString() }
+	},
 }
 
 function instanceSummary(instance: InstanceState) {
@@ -135,7 +356,7 @@ function instanceSummary(instance: InstanceState) {
 		bundleSlug: 'standalone',
 		bundleRevisionId: '',
 		vcsType: 'none',
-		metadata: null,
+		metadata: instance.metadata,
 		createdAt: instance.createdAt,
 	}
 }

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,13 @@ 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 { 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 +34,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 +97,25 @@ 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 platformApp = createPlatformApi({
+		instance,
+		sessionManager,
+		logger,
+		presets,
+		registry,
+		tokenSecret,
+		publicBaseUrl,
+	})
 
 	const outerApp = new Hono()
 	// Reflect the request origin and allow credentials — the SPA uses
@@ -96,6 +124,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 +138,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,
+		}
+	})
 }