@huaqiu/component-gen-server 0.3.6

package/lib/index.mjs

@@ -0,0 +1,636 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+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);
+}
+//#endregion
+//#region src/types.ts
+const COMPONENT_GEN_ROUTE_PREFIX = "/api/v1/huaqiu/component-gen";
+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/index.ts
+/** Build the DSH `webServer.register(...)` route object. */
+function createComponentGenRoutes(deps) {
+	return {
+		kind: "prefix",
+		path: COMPONENT_GEN_ROUTE_PREFIX,
+		handler: createComponentGenHandler(deps)
+	};
+}
+//#endregion
+export { COMPONENT_GEN_ROUTE_PREFIX, HistoryStore, JobStore, MAX_IMAGE_BYTES, createComponentGenHandler, createComponentGenRoutes, newHistoryId, newImageId, parseDataUrl, runGeneration };