@huaqiu/component-gen-server 0.3.6

package/src/routes.ts

@@ -0,0 +1,227 @@
+/**
+ * `@huaqiu/component-gen-server` — HTTP routes for the component-gen API.
+ *
+ * Mounted by the DSH plugin on `ctx.webServer` (kind 'prefix',
+ * `/api/v1/huaqiu/component-gen`) and by the standalone server. Route paths
+ * are parsed from `req.url` manually (DSH `WebRoute` supports only exact /
+ * prefix — no `:param`). CORS-free: everything is same-origin in both hosts.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { ComponentGenBackend } from './backend.js'
+import { HistoryStore, newImageId } from './history.js'
+import { JobStore, runGeneration, type JobMeta } from './jobs.js'
+import {
+  COMPONENT_GEN_ROUTE_PREFIX, MAX_IMAGE_BYTES,
+  type ComponentGenConfig, type HistoryPatch, type HistoryQuery, type JobEvent,
+  type JobState, type StartJobRequest,
+} from './types.js'
+
+export interface ComponentGenHandlerDeps {
+  backend: ComponentGenBackend
+  history: HistoryStore
+  hostMode?: boolean
+  getAccessToken?: () => Promise<string | null>
+}
+
+export type ComponentGenHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void> | void
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' })
+  res.end(JSON.stringify(body))
+}
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    req.on('data', (c: Buffer) => chunks.push(c))
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
+    req.on('error', reject)
+  })
+}
+
+function pathnameOf(url: string | undefined): string {
+  const u = url ?? ''
+  const q = u.indexOf('?')
+  return (q >= 0 ? u.slice(0, q) : u).replace(/\/+$/, '')
+}
+
+function jsonBodyOf<T>(text: string): T {
+  return JSON.parse(text || '{}') as T
+}
+
+/** Write one SSE frame and flush. */
+function sse(res: ServerResponse, event: string, payload: unknown): void {
+  res.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`)
+}
+
+function isFinal(status: JobState['status']): boolean {
+  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: JobState): JobEvent | null {
+  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
+}
+
+export function createComponentGenHandler(deps: ComponentGenHandlerDeps): ComponentGenHandler {
+  const store = new JobStore()
+
+  return async (req, res) => {
+    const raw = pathnameOf(req.url)
+    if (!raw.startsWith(COMPONENT_GEN_ROUTE_PREFIX)) {
+      sendJson(res, 404, { error: 'not found' })
+      return
+    }
+    const path = raw.slice(COMPONENT_GEN_ROUTE_PREFIX.length) || '/'
+    const method = req.method ?? 'GET'
+
+    try {
+      // GET /config
+      if (method === 'GET' && path === '/config') {
+        const cfg: ComponentGenConfig = {
+          hostMode: deps.hostMode === true,
+          capabilities: { symbol: true, footprint: true },
+          limits: { imageBytes: MAX_IMAGE_BYTES },
+        }
+        sendJson(res, 200, cfg)
+        return
+      }
+
+      // POST /jobs
+      if (method === 'POST' && path === '/jobs') {
+        const body = jsonBodyOf<StartJobRequest>(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 > MAX_IMAGE_BYTES) {
+          sendJson(res, 413, { error: 'image too large', detail: `max ${MAX_IMAGE_BYTES} bytes` })
+          return
+        }
+        const meta: JobMeta = {}
+        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)
+        void runGeneration(store, deps.backend, deps.history, state.id, { kind: body.kind, input }, meta).catch((err) => {
+          console.warn('[component-gen] background run failed', String((err as Error)?.message || err))
+        })
+        res.writeHead(202, { 'content-type': 'application/json; charset=utf-8' })
+        res.end(JSON.stringify({ jobId: state.id }))
+        return
+      }
+
+      // GET /jobs/:id
+      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
+      }
+
+      // GET /jobs/:id/events (SSE)
+      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')
+
+        // Replay current state first (covers jobs that finished pre-subscribe).
+        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
+      }
+
+      // DELETE /jobs/:id
+      const jobDel = /^\/jobs\/([^/]+)$/.exec(path)
+      if (method === 'DELETE' && jobDel) {
+        const ok = store.abort(jobDel[1]!)
+        sendJson(res, ok ? 200 : 404, { ok })
+        return
+      }
+
+      // GET /history
+      if (method === 'GET' && path === '/history') {
+        const url = new URL(req.url ?? '/', 'http://localhost')
+        const query: HistoryQuery = {
+          limit: url.searchParams.has('limit') ? Number(url.searchParams.get('limit')) : undefined,
+          cursor: url.searchParams.get('cursor'),
+        }
+        sendJson(res, 200, await deps.history.list(query))
+        return
+      }
+
+      // GET /history/:imageId/image
+      // `:imageId` is the stored thumbnail id (`img_…`), not a history entry
+      // id — the client's `ports.inputImage` sends it directly.
+      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
+      }
+
+      // GET /history/:id
+      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
+      }
+
+      // PATCH /history/:id
+      const histPatch = /^\/history\/([^/]+)$/.exec(path)
+      if (method === 'PATCH' && histPatch) {
+        const patch = jsonBodyOf<HistoryPatch>(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
+      }
+
+      // DELETE /history/:id
+      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) })
+    }
+  }
+}

package/src/standalone.ts

@@ -0,0 +1,172 @@
+/**
+ * `@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]
+ */
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http'
+import { createRequire } from 'node:module'
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { join, extname, resolve } from 'node:path'
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths'
+import { InMemoryHuaqiuAuthService, createAuthHandler, AUTH_ROUTE_PREFIX, type HuaqiuAuthService } from '@huaqiu/dsh-auth'
+import { HuaqiuArtifactService, createArtifactsHandler, ARTIFACTS_ROUTE_PREFIX } from '@huaqiu/dsh-artifacts'
+import { runGenerateSymbol, runGenerateFootprintFromImage, runGenerateFootprintFromDimensions, createComponentGenBackend, type SymbolFootprintEnv } from '@huaqiu/dsh-tool-symbol-footprint'
+import { createComponentGenHandler } from './index.js'
+import { HistoryStore } from './history.js'
+import { COMPONENT_GEN_ROUTE_PREFIX } from './types.js'
+
+const require = createRequire(import.meta.url)
+
+export interface StandaloneServerOptions {
+  port?: number
+  host?: string
+  /** component-gen-app dist dir (default: resolved from the package). */
+  appDist?: string
+  /** history dir (default `~/.dsh/component-gen/`). */
+  historyDir?: string
+  /** artifacts dir (default `~/.dsh/artifacts/`). */
+  artifactsDir?: string
+  authConfig?: Record<string, unknown> | null
+  hitlLanguage?: 'zh' | 'en'
+}
+
+export interface StandaloneServer {
+  server: ReturnType<typeof createServer>
+  port: number
+  auth: HuaqiuAuthService
+  history: HistoryStore
+  close(): Promise<void>
+}
+
+const MIME: Record<string, string> = {
+  '.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?: string): string {
+  if (override) return resolve(override)
+  try {
+    const pkgPath = require.resolve('@huaqiu/component-gen-app/package.json')
+    return join(pkgPath.replace(/package\.json$/, ''), 'dist')
+  } catch {
+    // Monorepo fallback (before publish): lib/standalone.mjs → packages/component-gen-app/dist
+    const local = resolve(new URL('../../component-gen-app/dist', import.meta.url).pathname)
+    return local
+  }
+}
+
+/** Static file responder with traversal protection. */
+function serveStatic(root: string, urlPath: string, res: ServerResponse): void {
+  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()) {
+    // SPA fallback: serve index.html for unknown non-asset paths.
+    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))
+}
+
+export async function createStandaloneServer(options: StandaloneServerOptions = {}): Promise<StandaloneServer> {
+  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 as never)
+  const artifacts = new HuaqiuArtifactService({ baseDir: options.artifactsDir ?? dshHomePath('artifacts') })
+
+  const env: SymbolFootprintEnv = {
+    auth: auth.auth,
+    artifacts,
+    hitlLanguage: options.hitlLanguage ?? 'zh',
+    deps: { processEnv: typeof process !== 'undefined' ? process.env : undefined },
+    // The app is the driver: never pause on the native HIL popup.
+    getUserQuestions: () => undefined,
+  }
+  const backend = createComponentGenBackend(env)
+  const componentGen = createComponentGenHandler({
+    backend,
+    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(COMPONENT_GEN_ROUTE_PREFIX)) {
+      await componentGen(req, res)
+      return
+    }
+    serveStatic(appDist, urlPath, res)
+  })
+
+  await new Promise<void>((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(): Promise<void> {
+  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])) {
+  void main()
+}

