@huaqiu/component-gen-server 0.3.6

package/lib/standalone.mjs

@@ -0,0 +1,754 @@
+import { createRequire } from "node:module";
+import { createServer } from "node:http";
+import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
+import { AUTH_ROUTE_PREFIX, InMemoryHuaqiuAuthService, createAuthHandler } from "@huaqiu/dsh-auth";
+import { ARTIFACTS_ROUTE_PREFIX, HuaqiuArtifactService, createArtifactsHandler } from "@huaqiu/dsh-artifacts";
+import { createComponentGenBackend } from "@huaqiu/dsh-tool-symbol-footprint";
+import { randomUUID } from "node:crypto";
+//#region src/history.ts
+/**
+* `@huaqiu/component-gen-server` — history store.
+*
+* Plain filesystem (no SQLite): `<dir>/history.json` + `<dir>/inputs/<id>`.
+* History is user-level (not project-level). Entries are appended by the job
+* runner on terminal states; input thumbnails are stored by the routes layer
+* at POST /jobs time. `imageId` in an entry's `input` points into `inputs/`.
+*/
+const INPUT_DIR = "inputs";
+function readJsonFile(path, fallback) {
+	try {
+		if (!existsSync(path)) return fallback;
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return fallback;
+	}
+}
+function writeJsonFile(path, value) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, JSON.stringify(value, null, 2), "utf8");
+}
+/** `data:image/...;base64,....` → { mime, bytes } | null. */
+function parseDataUrl(dataUrl) {
+	const m = /^data:([^;,]+);base64,(.+)$/s.exec(dataUrl);
+	if (!m) return null;
+	try {
+		return {
+			mime: m[1],
+			bytes: Buffer.from(m[2], "base64")
+		};
+	} catch {
+		return null;
+	}
+}
+var HistoryStore = class {
+	dir;
+	file;
+	entries = [];
+	constructor(dir) {
+		this.dir = dir;
+		this.file = join(dir, "history.json");
+		this.entries = readJsonFile(this.file, []);
+	}
+	/** All entries, newest first. */
+	sorted() {
+		return [...this.entries].sort((a, b) => a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : 0);
+	}
+	async append(entry) {
+		this.entries = [entry, ...this.entries.filter((e) => e.id !== entry.id)];
+		writeJsonFile(this.file, this.entries);
+		return entry;
+	}
+	async list(query) {
+		const limit = Math.max(1, Math.min(100, query.limit ?? 20));
+		const sorted = this.sorted();
+		const start = query.cursor ? sorted.findIndex((e) => e.id === query.cursor) + 1 : 0;
+		const slice = start < 0 ? [] : sorted.slice(start, start + limit);
+		return {
+			entries: slice,
+			nextCursor: start + slice.length < sorted.length ? slice[slice.length - 1]?.id ?? null : null
+		};
+	}
+	async get(id) {
+		return this.entries.find((e) => e.id === id) ?? null;
+	}
+	async patch(id, patch) {
+		const idx = this.entries.findIndex((e) => e.id === id);
+		if (idx < 0) return null;
+		const next = {
+			...this.entries[idx],
+			...patch.status !== void 0 ? { status: patch.status } : {},
+			...patch.error !== void 0 ? { error: patch.error } : {},
+			...patch.edited !== void 0 ? { edited: patch.edited } : {},
+			...patch.result !== void 0 ? { result: patch.result } : {}
+		};
+		this.entries[idx] = next;
+		writeJsonFile(this.file, this.entries);
+		return next;
+	}
+	async delete(id) {
+		const entry = this.entries.find((e) => e.id === id);
+		this.entries = this.entries.filter((e) => e.id !== id);
+		writeJsonFile(this.file, this.entries);
+		if (entry?.input?.imageId) {
+			try {
+				unlinkSync(join(this.dir, INPUT_DIR, entry.input.imageId));
+			} catch {}
+			try {
+				unlinkSync(join(this.dir, INPUT_DIR, `${entry.input.imageId}.mime`));
+			} catch {}
+		}
+	}
+	async saveImage(imageId, dataUrl) {
+		const parsed = parseDataUrl(dataUrl);
+		if (!parsed) throw new Error("component-gen: invalid image data URL");
+		const dir = join(this.dir, INPUT_DIR);
+		mkdirSync(dir, { recursive: true });
+		writeFileSync(join(dir, imageId), parsed.bytes);
+		writeFileSync(join(dir, `${imageId}.mime`), parsed.mime, "utf8");
+	}
+	async readImage(imageId) {
+		const dir = join(this.dir, INPUT_DIR);
+		const path = join(dir, imageId);
+		if (!existsSync(path)) return null;
+		let mime = "image/png";
+		try {
+			const sidecar = readFileSync(join(dir, `${imageId}.mime`), "utf8").trim();
+			if (sidecar) mime = sidecar;
+		} catch {}
+		return {
+			bytes: readFileSync(path),
+			mime
+		};
+	}
+};
+function newHistoryId() {
+	return `hst_${randomUUID().slice(0, 18)}`;
+}
+function newImageId() {
+	return `img_${randomUUID().slice(0, 18)}`;
+}
+//#endregion
+//#region src/jobs.ts
+var JobStore = class {
+	jobs = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Map();
+	create(req, meta) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const id = `job_${randomUUID().slice(0, 18)}`;
+		const state = {
+			id,
+			kind: req.kind,
+			status: "queued",
+			createdAt: now,
+			updatedAt: now
+		};
+		this.jobs.set(id, {
+			state,
+			controller: new AbortController()
+		});
+		return state;
+	}
+	get(id) {
+		return this.jobs.get(id)?.state;
+	}
+	abort(id) {
+		const rec = this.jobs.get(id);
+		if (!rec) return false;
+		rec.controller.abort();
+		return true;
+	}
+	signal(id) {
+		return this.jobs.get(id)?.controller.signal;
+	}
+	subscribe(id, cb) {
+		if (!this.jobs.has(id)) return null;
+		let set = this.listeners.get(id);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listeners.set(id, set);
+		}
+		set.add(cb);
+		return () => {
+			set?.delete(cb);
+			if (set && set.size === 0) this.listeners.delete(id);
+		};
+	}
+	emit(id, event) {
+		const set = this.listeners.get(id);
+		if (!set) return;
+		for (const cb of [...set]) try {
+			cb(event);
+		} catch {}
+	}
+	/** Update job state (public — the runner writes progress/status). */
+	update(id, patch, event) {
+		const rec = this.jobs.get(id);
+		if (!rec) return patch;
+		rec.state = {
+			...rec.state,
+			...patch,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		if (event) this.emit(id, event);
+		return rec.state;
+	}
+	/** Update + emit the canonical event for a terminal state. */
+	settle(id, patch) {
+		const state = this.update(id, patch);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		if (state.status === "completed") this.emit(id, {
+			type: "completed",
+			job: state,
+			at: now
+		});
+		else if (state.status === "failed") this.emit(id, {
+			type: "failed",
+			error: state.error ?? "generation failed",
+			result: state.result,
+			at: now
+		});
+		else if (state.status === "cancelled") this.emit(id, {
+			type: "cancelled",
+			at: now
+		});
+		else if (state.status === "needs_confirmation") this.emit(id, {
+			type: "needs_confirmation",
+			dimensions: state.dimensions ?? {},
+			pkgType: state.pkgType ?? null,
+			fileName: state.fileName ?? null,
+			at: now
+		});
+		return state;
+	}
+	remove(id) {
+		this.jobs.delete(id);
+		this.listeners.delete(id);
+	}
+};
+function isAbortError(err) {
+	return err instanceof Error && (err.name === "AbortError" || /abort/i.test(err.message));
+}
+/** Map the tool-body `needs_auth` outcome to a job failure with the marker. */
+function isNeedsAuth(result) {
+	return result?.status === "needs_auth";
+}
+/**
+* Run one generation to a terminal state. Returns the final JobState.
+* History recording happens here so entry and state cannot drift.
+*/
+async function runGeneration(store, backend, history, id, req, meta, onProgress) {
+	if (!store.get(id)) return {
+		state: {
+			id,
+			kind: req.kind,
+			status: "failed",
+			error: "job not found",
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		},
+		recorded: false
+	};
+	const signal = store.signal(id);
+	const progress = (message) => {
+		store.update(id, {
+			status: "running",
+			progress: message
+		});
+		onProgress?.(message);
+	};
+	const exec = { signal };
+	try {
+		if (req.kind === "symbol") {
+			progress("正在生成 Symbol…");
+			const result = await backend.generateSymbol({
+				imageDataUrl: req.input.imageDataUrl ?? "",
+				instruction: req.input.instruction
+			}, exec);
+			if (isNeedsAuth(result)) return fail("needs_auth");
+			const state = store.settle(id, {
+				status: "completed",
+				result
+			});
+			await record(history, meta, req, state);
+			return {
+				state,
+				recorded: true
+			};
+		}
+		if (req.kind === "extract-footprint") {
+			progress("正在提取封装尺寸…");
+			const result = await backend.extractFootprint({
+				imageDataUrl: req.input.imageDataUrl ?? "",
+				packageType: req.input.packageType,
+				instruction: req.input.instruction
+			}, exec);
+			if (isNeedsAuth(result)) return fail("needs_auth");
+			if (result.status === "needs_confirmation") {
+				const dims = result.dimensions && typeof result.dimensions === "object" ? result.dimensions : {};
+				const pkg = typeof result.pkgType === "string" ? result.pkgType : req.input.packageType ?? null;
+				const fileName = typeof result.fileName === "string" ? result.fileName : null;
+				return {
+					state: store.settle(id, {
+						status: "needs_confirmation",
+						dimensions: dims,
+						pkgType: pkg,
+						fileName
+					}),
+					recorded: false
+				};
+			}
+			if (result.status === "cancelled") {
+				const state = store.settle(id, {
+					status: "cancelled",
+					result
+				});
+				await record(history, meta, req, state);
+				return {
+					state,
+					recorded: true
+				};
+			}
+			const state = store.settle(id, {
+				status: "completed",
+				result
+			});
+			await record(history, meta, req, state);
+			return {
+				state,
+				recorded: true
+			};
+		}
+		progress("正在生成封装…");
+		const result = await backend.generateFootprint({
+			packageType: req.input.packageType ?? "",
+			fileName: req.input.fileName,
+			dimensions: req.input.dimensions ?? {}
+		}, exec);
+		if (isNeedsAuth(result)) return fail("needs_auth");
+		if (result.status === "cancelled") {
+			const state = store.settle(id, {
+				status: "cancelled",
+				result
+			});
+			await record(history, meta, req, state);
+			return {
+				state,
+				recorded: true
+			};
+		}
+		const state = store.settle(id, {
+			status: "completed",
+			result
+		});
+		await record(history, meta, req, state);
+		return {
+			state,
+			recorded: true
+		};
+	} catch (err) {
+		if (isAbortError(err)) {
+			const state = store.settle(id, { status: "cancelled" });
+			await record(history, meta, req, state).catch(() => {});
+			return {
+				state,
+				recorded: true
+			};
+		}
+		const message = String(err?.message || err);
+		const state = store.settle(id, {
+			status: "failed",
+			error: message
+		});
+		await record(history, meta, req, state).catch(() => {});
+		return {
+			state,
+			recorded: true
+		};
+	}
+	function fail(kind) {
+		const state = store.settle(id, {
+			status: "failed",
+			error: kind === "needs_auth" ? "Huaqiu EDA login required" : "generation failed",
+			result: { status: kind }
+		});
+		record(history, meta, req, state).catch(() => {});
+		return {
+			state,
+			recorded: true
+		};
+	}
+}
+/** Build + append a history entry for a terminal job state. */
+async function record(history, meta, req, state) {
+	const kind = state.kind === "symbol" ? "symbol" : "footprint";
+	const status = state.status === "completed" ? "generated" : state.status === "cancelled" ? "cancelled" : "failed";
+	const result = state.result;
+	const artifact = result?.artifact && typeof result.artifact === "object" ? result.artifact : null;
+	const entry = {
+		id: newHistoryId(),
+		kind,
+		createdAt: state.updatedAt ?? state.createdAt,
+		status,
+		input: {
+			...meta.imageId ? { imageId: meta.imageId } : {},
+			...req.input.instruction ? { instruction: req.input.instruction } : {},
+			...req.input.packageType ? { packageType: req.input.packageType } : {},
+			...req.input.dimensions && Object.keys(req.input.dimensions).length > 0 ? { dimensions: req.input.dimensions } : {}
+		},
+		...req.input.edited && Object.keys(req.input.edited).length > 0 ? { edited: req.input.edited } : {},
+		...status === "generated" && artifact?.id ? { result: {
+			artifactId: String(artifact.id),
+			filename: typeof artifact.filename === "string" ? artifact.filename : result?.filename ?? `${kind}.kicad_${kind === "symbol" ? "sym" : "mod"}`,
+			...typeof result?.fileUrl === "string" ? { fileUrl: result.fileUrl } : {},
+			...typeof artifact.size === "number" ? { size: artifact.size } : {}
+		} } : {},
+		...status === "failed" && state.error ? { error: state.error } : {}
+	};
+	await history.append(entry);
+}
+const MAX_IMAGE_BYTES = 4194304;
+//#endregion
+//#region src/routes.ts
+function sendJson(res, status, body) {
+	res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	res.end(JSON.stringify(body));
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (c) => chunks.push(c));
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", reject);
+	});
+}
+function pathnameOf(url) {
+	const u = url ?? "";
+	const q = u.indexOf("?");
+	return (q >= 0 ? u.slice(0, q) : u).replace(/\/+$/, "");
+}
+function jsonBodyOf(text) {
+	return JSON.parse(text || "{}");
+}
+/** Write one SSE frame and flush. */
+function sse(res, event, payload) {
+	res.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
+}
+function isFinal(status) {
+	return status === "needs_confirmation" || status === "completed" || status === "failed" || status === "cancelled";
+}
+/** Map a current job state to its replay SSE event (or null when queued/running). */
+function replayEventOf(state) {
+	if (state.status === "needs_confirmation") return {
+		type: "needs_confirmation",
+		dimensions: state.dimensions ?? {},
+		pkgType: state.pkgType ?? null,
+		fileName: state.fileName ?? null,
+		at: state.updatedAt
+	};
+	if (state.status === "completed") return {
+		type: "completed",
+		job: state,
+		at: state.updatedAt
+	};
+	if (state.status === "failed") return {
+		type: "failed",
+		error: state.error ?? "generation failed",
+		result: state.result,
+		at: state.updatedAt
+	};
+	if (state.status === "cancelled") return {
+		type: "cancelled",
+		at: state.updatedAt
+	};
+	return null;
+}
+function createComponentGenHandler(deps) {
+	const store = new JobStore();
+	return async (req, res) => {
+		const raw = pathnameOf(req.url);
+		if (!raw.startsWith("/api/v1/huaqiu/component-gen")) {
+			sendJson(res, 404, { error: "not found" });
+			return;
+		}
+		const path = raw.slice(28) || "/";
+		const method = req.method ?? "GET";
+		try {
+			if (method === "GET" && path === "/config") {
+				sendJson(res, 200, {
+					hostMode: deps.hostMode === true,
+					capabilities: {
+						symbol: true,
+						footprint: true
+					},
+					limits: { imageBytes: MAX_IMAGE_BYTES }
+				});
+				return;
+			}
+			if (method === "POST" && path === "/jobs") {
+				const body = jsonBodyOf(await readBody(req));
+				if (!body || body.kind !== "symbol" && body.kind !== "extract-footprint" && body.kind !== "generate-footprint") {
+					sendJson(res, 400, { error: "invalid job kind (expected symbol | extract-footprint | generate-footprint)" });
+					return;
+				}
+				const input = body.input ?? {};
+				if (input.imageDataUrl && input.imageDataUrl.length > 4194304) {
+					sendJson(res, 413, {
+						error: "image too large",
+						detail: `max ${MAX_IMAGE_BYTES} bytes`
+					});
+					return;
+				}
+				const meta = {};
+				if (input.imageDataUrl) {
+					const imageId = newImageId();
+					await deps.history.saveImage(imageId, input.imageDataUrl);
+					meta.imageId = imageId;
+				}
+				const state = store.create({
+					kind: body.kind,
+					input
+				}, meta);
+				runGeneration(store, deps.backend, deps.history, state.id, {
+					kind: body.kind,
+					input
+				}, meta).catch((err) => {
+					console.warn("[component-gen] background run failed", String(err?.message || err));
+				});
+				res.writeHead(202, { "content-type": "application/json; charset=utf-8" });
+				res.end(JSON.stringify({ jobId: state.id }));
+				return;
+			}
+			const jobGet = /^\/jobs\/([^/]+)$/.exec(path);
+			if (method === "GET" && jobGet) {
+				const state = store.get(jobGet[1]);
+				if (!state) {
+					sendJson(res, 404, { error: "job not found" });
+					return;
+				}
+				sendJson(res, 200, state);
+				return;
+			}
+			const jobEvents = /^\/jobs\/([^/]+)\/events$/.exec(path);
+			if (method === "GET" && jobEvents) {
+				const id = jobEvents[1];
+				const state = store.get(id);
+				if (!state) {
+					sendJson(res, 404, { error: "job not found" });
+					return;
+				}
+				res.writeHead(200, {
+					"content-type": "text/event-stream; charset=utf-8",
+					"cache-control": "no-cache",
+					connection: "keep-alive"
+				});
+				res.write(": ok\n\n");
+				const replay = replayEventOf(state);
+				if (replay) sse(res, replay.type, replay);
+				if (isFinal(state.status)) {
+					res.end();
+					return;
+				}
+				const unsub = store.subscribe(id, (e) => {
+					sse(res, e.type, e);
+					if (e.type === "needs_confirmation" || e.type === "completed" || e.type === "failed" || e.type === "cancelled") {
+						unsub?.();
+						res.end();
+					}
+				});
+				req.on("close", () => unsub?.());
+				return;
+			}
+			const jobDel = /^\/jobs\/([^/]+)$/.exec(path);
+			if (method === "DELETE" && jobDel) {
+				const ok = store.abort(jobDel[1]);
+				sendJson(res, ok ? 200 : 404, { ok });
+				return;
+			}
+			if (method === "GET" && path === "/history") {
+				const url = new URL(req.url ?? "/", "http://localhost");
+				const query = {
+					limit: url.searchParams.has("limit") ? Number(url.searchParams.get("limit")) : void 0,
+					cursor: url.searchParams.get("cursor")
+				};
+				sendJson(res, 200, await deps.history.list(query));
+				return;
+			}
+			const histImage = /^\/history\/([^/]+)\/image$/.exec(path);
+			if (method === "GET" && histImage) {
+				const img = await deps.history.readImage(histImage[1]);
+				if (!img) {
+					sendJson(res, 404, { error: "image not found" });
+					return;
+				}
+				res.writeHead(200, {
+					"content-type": img.mime,
+					"cache-control": "public, max-age=3600"
+				});
+				res.end(Buffer.from(img.bytes));
+				return;
+			}
+			const histGet = /^\/history\/([^/]+)$/.exec(path);
+			if (method === "GET" && histGet) {
+				const entry = await deps.history.get(histGet[1]);
+				if (!entry) {
+					sendJson(res, 404, { error: "history not found" });
+					return;
+				}
+				sendJson(res, 200, entry);
+				return;
+			}
+			const histPatch = /^\/history\/([^/]+)$/.exec(path);
+			if (method === "PATCH" && histPatch) {
+				const patch = jsonBodyOf(await readBody(req));
+				const entry = await deps.history.patch(histPatch[1], patch);
+				if (!entry) {
+					sendJson(res, 404, { error: "history not found" });
+					return;
+				}
+				sendJson(res, 200, entry);
+				return;
+			}
+			const histDel = /^\/history\/([^/]+)$/.exec(path);
+			if (method === "DELETE" && histDel) {
+				await deps.history.delete(histDel[1]);
+				sendJson(res, 200, { ok: true });
+				return;
+			}
+			sendJson(res, 404, { error: "not found" });
+		} catch (err) {
+			sendJson(res, 500, {
+				error: "internal error",
+				detail: String(err)
+			});
+		}
+	};
+}
+//#endregion
+//#region src/standalone.ts
+/**
+* `@huaqiu/component-gen-server` — standalone server.
+*
+* A self-contained local server (no DSH host needed) that serves:
+*   - the `@huaqiu/component-gen-app` static bundle (dist),
+*   - the component-gen API (`/api/v1/huaqiu/component-gen/*`),
+*   - the `@huaqiu/dsh-auth` session routes (login bridge; the same
+*     `InMemoryHuaqiuAuthService` the DSH node half uses),
+*   - the `@huaqiu/dsh-artifacts` routes (preview artifact content).
+*
+* The generation backend is the plugin's own `createComponentGenBackend` —
+* same `runGenerate*` functions, no reimplementation. Auth is injected through
+* the dsh-auth public service; the backend never implements the login flow.
+*
+* Usage:
+*   hq-component-gen [--port 8787]
+*/
+const require = createRequire(import.meta.url);
+const MIME = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".ico": "image/x-icon",
+	".woff2": "font/woff2",
+	".map": "application/json; charset=utf-8"
+};
+function resolveAppDist(override) {
+	if (override) return resolve(override);
+	try {
+		const pkgPath = require.resolve("@huaqiu/component-gen-app/package.json");
+		return join(pkgPath.replace(/package\.json$/, ""), "dist");
+	} catch {
+		return resolve(new URL("../../component-gen-app/dist", import.meta.url).pathname);
+	}
+}
+/** Static file responder with traversal protection. */
+function serveStatic(root, urlPath, res) {
+	const decoded = decodeURIComponent(urlPath.split("?")[0] ?? "/");
+	let rel = decoded === "/" ? "/index.html" : decoded;
+	if (rel.startsWith("/")) rel = rel.slice(1);
+	const target = resolve(root, rel);
+	if (!target.startsWith(resolve(root)) || !target.startsWith(root)) {
+		res.writeHead(403);
+		res.end("forbidden");
+		return;
+	}
+	if (!existsSync(target) || !statSync(target).isFile()) {
+		const idx = join(root, "index.html");
+		if (existsSync(idx)) {
+			res.writeHead(200, { "content-type": MIME[".html"] });
+			res.end(readFileSync(idx));
+			return;
+		}
+		res.writeHead(404);
+		res.end("not found");
+		return;
+	}
+	res.writeHead(200, { "content-type": MIME[extname(target).toLowerCase()] ?? "application/octet-stream" });
+	res.end(readFileSync(target));
+}
+async function createStandaloneServer(options = {}) {
+	const port = options.port ?? 8787;
+	const host = options.host ?? "127.0.0.1";
+	const appDist = resolveAppDist(options.appDist);
+	const history = new HistoryStore(options.historyDir ?? dshHomePath("component-gen"));
+	const auth = new InMemoryHuaqiuAuthService(options.authConfig);
+	const artifacts = new HuaqiuArtifactService({ baseDir: options.artifactsDir ?? dshHomePath("artifacts") });
+	const env = {
+		auth: auth.auth,
+		artifacts,
+		hitlLanguage: options.hitlLanguage ?? "zh",
+		deps: { processEnv: typeof process !== "undefined" ? process.env : void 0 },
+		getUserQuestions: () => void 0
+	};
+	const componentGen = createComponentGenHandler({
+		backend: createComponentGenBackend(env),
+		history,
+		hostMode: auth.hostMode
+	});
+	const server = createServer(async (req, res) => {
+		const urlPath = req.url ?? "/";
+		if (urlPath.startsWith(AUTH_ROUTE_PREFIX)) {
+			await createAuthHandler(auth)(req, res);
+			return;
+		}
+		if (urlPath.startsWith(ARTIFACTS_ROUTE_PREFIX)) {
+			await createArtifactsHandler(artifacts)(req, res);
+			return;
+		}
+		if (urlPath.startsWith("/api/v1/huaqiu/component-gen")) {
+			await componentGen(req, res);
+			return;
+		}
+		serveStatic(appDist, urlPath, res);
+	});
+	await new Promise((resolveListen) => {
+		server.listen(port, host, resolveListen);
+	});
+	return {
+		server,
+		port,
+		auth,
+		history,
+		close: async () => new Promise((resolveClose) => server.close(() => resolveClose()))
+	};
+}
+/** CLI entry (`hq-component-gen`). */
+async function main() {
+	const args = process.argv.slice(2);
+	let port = 8787;
+	for (let i = 0; i < args.length; i++) if (args[i] === "--port" && args[i + 1]) port = Number(args[i + 1]);
+	const app = await createStandaloneServer({ port });
+	const urls = [`http://localhost:${app.port}/?page=footprint`, `http://localhost:${app.port}/?page=symbol`];
+	console.log(`[hq-component-gen] standalone server on ${urls[0]}`);
+	console.log(`[hq-component-gen] symbol:  ${urls[1]}`);
+}
+if (process.argv[1] && /standalone/.test(process.argv[1])) main();
+//#endregion
+export { createStandaloneServer };