agentworkshop 0.5.8 → 0.6.0

package/server/services/workshop/daq/frames.ts

@@ -0,0 +1,227 @@
+/**
+ * DaqFrame 处理器注册表 —— 实时下沉处理(sink pipeline)的执行面。
+ *
+ * 模板 `sink.processors` 声明有序步骤,采样后、入队/入库前在生产侧按序执行
+ * (图像 blob 不能过 MQTT 队列 → 全部 blob 处理必须在生产侧完成,消费侧只收元数据);
+ * 处理器 = 纯函数式变换(working frame → working frame),内置 5 件,插件经
+ * ctx.daq.registerProcessor 追加(同名覆盖并告警)。
+ *
+ * 内置处理器:
+ *  - resample(n)       vector 重采样到 n 点(线性插值)
+ *  - derive-metric     vector/image 派生标量指标(op=avg|min|max|range|std)
+ *  - zones(n)          vector 分区统计(zone_i_min/max/avg 进 metrics)
+ *  - thumbnail(width)  image 生成缩略图(thumbPng,最近邻抽点)
+ *  - quality-gate      image 亮度统计(brightness/contrast 进 metrics)
+ */
+import { createLogger } from '../logger'
+import { inflateSync } from 'node:zlib'
+import { encodePng, resizeGray } from './png-enc'
+import type { DaqSinkStep } from '../../../../shared/daq-protocol'
+
+const log = createLogger('daq.frames')
+
+/** 下沉管线的处理中帧(blob 仅在生产侧管线内存续,入队前被替换为 objectKey) */
+export interface DaqFrameWorking {
+  kind: 'vector' | 'image'
+  /** vector:工程量点列 */
+  points?: number[]
+  /** image:原始 PNG blob(生产侧管线内;入队前剥离) */
+  blob?: Buffer
+  thumbBlob?: Buffer
+  mime?: string
+  width?: number
+  height?: number
+  metrics?: Record<string, number>
+}
+
+export interface DaqFrameProcessor {
+  name: string
+  /** 适用形态(any = 两种都吃) */
+  applies: 'vector' | 'image' | 'any'
+  process(frame: DaqFrameWorking, args: Record<string, unknown>): DaqFrameWorking
+}
+
+// ---------- 内置处理器 ----------
+
+const num = (v: unknown, fallback: number): number => (Number.isFinite(Number(v)) ? Number(v) : fallback)
+
+function vectorStats(points: number[]): { min: number, max: number, avg: number } {
+  let min = Infinity
+  let max = -Infinity
+  let sum = 0
+  for (const p of points) {
+    if (p < min) min = p
+    if (p > max) max = p
+    sum += p
+  }
+  return { min, max, avg: points.length > 0 ? sum / points.length : 0 }
+}
+
+const resample: DaqFrameProcessor = {
+  name: 'resample',
+  applies: 'vector',
+  process(frame, args) {
+    const n = Math.max(2, Math.min(4096, Math.round(num(args.n, frame.points?.length ?? 64))))
+    const src = frame.points ?? []
+    if (src.length === n || src.length === 0) return { ...frame, points: src }
+    const out: number[] = []
+    for (let i = 0; i < n; i++) {
+      const pos = (i * (src.length - 1)) / (n - 1)
+      const lo = Math.floor(pos)
+      const hi = Math.min(src.length - 1, lo + 1)
+      const f = pos - lo
+      out.push(src[lo]! * (1 - f) + src[hi]! * f)
+    }
+    return { ...frame, points: out }
+  },
+}
+
+const deriveMetric: DaqFrameProcessor = {
+  name: 'derive-metric',
+  applies: 'any',
+  process(frame, args) {
+    const name = String(args.name ?? '').trim()
+    if (!name) return frame
+    const op = String(args.op ?? 'avg')
+    let value: number
+    if (frame.points && frame.points.length > 0) {
+      const st = vectorStats(frame.points)
+      value = op === 'min' ? st.min : op === 'max' ? st.max : op === 'range' ? st.max - st.min : op === 'std' ? stdOf(frame.points) : st.avg
+    }
+    else {
+      value = num(frame.metrics?.[op], Number.NaN)
+      if (!Number.isFinite(value)) return frame
+    }
+    return { ...frame, metrics: { ...frame.metrics, [name]: Math.round(value * 1e6) / 1e6 } }
+  },
+}
+
+function stdOf(points: number[]): number {
+  if (points.length === 0) return 0
+  const avg = points.reduce((s, p) => s + p, 0) / points.length
+  const v = points.reduce((s, p) => s + (p - avg) ** 2, 0) / points.length
+  return Math.sqrt(v)
+}
+
+const zones: DaqFrameProcessor = {
+  name: 'zones',
+  applies: 'vector',
+  process(frame, args) {
+    const src = frame.points ?? []
+    const n = Math.max(2, Math.min(64, Math.round(num(args.n, 8))))
+    const size = Math.max(1, Math.floor(src.length / n))
+    const metrics = { ...frame.metrics }
+    for (let z = 0; z < n; z++) {
+      const seg = src.slice(z * size, z === n - 1 ? src.length : (z + 1) * size)
+      if (seg.length === 0) continue
+      const st = vectorStats(seg)
+      metrics[`zone${z + 1}_min`] = Math.round(st.min * 1e6) / 1e6
+      metrics[`zone${z + 1}_max`] = Math.round(st.max * 1e6) / 1e6
+      metrics[`zone${z + 1}_avg`] = Math.round(st.avg * 1e6) / 1e6
+    }
+    return { ...frame, metrics }
+  },
+}
+
+const thumbnail: DaqFrameProcessor = {
+  name: 'thumbnail',
+  applies: 'image',
+  process(frame, args) {
+    const w = frame.width ?? 0
+    const h = frame.height ?? 0
+    if (!frame.blob || w <= 0 || h <= 0) return frame
+    const tw = Math.max(16, Math.min(1024, Math.round(num(args.width, 256))))
+    const th = Math.max(1, Math.round((h * tw) / w))
+    // blob 为本仓 png-enc 的灰度 PNG:解不出像素时跳过(缩略图缺省,主图可达)
+    const gray = decodeGrayPng(frame.blob, w, h)
+    if (!gray) return frame
+    const small = resizeGray(gray, w, h, tw, th)
+    return { ...frame, thumbBlob: encodePng(tw, th, small), metrics: frame.metrics }
+  },
+}
+
+/** 最小灰度 PNG 解码(仅支持本仓 encodePng 产出的 filter-0/8bit 灰度;其余返回 null) */
+function decodeGrayPng(blob: Buffer, w: number, h: number): Uint8Array | null {
+  try {
+    // 定位 IDAT(跳签名+IHDR;本仓编码器结构固定,宽容解析)
+    let off = 8
+    const idat: Buffer[] = []
+    while (off + 8 <= blob.length) {
+      const len = blob.readUInt32BE(off)
+      const type = blob.subarray(off + 4, off + 8).toString('ascii')
+      if (type === 'IDAT') idat.push(blob.subarray(off + 8, off + 8 + len))
+      off += 12 + len
+    }
+    if (idat.length === 0) return null
+    const raw = inflateSync(Buffer.concat(idat))
+    const stride = w + 1
+    if (raw.length < stride * h) return null
+    const out = new Uint8Array(w * h)
+    for (let y = 0; y < h; y++) out.set(raw.subarray(y * stride + 1, y * stride + 1 + w), y * w)
+    return out
+  }
+  catch {
+    return null
+  }
+}
+
+const qualityGate: DaqFrameProcessor = {
+  name: 'quality-gate',
+  applies: 'image',
+  process(frame) {
+    const w = frame.width ?? 0
+    const h = frame.height ?? 0
+    if (!frame.blob || w <= 0 || h <= 0) return frame
+    const gray = decodeGrayPng(frame.blob, w, h)
+    if (!gray) return frame
+    let sum = 0
+    for (const v of gray) sum += v
+    const brightness = sum / gray.length
+    let varSum = 0
+    for (const v of gray) varSum += (v - brightness) ** 2
+    const contrast = Math.sqrt(varSum / gray.length)
+    const r = (x: number): number => Math.round(x * 10) / 10
+    return { ...frame, metrics: { ...frame.metrics, brightness: r(brightness), contrast: r(contrast) } }
+  },
+}
+
+// ---------- 注册表 ----------
+
+const builtin = new Map<string, DaqFrameProcessor>([resample, deriveMetric, zones, thumbnail, qualityGate].map(p => [p.name, p]))
+
+const g = globalThis as typeof globalThis & { __daqFrameProcessors?: Map<string, DaqFrameProcessor> }
+function registry(): Map<string, DaqFrameProcessor> {
+  return g.__daqFrameProcessors ??= new Map()
+}
+
+/** 插件处理器注册(同名覆盖内置并告警;热重载时重复注册幂等) */
+export function registerFrameProcessor(p: DaqFrameProcessor): void {
+  if (builtin.has(p.name)) log.warn(`[daq-frames] 插件处理器覆盖内置:「${p.name}」`)
+  registry().set(p.name, p)
+}
+
+/** 已注册处理器名清单(诊断/manifest 用) */
+export function listFrameProcessors(): string[] {
+  return [...builtin.keys(), ...registry().keys()]
+}
+
+/** 执行模板 sink 管线(生产侧;单步失败保留原帧并告警,永不抛出) */
+export function runSinkPipeline(frame: DaqFrameWorking, steps: DaqSinkStep[] | undefined, nodeId: string): DaqFrameWorking {
+  if (!steps || steps.length === 0) return frame
+  let cur = frame
+  for (const step of steps) {
+    try {
+      const p = registry().get(step.name) ?? builtin.get(step.name)
+      if (!p) {
+        log.warn(`[daq-frames] ${nodeId} 未知处理器「${step.name}」,跳过`)
+        continue
+      }
+      if (p.applies !== 'any' && p.applies !== cur.kind) continue
+      cur = p.process(cur, step.args ?? {})
+    }
+    catch (err) {
+      log.error(`[daq-frames] ${nodeId} 处理器「${step.name}」失败(保留原帧):`, err instanceof Error ? err.message : err)
+    }
+  }
+  return cur
+}