package/src/types.ts

@@ -0,0 +1,101 @@
+/**
+ * `@huaqiu/component-gen-server` — shared domain types.
+ *
+ * These mirror `@huaqiu/component-gen-app/src/ports.ts` (structurally
+ * identical, JSON interop) but are owned by the server as the authority.
+ */
+
+export type ComponentGenPage = 'symbol' | 'footprint'
+
+export type JobKind = 'symbol' | 'extract-footprint' | 'generate-footprint'
+
+export type JobStatus =
+  | 'queued'
+  | 'running'
+  | 'needs_confirmation'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+
+export interface JobInput {
+  imageDataUrl?: string
+  instruction?: string
+  packageType?: string
+  dimensions?: Record<string, number>
+  fileName?: string
+  edited?: Record<string, boolean>
+}
+
+export interface JobState {
+  id: string
+  kind: JobKind
+  status: JobStatus
+  progress?: string
+  result?: Record<string, unknown>
+  dimensions?: Record<string, unknown>
+  pkgType?: string | null
+  fileName?: string | null
+  error?: string
+  createdAt: string
+  updatedAt: string
+}
+
+export type JobEvent =
+  | { type: 'progress'; message: string; at: string }
+  | { type: 'needs_confirmation'; dimensions: Record<string, unknown>; pkgType?: string | null; fileName?: string | null; at: string }
+  | { type: 'completed'; job: JobState; at: string }
+  | { type: 'failed'; error: string; result?: Record<string, unknown>; at: string }
+  | { type: 'cancelled'; at: string }
+
+export interface StartJobRequest {
+  kind: JobKind
+  input: JobInput
+}
+
+export interface HistoryQuery {
+  limit?: number
+  cursor?: string | null
+}
+
+export interface HistoryPage {
+  entries: HistoryEntry[]
+  nextCursor?: string | null
+}
+
+export interface HistoryEntry {
+  id: string
+  kind: 'symbol' | 'footprint'
+  createdAt: string
+  status: 'generated' | 'failed' | 'cancelled'
+  input: {
+    imageId?: string
+    instruction?: string
+    packageType?: string
+    dimensions?: Record<string, number>
+  }
+  edited?: Record<string, boolean>
+  result?: {
+    artifactId: string
+    filename: string
+    fileUrl?: string
+    size?: number
+  }
+  error?: string
+}
+
+export interface HistoryPatch {
+  status?: HistoryEntry['status']
+  result?: HistoryEntry['result']
+  error?: string
+  edited?: Record<string, boolean>
+}
+
+export interface ComponentGenConfig {
+  hostMode: boolean
+  capabilities: { symbol: boolean; footprint: boolean }
+  limits: { imageBytes: number }
+}
+
+export const COMPONENT_GEN_ROUTE_PREFIX = '/api/v1/huaqiu/component-gen'
+
+export const MAX_IMAGE_BYTES = 4 * 1024 * 1024