@fabrika/builder 0.2.0

package/daemon/src/handlers.ts

@@ -0,0 +1,472 @@
+import { type CanvasScope, compileJsx, type SessionManager, watchSession } from '@fabrika/canvas-kernel/server'
+import type { Route } from '@fabrika/daemon-kit'
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
+import { basename, dirname, extname, join, resolve, sep } from 'path'
+import type { BuildEvent, BuildStream } from './build-stream'
+import { COMPILE_TEMP_DIR } from './paths'
+import { derivePhaseState, type GateOracle } from './phases'
+
+function jsonResponse(data: unknown, status = 200): Response {
+	return new Response(JSON.stringify(data), {
+		status,
+		headers: { 'Content-Type': 'application/json' },
+	})
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error)
+}
+
+function routeParam(match: URLPatternResult, name: string): string {
+	const value = match.pathname.groups[name]
+	if (value === undefined) throw new Error(`Missing route parameter: ${name}`)
+	return value
+}
+
+function optionalString(value: unknown): string | undefined {
+	return typeof value === 'string' ? value : undefined
+}
+
+function isBuildStatus(value: unknown): value is BuildEvent['status'] {
+	return value === 'queued' || value === 'running' || value === 'passed' || value === 'failed' || value === 'blocked'
+		|| value === 'info'
+}
+
+function parseBuildEvent(value: unknown): BuildEvent | null {
+	if (!isRecord(value) || !isBuildStatus(value['status'])) return null
+	const issue = optionalString(value['issue'])
+	const message = optionalString(value['message'])
+	const at = optionalString(value['at'])
+	const data = isRecord(value['data']) ? value['data'] : undefined
+	return {
+		status: value['status'],
+		...(issue === undefined ? {} : { issue }),
+		...(message === undefined ? {} : { message }),
+		...(at === undefined ? {} : { at }),
+		...(data === undefined ? {} : { data }),
+	}
+}
+
+export function corsHeaders(port: number): Record<string, string> {
+	return {
+		'Access-Control-Allow-Origin': `http://localhost:${port}`,
+		'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+		'Access-Control-Allow-Headers': 'Content-Type',
+	}
+}
+
+export interface HandlerContext {
+	sessionManager: SessionManager
+	broadcastPlanUpdate: (id: string) => void
+	broadcastRevisionUpdate: (id: string) => void
+	buildStream: BuildStream
+	sessionsDir: string
+	port: number
+	version: string
+}
+
+function gateOracleFor(sm: SessionManager): GateOracle {
+	return {
+		getLatestUnconsumedFeedback: (id) => sm.getLatestUnconsumedFeedback(id),
+		hasGateRevision: (id, gateName) => {
+			const session = sm.get(id)
+			if (!session) return false
+			for (let i = session.revisions.length - 1; i >= 0; i--) {
+				const r = session.revisions[i]!
+				if (r.label === gateName) return r.hasFeedback
+			}
+			return false
+		},
+	}
+}
+
+interface CanvasSelection {
+	files: Map<string, string>
+	scope: CanvasScope
+}
+
+function resolveCanvasSelection(body: Record<string, unknown>): CanvasSelection {
+	const view = typeof body['view'] === 'string' ? body['view'] : null
+	const directory = typeof body['directory'] === 'string' ? body['directory'] : null
+	if (!!view === !!directory) {
+		throw new Error('Provide exactly one of view or directory')
+	}
+
+	if (view) {
+		if (!existsSync(view) || !statSync(view).isFile()) {
+			throw new Error(`Canvas view not found: ${view}`)
+		}
+		if (extname(view).toLowerCase() !== '.jsx') {
+			throw new Error(`Canvas view must be a .jsx file: ${view}`)
+		}
+		const filename = basename(view)
+		return {
+			files: new Map([[filename, readFileSync(view, 'utf-8')]]),
+			scope: { kind: 'view', filename },
+		}
+	}
+
+	if (directory === null) throw new Error('Canvas directory is missing')
+	if (!existsSync(directory) || !statSync(directory).isDirectory()) {
+		throw new Error(`Canvas directory not found: ${directory}`)
+	}
+	const filenames = readdirSync(directory).filter((f) => f.endsWith('.jsx')).sort()
+	if (filenames.length === 0) throw new Error('No .jsx files found in directory')
+	const files = new Map<string, string>()
+	for (const filename of filenames) {
+		files.set(filename, readFileSync(join(directory, filename), 'utf-8'))
+	}
+	return { files, scope: { kind: 'directory' } }
+}
+
+export function createHandlers(ctx: HandlerContext): Route[] {
+	const { sessionManager, broadcastPlanUpdate, broadcastRevisionUpdate, buildStream } = ctx
+
+	function handleHealth(): Response {
+		return jsonResponse({
+			ok: true,
+			version: ctx.version,
+			pid: process.pid,
+			dataDir: dirname(ctx.sessionsDir),
+			sessionsDir: ctx.sessionsDir,
+			sessions: sessionManager.list().map((s) => s.id),
+		})
+	}
+
+	function handlePhase(_req: Request, url: URL): Response {
+		const root = url.searchParams.get('root')
+		if (!root) return jsonResponse({ error: 'Missing ?root=<fabrikaDir>' }, 400)
+		const sessionId = url.searchParams.get('session') ?? ''
+		try {
+			const state = derivePhaseState(root, sessionId, gateOracleFor(sessionManager))
+			return jsonResponse(state)
+		} catch (error: unknown) {
+			return jsonResponse({ error: errorMessage(error) }, 500)
+		}
+	}
+
+	async function handlePlanPost(req: Request, _url: URL, match: URLPatternResult): Promise<Response> {
+		const sessionId = routeParam(match, 'id')
+		try {
+			const parsedBody: unknown = await req.json()
+			if (!isRecord(parsedBody)) return jsonResponse({ error: 'Expected a JSON object' }, 400)
+			const body = parsedBody
+			let selection: CanvasSelection
+			try {
+				selection = resolveCanvasSelection(body)
+			} catch (error) {
+				return jsonResponse({ error: error instanceof Error ? error.message : String(error) }, 400)
+			}
+			const canvasFiles = selection.files
+
+			const unconsumed = sessionManager.getLatestUnconsumedFeedback(sessionId)
+			if (unconsumed) {
+				sessionManager.consumeFeedback(sessionId, unconsumed.revision)
+				return jsonResponse(
+					{
+						ok: false,
+						error: `Unconsumed feedback from revision ${unconsumed.revision}. Address the feedback before pushing a new canvas.`,
+						unconsumedFeedback: unconsumed.feedback,
+						unconsumedRevision: unconsumed.revision,
+					},
+					409,
+				)
+			}
+
+			const projectRoot = optionalString(body['projectRoot']) ?? process.cwd()
+			const isNew = !sessionManager.get(sessionId)
+			const gate = optionalString(body['gate'])
+			const label = gate ?? optionalString(body['label'])
+			const response = optionalString(body['response'])
+
+			const compiled = new Map<string, string>()
+			const errors: Record<string, string> = {}
+			await Promise.all(
+				[...canvasFiles.entries()].map(async ([filename, jsx]) => {
+					const result = await compileJsx(jsx, { projectRoot, tempDir: COMPILE_TEMP_DIR })
+					if (result.ok) compiled.set(filename, result.js)
+					else errors[filename] = result.error
+				}),
+			)
+			if (Object.keys(errors).length > 0) {
+				return jsonResponse({ ok: false, error: 'Canvas compilation failed', errors }, 400)
+			}
+
+			const session = sessionManager.upsert(
+				sessionId,
+				canvasFiles,
+				projectRoot,
+				label,
+				response,
+				selection.scope,
+			)
+			for (const [filename, js] of compiled) {
+				sessionManager.saveCompiled(sessionId, filename, js, session.currentRevision)
+			}
+
+			broadcastPlanUpdate(sessionId)
+			watchSession(sessionId, sessionManager, broadcastPlanUpdate)
+
+			const browserUrl = `http://localhost:${ctx.port}/s/${sessionId}`
+			return jsonResponse({
+				ok: true,
+				browserUrl,
+				isNew,
+				revision: session.currentRevision,
+				sessionId,
+				...(gate === undefined ? {} : { gate }),
+				canvasFiles: [...canvasFiles.keys()],
+			})
+		} catch (error: unknown) {
+			return jsonResponse({ error: errorMessage(error) }, 500)
+		}
+	}
+
+	async function handleCanvasJs(_req: Request, url: URL, match: URLPatternResult): Promise<Response> {
+		const sessionId = routeParam(match, 'id')
+		const jsFilename = routeParam(match, 'filename')
+		const jsxFilename = jsFilename.replace(/\.js$/, '.jsx')
+		const revParam = url.searchParams.get('rev')
+		const rev = revParam ? parseInt(revParam, 10) : undefined
+
+		let compiled = sessionManager.getCompiled(sessionId, jsxFilename, rev)
+
+		if (!compiled && rev) {
+			const session = sessionManager.get(sessionId)
+			if (session) {
+				const jsx = sessionManager.readRevisionJsx(sessionId, rev, jsxFilename)
+				if (jsx) {
+					const result = await compileJsx(jsx, { projectRoot: session.projectRoot, tempDir: COMPILE_TEMP_DIR })
+					if (result.ok) {
+						sessionManager.saveCompiled(sessionId, jsxFilename, result.js, rev)
+						compiled = result.js
+					}
+				}
+			}
+		}
+
+		if (!compiled) return jsonResponse({ error: 'No compiled canvas' }, 404)
+		return new Response(compiled, {
+			headers: { 'Content-Type': 'application/javascript', 'Cache-Control': 'no-cache' },
+		})
+	}
+
+	function handleMeta(_req: Request, _url: URL, match: URLPatternResult): Response {
+		const sessionId = routeParam(match, 'id')
+		const session = sessionManager.get(sessionId)
+		if (!session) return jsonResponse({ error: 'Session not found' }, 404)
+		return jsonResponse({
+			projectRoot: session.projectRoot,
+			currentRevision: session.currentRevision,
+			revisions: session.revisions,
+			canvasFiles: session.canvasFiles,
+			createdAt: session.createdAt,
+			updatedAt: session.updatedAt,
+		})
+	}
+
+	function handleArtifact(_req: Request, url: URL, match: URLPatternResult): Response {
+		const sessionId = routeParam(match, 'id')
+		const session = sessionManager.get(sessionId)
+		if (!session) return jsonResponse({ error: 'Session not found' }, 404)
+
+		const rel = url.searchParams.get('path')
+		if (!rel) return jsonResponse({ error: 'Missing ?path=<relative path>' }, 400)
+
+		const root = resolve(session.projectRoot)
+		const target = resolve(root, rel)
+		if (target !== root && !target.startsWith(root + sep)) {
+			return jsonResponse({ error: 'Path escapes project root' }, 403)
+		}
+		try {
+			const st = statSync(target)
+			if (!st.isFile()) return jsonResponse({ error: 'Not a file' }, 404)
+			return jsonResponse({ path: rel, content: readFileSync(target, 'utf-8') })
+		} catch {
+			return jsonResponse({ error: 'Artifact not found' }, 404)
+		}
+	}
+
+	function handleSkeletons(_req: Request, _url: URL, match: URLPatternResult): Response {
+		const sessionId = routeParam(match, 'id')
+		const session = sessionManager.get(sessionId)
+		if (!session) return jsonResponse({ error: 'Session not found' }, 404)
+		const dir = join(session.projectRoot, 'tests', 'browser')
+		if (!existsSync(dir)) return jsonResponse({ skeletons: [] })
+
+		const matchBrace = (s: string, open: number): number => {
+			let depth = 0
+			for (let i = open; i < s.length; i++) {
+				if (s[i] === '{') depth++
+				else if (s[i] === '}' && --depth === 0) return i
+			}
+			return -1
+		}
+		const routePath = (u: string | undefined): string | undefined => {
+			if (!u) return undefined
+			let s = u.replace(/\$\{[^}]*\}/g, '').replace(/^https?:\/\/[^/]+/, '')
+			s = s.split('#')[0]!.split('?')[0]!
+			if (!s.startsWith('/')) s = '/' + s
+			return s.replace(/\/{2,}/g, '/') || '/'
+		}
+
+		const skeletons: unknown[] = []
+		for (const entry of readdirSync(dir).sort()) {
+			if (!/\.test\.ts$/.test(entry)) continue
+			const src = readFileSync(join(dir, entry), 'utf-8')
+			const re = /browserTest\s*\(/g
+			let mm: RegExpExecArray | null
+			while ((mm = re.exec(src))) {
+				const objStart = src.indexOf('{', mm.index)
+				if (objStart === -1) continue
+				const objEnd = matchBrace(src, objStart)
+				if (objEnd === -1) continue
+				const meta = src.slice(objStart, objEnd + 1)
+				const str = (k: string) => meta.match(new RegExp(`\\b${k}\\s*:\\s*[\`'"]([^\`'"]*)`))?.[1]
+				const arr = (k: string) => {
+					const a = meta.match(new RegExp(`\\b${k}\\s*:\\s*\\[([\\s\\S]*?)\\]`))?.[1] ?? ''
+					return [...a.matchAll(/[`'"]([^`'"]+)[`'"]/g)].map((x) => x[1])
+				}
+				const after = src.slice(objEnd + 1)
+				const nextBT = after.search(/\bbrowserTest\s*\(/)
+				const body = nextBT === -1 ? after : after.slice(0, nextBT)
+				const steps = (body.match(/\bstep(?:\.\w+)?\s*\(/g) ?? []).length
+				const invariants = (body.match(/\binvariant(?:\.\w+)?\s*\(/g) ?? []).length
+				const pending = (body.match(/\bstep\s*\(\s*[`'"][^`'"]*[`'"]\s*,\s*\{[^}]*\}\s*\)/g) ?? []).length
+					+ (body.match(/\binvariant\.todo\s*\(/g) ?? []).length
+				skeletons.push({
+					file: entry,
+					name: str('name') ?? entry.replace(/\.test\.ts$/, ''),
+					url: routePath(str('url')),
+					feature: str('feature'),
+					seeds: arr('seeds'),
+					roles: arr('roles'),
+					steps,
+					invariants,
+					pending,
+				})
+			}
+		}
+		return jsonResponse({ skeletons })
+	}
+
+	function handleFeedbackGet(_req: Request, _url: URL, match: URLPatternResult): Response {
+		const sessionId = routeParam(match, 'id')
+		const rev = parseInt(routeParam(match, 'rev'), 10)
+		const feedback = sessionManager.getFeedback(sessionId, rev)
+		if (feedback === null) return jsonResponse({ error: 'No feedback' }, 404)
+		return jsonResponse({ feedback })
+	}
+
+	function handleFeedbackConsume(_req: Request, _url: URL, match: URLPatternResult): Response {
+		const sessionId = routeParam(match, 'id')
+		const result = sessionManager.getLatestUnconsumedFeedback(sessionId)
+		if (!result) return jsonResponse({ found: false })
+		sessionManager.consumeFeedback(sessionId, result.revision)
+		broadcastRevisionUpdate(sessionId)
+		return jsonResponse({ found: true, revision: result.revision, feedback: result.feedback })
+	}
+
+	function handleResponsesGet(_req: Request, _url: URL, match: URLPatternResult): Response {
+		const sessionId = routeParam(match, 'id')
+		const rev = parseInt(routeParam(match, 'rev'), 10)
+		const responses = sessionManager.getResponses(sessionId, rev)
+		return jsonResponse({ responses })
+	}
+
+	async function handleResponsesPut(req: Request, _url: URL, match: URLPatternResult): Promise<Response> {
+		const sessionId = routeParam(match, 'id')
+		const rev = parseInt(routeParam(match, 'rev'), 10)
+		if (!sessionManager.get(sessionId)) return jsonResponse({ error: 'Session not found' }, 404)
+		try {
+			const body = await req.json()
+			sessionManager.saveResponses(sessionId, rev, body)
+			return jsonResponse({ ok: true })
+		} catch (error: unknown) {
+			return jsonResponse({ error: errorMessage(error) }, 400)
+		}
+	}
+
+	function handleSessionReset(_req: Request, _url: URL, match: URLPatternResult): Response {
+		const sessionId = routeParam(match, 'id')
+		const existed = !!sessionManager.get(sessionId)
+		if (existed) {
+			sessionManager.remove(sessionId)
+			broadcastRevisionUpdate(sessionId)
+		}
+		return jsonResponse({ ok: true, existed })
+	}
+
+	function handleSessions(): Response {
+		return jsonResponse(
+			sessionManager.list().map((s) => ({
+				id: s.id,
+				projectRoot: s.projectRoot,
+				currentRevision: s.currentRevision,
+				updatedAt: s.updatedAt,
+			})),
+		)
+	}
+
+	async function handleBuildEvent(req: Request): Promise<Response> {
+		try {
+			const body: unknown = await req.json()
+			const event = parseBuildEvent(body)
+			if (event === null) return jsonResponse({ error: 'Invalid or missing status' }, 400)
+			const ev = buildStream.append(event)
+			return jsonResponse({ ok: true, event: ev })
+		} catch (error: unknown) {
+			return jsonResponse({ error: errorMessage(error) }, 500)
+		}
+	}
+
+	function handleBuildStream(): Response {
+		const encoder = new TextEncoder()
+		let unsubscribe: (() => void) | null = null
+		const stream = new ReadableStream({
+			start(controller) {
+				const send = (ev: BuildEvent) => {
+					try {
+						controller.enqueue(encoder.encode(`data: ${JSON.stringify(ev)}\n\n`))
+					} catch {
+					}
+				}
+				for (const ev of buildStream.history()) send(ev)
+				controller.enqueue(encoder.encode(`: connected\n\n`))
+				unsubscribe = buildStream.subscribe(send)
+			},
+			cancel() {
+				unsubscribe?.()
+			},
+		})
+		return new Response(stream, {
+			headers: {
+				'Content-Type': 'text/event-stream',
+				'Cache-Control': 'no-cache, no-transform',
+				Connection: 'keep-alive',
+			},
+		})
+	}
+
+	return [
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/health' }), handler: handleHealth },
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/api/phase' }), handler: handlePhase },
+		{ method: 'POST', pattern: new URLPattern({ pathname: '/api/session/:id/plan' }), handler: handlePlanPost },
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/api/session/:id/canvas/:filename' }), handler: handleCanvasJs },
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/api/session/:id/meta' }), handler: handleMeta },
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/api/session/:id/artifact' }), handler: handleArtifact },
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/api/session/:id/skeletons' }), handler: handleSkeletons },
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/api/session/:id/revision/:rev/feedback' }), handler: handleFeedbackGet },
+		{ method: 'POST', pattern: new URLPattern({ pathname: '/api/session/:id/feedback/consume' }), handler: handleFeedbackConsume },
+		{ method: 'POST', pattern: new URLPattern({ pathname: '/api/session/:id/reset' }), handler: handleSessionReset },
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/api/session/:id/revision/:rev/responses' }), handler: handleResponsesGet },
+		{ method: 'PUT', pattern: new URLPattern({ pathname: '/api/session/:id/revision/:rev/responses' }), handler: handleResponsesPut },
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/api/sessions' }), handler: handleSessions },
+		{ method: 'POST', pattern: new URLPattern({ pathname: '/api/build/event' }), handler: handleBuildEvent },
+		{ method: 'GET', pattern: new URLPattern({ pathname: '/api/build/stream' }), handler: handleBuildStream },
+	]
+}

package/daemon/src/index.ts

@@ -0,0 +1,123 @@
+import { createWebSocketManager, SessionManager, unwatchAll, type WSData } from '@fabrika/canvas-kernel/server'
+import { dispatch } from '@fabrika/daemon-kit'
+import { resolve } from 'path'
+import { BuildStream } from './build-stream'
+import { corsHeaders, createHandlers } from './handlers'
+import { SESSIONS_DIR } from './paths'
+import { createStaticHandlers } from './static'
+
+export type { BuildEvent } from './build-stream'
+export { derivePhaseState, PHASES } from './phases'
+export type { Phase, PhaseId, PhaseState } from './phases'
+
+export interface GateRecord {
+	name: string
+	revision: number
+	hasFeedback: boolean
+	consumed: boolean
+}
+
+const DEFAULT_PORT = parseInt(process.env['FABRIKA_PORT'] || '19410', 10)
+const VERSION = '0.0.0'
+
+export interface StartDaemonOptions {
+	port?: number
+	sessionsDir?: string
+}
+
+export interface RunningDaemon {
+	server: import('bun').Server<WSData>
+	port: number
+	sessionManager: SessionManager
+	stop(): void
+}
+
+export function startDaemon(opts: StartDaemonOptions = {}): RunningDaemon {
+	const port = opts.port ?? DEFAULT_PORT
+
+	const sessionsDir = resolve(opts.sessionsDir ?? SESSIONS_DIR)
+	const sessionManager = new SessionManager(sessionsDir)
+	sessionManager.cleanupStale()
+	const wsManager = createWebSocketManager(sessionManager, { feedbackConsumption: 'external' })
+	const buildStream = new BuildStream()
+
+	const portRef = { value: port }
+
+	const handlerCtx = {
+		sessionManager,
+		broadcastPlanUpdate: wsManager.broadcastPlanUpdate,
+		broadcastRevisionUpdate: wsManager.broadcastRevisionUpdate,
+		buildStream,
+		sessionsDir,
+		get port() {
+			return portRef.value
+		},
+		version: VERSION,
+	}
+
+	const routes = [...createHandlers(handlerCtx), ...createStaticHandlers()]
+
+	const server = Bun.serve<WSData>({
+		port,
+		hostname: 'localhost',
+		fetch(req, server) {
+			const url = new URL(req.url)
+
+			if (req.method === 'OPTIONS') {
+				return new Response(null, { status: 204, headers: corsHeaders(portRef.value) })
+			}
+
+			const wsBrowser = url.pathname.match(/^\/ws\/session\/([^/]+)$/)
+			if (wsBrowser) {
+				const ok = server.upgrade(req, { data: { type: 'browser', sessionId: wsBrowser[1]! } })
+				if (!ok) return new Response('WebSocket upgrade failed', { status: 400 })
+				return
+			}
+
+			const wsWait = url.pathname.match(/^\/ws\/wait\/([^/]+)$/)
+			if (wsWait) {
+				const ok = server.upgrade(req, { data: { type: 'wait', sessionId: wsWait[1]! } })
+				if (!ok) return new Response('WebSocket upgrade failed', { status: 400 })
+				return
+			}
+
+			const response = dispatch(routes, req, url)
+			if (response) return response
+
+			if (url.pathname === '/' && req.method === 'GET') {
+				const sessions = sessionManager.list()
+				if (sessions.length > 0) {
+					const latest = sessions.sort(
+						(a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),
+					)[0]!
+					return Response.redirect(`/s/${latest.id}`, 302)
+				}
+				return new Response(JSON.stringify({ message: 'No active sessions', sessions: [] }), {
+					headers: { 'Content-Type': 'application/json' },
+				})
+			}
+
+			return new Response(JSON.stringify({ error: 'Not found' }), {
+				status: 404,
+				headers: { 'Content-Type': 'application/json' },
+			})
+		},
+		websocket: wsManager.handlers,
+	})
+
+	const boundPort = server.port ?? port
+	portRef.value = boundPort
+
+	return {
+		server,
+		port: boundPort,
+		sessionManager,
+		stop() {
+			try {
+				unwatchAll()
+			} catch {
+			}
+			server.stop(true)
+		},
+	}
+}

package/daemon/src/paths.ts

@@ -0,0 +1,30 @@
+import { createCanvasPaths } from '@fabrika/canvas-kernel/server'
+import { existsSync } from 'fs'
+import { homedir, tmpdir } from 'os'
+import { join, resolve } from 'path'
+
+export const NEUTRAL_DATA_DIR = join(homedir(), '.fabrika')
+export const LEGACY_DATA_DIR = join(homedir(), '.claude', 'fabrika')
+
+export function resolveDataDir(): string {
+	const explicit = process.env['FABRIKA_DATA_DIR']
+	if (explicit) return resolve(explicit)
+	if (existsSync(NEUTRAL_DATA_DIR)) return NEUTRAL_DATA_DIR
+	if (existsSync(LEGACY_DATA_DIR)) return LEGACY_DATA_DIR
+	return NEUTRAL_DATA_DIR
+}
+
+export const paths = createCanvasPaths({
+	appName: 'fabrika',
+	dataDir: resolveDataDir(),
+	tempDir: join(tmpdir(), 'fabrika'),
+})
+
+export const DATA_DIR = paths.dataDir
+export const SESSIONS_DIR = paths.sessionsDir
+export const TEMP_DIR = paths.tempDir
+export const PID_FILE = paths.pidFile
+export const COMPILE_TEMP_DIR = paths.compileTempDir
+export const UPLOADS_DIR = paths.uploadsDir
+
+export const DEFAULT_PORT = parseInt(process.env['FABRIKA_PORT'] || '19410', 10)