package/server/services/workshop/daq/infra.ts

@@ -11,20 +11,22 @@
  * 控制器停采(在线数采停用),meta 携带 warning,前端横幅 + 一键重连;
  * 后台每 30s 自动重试,恢复后自动重启采集并切回真实后端。
  */
-import { createLogger } from '../logger'
+import { createLogger } from '../logger'
 import { execFile } from 'node:child_process'
 import { createConnection } from 'node:net'
 import { promisify } from 'node:util'
 import { join } from 'node:path'
 
-const log = createLogger('daq.infra')
-
+const log = createLogger('daq.infra')
+
 const execFileAsync = promisify(execFile)
 
 export interface DaqInfraConfig {
   startInfrastructure: 'auto' | 'always' | 'never'
   mqtt: { host: string, port: number, username?: string, password?: string, secure?: boolean, caFile?: string }
   timescale: { host: string, port: number, user: string, password: string, database: string }
+  /** 对象存储(v2:图像帧;不可达 → 本地磁盘降级,不阻断采集) */
+  objectstore?: { host: string, port: number, accessKey: string, secretKey: string, bucket: string }
 }
 
 export interface DaqInfraStatus {
@@ -32,6 +34,8 @@ export interface DaqInfraStatus {
   mqttOnline: boolean
   /** Timescale 是否在线(离线 → SQLite 时序仿真降级) */
   tsdbOnline: boolean
+  /** 对象存储是否在线(离线 → 本地磁盘降级;不计入 degraded,采集不中断) */
+  objectStoreOnline: boolean
   /** 任一降级 → 在线采集停用,前端横幅警告 */
   degraded: boolean
   warning: string
@@ -48,7 +52,7 @@ const g = globalThis as typeof globalThis & {
 function state() {
   return g.__daqInfra ??= {
     cfg: { startInfrastructure: 'auto', mqtt: { host: '127.0.0.1', port: 1883 }, timescale: { host: '127.0.0.1', port: 5432, user: 'postgres', password: 'awshop', database: 'awshop' } },
-    status: { mqttOnline: false, tsdbOnline: false, degraded: true, warning: '', startedBy: 'none', lastCheckAt: new Date().toISOString() },
+    status: { mqttOnline: false, tsdbOnline: false, objectStoreOnline: false, degraded: true, warning: '', startedBy: 'none', lastCheckAt: new Date().toISOString() },
   }
 }
 
@@ -78,7 +82,7 @@ async function dockerAvailable(): Promise<boolean> {
 
 async function dockerComposeUp(projectRoot: string): Promise<{ ok: boolean, error?: string }> {
   try {
-    await execFileAsync('docker', ['compose', '-f', join(projectRoot, 'docker-compose.yml'), 'up', '-d', 'daq-mosquitto', 'daq-timescale'], { timeout: 120_000, cwd: projectRoot })
+    await execFileAsync('docker', ['compose', '-f', join(projectRoot, 'docker-compose.yml'), 'up', '-d', 'daq-mosquitto', 'daq-timescale', 'daq-minio'], { timeout: 180_000, cwd: projectRoot })
     return { ok: true }
   }
   catch (err) {
@@ -86,17 +90,19 @@ async function dockerComposeUp(projectRoot: string): Promise<{ ok: boolean, erro
   }
 }
 
-/** 等待两个端口就绪(拉起后服务初始化需要数秒;最长 waitMs) */
-async function waitPorts(cfg: DaqInfraConfig, waitMs: number): Promise<{ mqtt: boolean, tsdb: boolean }> {
+/** 等待三个端口就绪(拉起后服务初始化需要数秒;最长 waitMs) */
+async function waitPorts(cfg: DaqInfraConfig, waitMs: number): Promise<{ mqtt: boolean, tsdb: boolean, os: boolean }> {
   const deadline = Date.now() + waitMs
   let mqtt = false
   let tsdb = false
-  while (Date.now() < deadline && !(mqtt && tsdb)) {
+  let os = false
+  while (Date.now() < deadline && !(mqtt && tsdb && os)) {
     mqtt = mqtt || await probePort(cfg.mqtt.host, cfg.mqtt.port, 1200)
     tsdb = tsdb || await probePort(cfg.timescale.host, cfg.timescale.port, 1200)
-    if (!(mqtt && tsdb)) await new Promise(r => setTimeout(r, 1500))
+    os = os || await probePort(cfg.objectstore?.host ?? '127.0.0.1', cfg.objectstore?.port ?? 9000, 1200)
+    if (!(mqtt && tsdb && os)) await new Promise(r => setTimeout(r, 1500))
   }
-  return { mqtt, tsdb }
+  return { mqtt, tsdb, os }
 }
 
 export function daqInfraStatus(): DaqInfraStatus {
@@ -108,8 +114,8 @@ export function daqInfraConfig(): DaqInfraConfig {
   return state().cfg
 }
 
-/** 配置 → 连接 URL(env 显式覆盖优先,便于外部托管 broker/db;S1:支持凭据/TLS) */
-export function daqUrls(cfg = state().cfg): { mqttUrl: string | null, tsdbUrl: string | null } {
+/** 配置 → 连接 URL(env 显式覆盖优先,便于外部托管 broker/db/对象存储;S1:支持凭据/TLS) */
+export function daqUrls(cfg = state().cfg): { mqttUrl: string | null, tsdbUrl: string | null, objectStoreUrl: string | null } {
   // S1:凭据/TLS 优先 env(DAQ_MQTT_URL 整串覆盖),否则由 config.mqtt 拼(含 user:pass@ 与 mqtts://)
   let mqttUrl: string
   if (process.env.DAQ_MQTT_URL) {
@@ -124,7 +130,13 @@ export function daqUrls(cfg = state().cfg): { mqttUrl: string | null, tsdbUrl: s
   }
   const { user, password, database, host, port } = cfg.timescale
   const tsdbUrl = process.env.DAQ_TSDB_URL ?? `postgres://${encodeURIComponent(user)}:${encodeURIComponent(password)}@${host}:${port}/${database}`
-  return { mqttUrl, tsdbUrl }
+  // 对象存储(v2):DAQ_OS_URL 覆盖;未配置 objectstore 段 → null(磁盘降级)
+  const osCfg = cfg.objectstore
+  const objectStoreUrl = process.env.DAQ_OS_URL
+    ?? (osCfg
+      ? `http://${encodeURIComponent(osCfg.accessKey)}:${encodeURIComponent(osCfg.secretKey)}@${osCfg.host}:${osCfg.port}/${osCfg.bucket}`
+      : null)
+  return { mqttUrl, tsdbUrl, objectStoreUrl }
 }
 
 /**
@@ -141,12 +153,11 @@ export async function ensureDaqInfrastructure(cfg: DaqInfraConfig, projectRoot:
   // 1) 直接探测配置地址
   let probe = await waitPorts(cfg, 3000)
   s.startedBy = 'none'
-
   // 2) 不通 → 按策略 Docker 拉起
   if (!(probe.mqtt && probe.tsdb) && cfg.startInfrastructure !== 'never') {
     const canDocker = await dockerAvailable()
     if (canDocker) {
-      log.info('[daq-infra] 配置地址未就绪,经 Docker Compose 拉起(daq-mosquitto + daq-timescale)…')
+      log.info('[daq-infra] 配置地址未就绪,经 Docker Compose 拉起(daq-mosquitto + daq-timescale + daq-minio)…')
       const up = await dockerComposeUp(projectRoot)
       if (up.ok) {
         probe = await waitPorts(cfg, 60_000)
@@ -168,6 +179,7 @@ export async function ensureDaqInfrastructure(cfg: DaqInfraConfig, projectRoot:
 
   s.mqttOnline = probe.mqtt
   s.tsdbOnline = probe.tsdb
+  s.objectStoreOnline = probe.os
   s.degraded = !(probe.mqtt && probe.tsdb)
 
   if (s.degraded) {
@@ -178,8 +190,10 @@ export async function ensureDaqInfrastructure(cfg: DaqInfraConfig, projectRoot:
     log.warn(`[daq-infra] 降级运行 — ${s.warning}`)
   }
   else {
-    s.warning = ''
-    log.info(`[daq-infra] 真实链路就绪(mqtt=${cfg.mqtt.host}:${cfg.mqtt.port}, timescale=${cfg.timescale.host}:${cfg.timescale.port}, 来源=${s.startedBy})`)
+    s.warning = probe.os
+      ? ''
+      : `对象存储(MinIO)不可达:图像帧已降级本地磁盘(data/daq-objects/),采集不中断。`
+    log.info(`[daq-infra] 真实链路就绪(mqtt=${cfg.mqtt.host}:${cfg.mqtt.port}, timescale=${cfg.timescale.host}:${cfg.timescale.port}, objectstore=${probe.os ? `${cfg.objectstore?.host}:${cfg.objectstore?.port}` : 'disk-degraded'}, 来源=${s.startedBy})`)
   }
   return daqInfraStatus()
 }

package/server/services/workshop/daq/objectstore/disk.adapter.ts

@@ -0,0 +1,38 @@
+/**
+ * DiskObjectAdapter —— 对象存储的本地磁盘降级实现(data/daq-objects/)。
+ * MinIO 不可达时帧管线自动切换到此适配器(采集不中断;meta.infra 报告 disk:degraded)。
+ */
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { join, resolve } from 'node:path'
+import { ensureDataDir } from '@/shared/config/home.mjs'
+import type { DaqObjectStore } from './objectstore-port'
+
+const ROOT = resolve(join(ensureDataDir(), 'daq-objects'))
+
+export class DiskObjectAdapter implements DaqObjectStore {
+  readonly backend = 'disk'
+
+  async init(): Promise<void> {
+    await mkdir(ROOT, { recursive: true })
+  }
+
+  /** key 归一(防路径逃逸:只允许 [A-Za-z0-9/._-];非法字符拒绝) */
+  private pathOf(key: string): string {
+    if (!/^[A-Za-z0-9][A-Za-z0-9/._-]*$/.test(key)) throw new Error(`非法对象键: ${key}`)
+    return join(ROOT, key)
+  }
+
+  async put(key: string, data: Buffer): Promise<void> {
+    const p = this.pathOf(key)
+    await mkdir(join(p, '..'), { recursive: true })
+    await writeFile(p, data)
+  }
+
+  async get(key: string): Promise<Buffer> {
+    return readFile(this.pathOf(key))
+  }
+
+  async remove(key: string): Promise<void> {
+    await rm(this.pathOf(key), { force: true })
+  }
+}

package/server/services/workshop/daq/objectstore/index.ts

@@ -0,0 +1,88 @@
+/**
+ * DaqObjectStore 工厂 —— 配置驱动,MinIO 不可达自动降级本地磁盘。
+ * 单例挂 globalThis;rebuildObjectStore() 支持重连时切回真实实例(与 tsdb 工厂同构)。
+ */
+import { createLogger } from '../../logger'
+import { DiskObjectAdapter } from './disk.adapter'
+import { MinioObjectAdapter } from './minio.adapter'
+import type { DaqObjectStore } from './objectstore-port'
+
+const log = createLogger('daq.objectstore')
+
+interface DaqOsState { current?: DaqObjectStore }
+const g = globalThis as typeof globalThis & { __daqObjectStoreState?: DaqOsState }
+
+/**
+ * 解析对象存储连接(DAQ_OS_URL 显式覆盖优先):
+ *   http://accessKey:secretKey@host:port/bucket
+ */
+export function parseObjectStoreUrl(url: string): { endPoint: string, port: number, accessKey: string, secretKey: string, bucket: string } | null {
+  try {
+    const u = new URL(url)
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') return null
+    return {
+      endPoint: u.hostname,
+      port: Number(u.port || (u.protocol === 'https:' ? 443 : 80)),
+      accessKey: decodeURIComponent(u.username || 'awshop'),
+      secretKey: decodeURIComponent(u.password || 'awshop'),
+      bucket: decodeURIComponent(u.pathname.replace(/^\//, '')) || 'daq',
+    }
+  }
+  catch {
+    return null
+  }
+}
+
+function makeFallback(reason: string): DaqObjectStore {
+  const dev = new DiskObjectAdapter()
+  void dev.init()
+  log.warn(`[daq-objectstore] ${reason} → 已降级本地磁盘(data/daq-objects/)`)
+  return dev
+}
+
+export function getObjectStore(): DaqObjectStore {
+  const st: DaqOsState = g.__daqObjectStoreState ??= {}
+  let cur = st.current
+  if (!cur) {
+    cur = new DiskObjectAdapter()
+    void cur.init()
+    log.info('[daq-objectstore] 本地磁盘对象存储就绪(data/daq-objects/)')
+    st.current = cur
+  }
+  return cur
+}
+
+/** 重连/初始装配:online 且 url 可解析 → MinIO(5×2.5s 重试扛容器初始化窗口);否则磁盘降级 */
+export async function rebuildObjectStore(online: boolean, url?: string | null): Promise<void> {
+  const st: DaqOsState = g.__daqObjectStoreState ??= {}
+  const swap = (next: DaqObjectStore): void => {
+    const old = st.current
+    st.current = next
+    void Promise.resolve(old?.close?.()).catch(() => {})
+  }
+  const parsed = url ? parseObjectStoreUrl(url) : null
+  if (!online || !parsed) {
+    if (st.current?.backend !== 'disk') swap(makeFallback('infra 判定离线或未配置'))
+    return
+  }
+  const adapter = new MinioObjectAdapter(parsed)
+  let lastErr: unknown
+  for (let i = 0; i < 5; i++) {
+    try {
+      await adapter.init()
+      lastErr = null
+      break
+    }
+    catch (err) {
+      lastErr = err
+      await new Promise(r => setTimeout(r, 2500))
+    }
+  }
+  if (lastErr) {
+    await adapter.close?.().catch(() => {})
+    swap(makeFallback(lastErr instanceof Error ? lastErr.message : String(lastErr)))
+    return
+  }
+  swap(adapter)
+  log.info(`[daq-objectstore] MinIO 就绪(${parsed.endPoint}:${parsed.port}/${parsed.bucket})`)
+}

package/server/services/workshop/daq/objectstore/minio.adapter.ts

@@ -0,0 +1,60 @@
+/**
+ * MinioObjectAdapter —— S3 兼容对象存储实现(compose daq-minio)。
+ *
+ * minio 官方客户端经 createRequire 加载(nitro Windows 动态 import external 的
+ * 'd:' scheme 坑,与 pg/mqtt 同款规避);bucket 不存在时 init 幂等创建。
+ */
+import { createRequire } from 'node:module'
+import type { DaqObjectStore } from './objectstore-port'
+
+const reqOs = createRequire(import.meta.url)
+
+export interface MinioConnectOpts {
+  endPoint: string
+  port: number
+  accessKey: string
+  secretKey: string
+  bucket: string
+}
+
+export class MinioObjectAdapter implements DaqObjectStore {
+  readonly backend = 'minio'
+  private client: import('minio').Client | null = null
+
+  constructor(private readonly opts: MinioConnectOpts) {}
+
+  async init(): Promise<void> {
+    const mod = reqOs('minio') as unknown as { Client: new (o: Record<string, unknown>) => import('minio').Client }
+    this.client = new mod.Client({
+      endPoint: this.opts.endPoint,
+      port: this.opts.port,
+      useSSL: false,
+      accessKey: this.opts.accessKey,
+      secretKey: this.opts.secretKey,
+    })
+    const exists = await this.client.bucketExists(this.opts.bucket).catch(() => false)
+    if (!exists) await this.client.makeBucket(this.opts.bucket, 'us-east-1')
+  }
+
+  async put(key: string, data: Buffer, contentType: string): Promise<void> {
+    if (!this.client) throw new Error('minio 未初始化')
+    await this.client.putObject(this.opts.bucket, key, data, data.length, { 'Content-Type': contentType })
+  }
+
+  async get(key: string): Promise<Buffer> {
+    if (!this.client) throw new Error('minio 未初始化')
+    const stream = await this.client.getObject(this.opts.bucket, key)
+    const chunks: Buffer[] = []
+    for await (const c of stream) chunks.push(c as Buffer)
+    return Buffer.concat(chunks)
+  }
+
+  async remove(key: string): Promise<void> {
+    if (!this.client) return
+    await this.client.removeObject(this.opts.bucket, key)
+  }
+
+  async close(): Promise<void> {
+    this.client = null
+  }
+}

package/server/services/workshop/daq/objectstore/objectstore-port.ts

@@ -0,0 +1,27 @@
+/**
+ * DaqObjectStore 端口(hexagonal seam)—— 图像等非结构化帧数据的持久化出口。
+ *
+ * 分工约定(plan D1/D3):Timescale 存帧元数据(daq_frames.meta.objectKey),
+ * 像素 blob 只落对象存储;实现:
+ *  - minio.adapter —— S3 兼容(compose daq-minio;DAQ_OS_URL / config daq.objectstore 启用)
+ *  - disk.adapter  —— 本地磁盘降级(data/daq-objects/;MinIO 不可达时自动切换,采集不中断)
+ */
+
+export interface DaqObjectStore {
+  /** 后端标识(minio | disk)——REST meta 直报前端 */
+  readonly backend: string
+  init(): Promise<void>
+  put(key: string, data: Buffer, contentType: string): Promise<void>
+  get(key: string): Promise<Buffer>
+  remove(key: string): Promise<void>
+  close?(): Promise<void> | void
+}
+
+/** 对象键生成(daq/<nodeId>/<yyyy>/<mm>/<dd>/<ts><suffix>) */
+export function daqObjectKey(nodeId: string, tsMs: number, ext: string): string {
+  const d = new Date(tsMs)
+  const yyyy = d.getUTCFullYear()
+  const mm = String(d.getUTCMonth() + 1).padStart(2, '0')
+  const dd = String(d.getUTCDate()).padStart(2, '0')
+  return `daq/${nodeId}/${yyyy}/${mm}/${dd}/${tsMs}${ext}`
+}

package/server/services/workshop/daq/plugin-bridge.ts

@@ -0,0 +1,73 @@
+import type { DaqTemplateDef } from '../../../../shared/daq-protocol'
+import { getDaqTemplateRegistry } from './daq-templates'
+import { registerPluginDriver } from './drivers'
+import { registerFrameProcessor } from './frames'
+
+interface DaqPluginBridge {
+  pendingDrivers: unknown[]
+  pendingProcessors: Array<{ kind: string, name: string, fn: unknown }>
+  pendingTemplates: unknown[]
+  /** 回放槽(drain 接管后设置;注册即时回调) */
+  _drain?: () => void
+  registerDriver(d: unknown): void
+  registerProcessor(kind: string, name: string, fn: unknown): void
+  registerTemplate(t: unknown): void
+  drain(onDriver: (d: unknown) => void, onProcessor: (kind: string, name: string, fn: unknown) => void, onTemplate: (t: unknown) => void): void
+}
+
+/** 自建桥(仅队列 + drain 槽;宿主后到时由其接管) */
+function makeDaqBridge(): DaqPluginBridge {
+  return {
+    pendingDrivers: [],
+    pendingProcessors: [],
+    pendingTemplates: [],
+    registerDriver(d) {
+      this.pendingDrivers.push(d)
+      this._drain?.()
+    },
+    registerProcessor(kind, name, fn) {
+      this.pendingProcessors.push({ kind, name, fn })
+      this._drain?.()
+    },
+    registerTemplate(t) {
+      this.pendingTemplates.push(t)
+      this._drain?.()
+    },
+    drain(onDriver, onProcessor, onTemplate) {
+      this._drain = () => {
+        for (const d of this.pendingDrivers.splice(0)) onDriver(d)
+        for (const p of this.pendingProcessors.splice(0)) onProcessor(p.kind, p.name, p.fn)
+        for (const t of this.pendingTemplates.splice(0)) onTemplate(t)
+      }
+      this._drain()
+    },
+  }
+}
+
+let attached = false
+
+export function attachDaqPluginBridge(): void {
+  if (attached) return
+  attached = true
+  // 顺序无关:daq 先于插件宿主装载时桥尚不存在 → 此处自建(仅队列+drain 槽);
+  // 反之宿主已建桥则直接接管。drain 设槽即回放,后续注册实时到达。
+  const g = globalThis as { __daqPluginExt?: DaqPluginBridge }
+  const bridge: DaqPluginBridge = g.__daqPluginExt ?? makeDaqBridge()
+  g.__daqPluginExt = bridge
+  bridge.drain(
+    d => registerPluginDriver(d as Parameters<typeof registerPluginDriver>[0]),
+    (kind, name, fn) => registerFrameProcessor({
+      name,
+      applies: kind === 'vector' ? 'vector' : kind === 'image' ? 'image' : 'any',
+      process: fn as Parameters<typeof registerFrameProcessor>[0]['process'],
+    }),
+    (t) => {
+      try {
+        getDaqTemplateRegistry().registerPlugin(t as DaqTemplateDef)
+      }
+      catch (err) {
+        console.error('[daq] 插件模板注册失败:', err instanceof Error ? err.message : err)
+      }
+    },
+  )
+}