dsh-mesh-node 0.0.0-stage → 0.0.2

package/src/core/session-profile.js

@@ -0,0 +1,146 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+/**
+ * Delegation safety profile (2026-10-25).
+ *
+ * A peer must never inject a task into a session that owns a scheduled job:
+ * that mixes two contexts and pollutes the scheduled conversation (real
+ * incident: a `channel_wake` landed inside a company `定时-*` session).
+ *
+ * The profile joins two local sources of truth:
+ *   - `<dshHome>/storages/schedule.json`      schedules  -> sessionId
+ *   - `<fsRoot>/.mesh/tasks/<taskId>/request.json` delegations -> sessionId
+ *
+ * A session is *protected* when it owns at least one schedule record.
+ * Delegations are the sessions this node created for a peer, so they are
+ * identified explicitly instead of being guessed from titles.
+ */
+
+const TITLE_SCHEDULE_HINT = /定时|班次|schedule|nightly/i
+const EMPTY = Object.freeze([])
+
+function readJson(file, fallback = null) {
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'))
+  } catch {
+    return fallback
+  }
+}
+
+/** `<home>/profiles/web` -> `<home>`; empty/unknown profileDir -> ''. */
+export function dshHomeOf(hostEntry) {
+  const dir = String(hostEntry?.profileDir || '')
+  if (!dir) return ''
+  return dirname(dirname(dir))
+}
+
+/** sessionId -> [{id,title,kind,status,instance}] for one configured instance. */
+export function readScheduleIndex(hostEntry) {
+  const home = dshHomeOf(hostEntry)
+  const file = home ? join(home, 'storages', 'schedule.json') : ''
+  const index = new Map()
+  const raw = file && existsSync(file) ? readJson(file) : null
+  const tasks = raw?.tables?.tasks || {}
+  for (const [id, entry] of Object.entries(tasks)) {
+    const sessionId = entry?.sessionId
+    if (!sessionId) continue
+    const record = entry.record || {}
+    const rows = index.get(sessionId) || []
+    rows.push({
+      id,
+      title: record.title || '',
+      kind: record.kind || '',
+      status: entry.status || '',
+      instance: hostEntry?.id || ''
+    })
+    index.set(sessionId, rows)
+  }
+  return index
+}
+
+/** sessionId -> delegation record from this node's `.mesh/tasks` mailbox. */
+export function readDelegationIndex(root) {
+  const dir = root ? join(root, '.mesh', 'tasks') : ''
+  const index = new Map()
+  if (!dir || !existsSync(dir)) return index
+  let names = []
+  try {
+    names = readdirSync(dir)
+  } catch {
+    return index
+  }
+  for (const name of names) {
+    const request = readJson(join(dir, name, 'request.json'))
+    if (!request?.sessionId) continue
+    index.set(request.sessionId, {
+      taskId: request.taskId || name,
+      conversationId: request.conversationId || '',
+      from: request.from || '',
+      policy: request.sessionPolicy || '',
+      createdAt: request.requestedAt || ''
+    })
+  }
+  return index
+}
+
+/** Join every configured instance's schedules plus this node's delegations. */
+export function buildSessionProfile(config) {
+  const schedules = new Map()
+  for (const entry of config?.hosts || []) {
+    if (entry?.enabled === false) continue
+    for (const [sessionId, rows] of readScheduleIndex(entry)) {
+      const merged = schedules.get(sessionId) || []
+      merged.push(...rows.map((row) => ({ ...row, instance: entry.id })))
+      schedules.set(sessionId, merged)
+    }
+  }
+  return { schedules, delegations: readDelegationIndex(config?.acl?.fsRoots?.[0] || '') }
+}
+
+/** Classify one host_sessions / delegate_candidates / listAgents row. */
+export function classifySession(profile, session) {
+  const sessionId = session?.sessionId || session?.id || ''
+  const schedules = profile?.schedules?.get(sessionId) || EMPTY
+  const delegation = profile?.delegations?.get(sessionId) || null
+  const title = String(session?.title || '')
+  const alive = session?.agentAvailable === true && session?.state !== 'ended'
+  let kind = 'unknown'
+  let reason = 'no schedule record and no delegation record'
+  if (schedules.length > 0) {
+    kind = 'business-scheduled'
+    reason = `owns ${schedules.length} scheduled task(s) — injecting here would pollute the scheduled conversation`
+  } else if (delegation) {
+    kind = 'delegation'
+    reason = `created by delegation ${delegation.taskId}`
+  } else if (TITLE_SCHEDULE_HINT.test(title)) {
+    kind = 'business'
+    reason = 'title looks like a scheduled/business session (no schedule record found — still inject with care)'
+  }
+  return {
+    kind,
+    protected: schedules.length > 0,
+    delegatable: alive && schedules.length === 0,
+    recommended: alive && String(session?.state) === 'idle' && schedules.length === 0,
+    reason,
+    schedules,
+    delegation
+  }
+}
+
+/**
+ * Guard for write-capable tools (host_session_prompt / channel_wake /
+ * host_call / delegate continuation). Returns null when the target is safe.
+ */
+export function sessionBlock(profile, sessionId) {
+  const schedules = profile?.schedules?.get(String(sessionId || '')) || EMPTY
+  if (schedules.length === 0) return null
+  return {
+    kind: 'business-scheduled',
+    reason: `session ${sessionId} owns ${schedules.length} scheduled task(s): ${schedules
+      .map((row) => row.title || row.id)
+      .join(' / ')}`,
+    schedules,
+    hint: 'delegate to a FRESH conversation instead (omit sessionId), or pass force:true if you really mean to inject into this scheduled session'
+  }
+}

package/src/core/tls.js

@@ -0,0 +1,160 @@
+/**
+ * TLS：自签证书生成与校验信息读取。
+ *
+ * 为什么需要：樱花穿透的 TCP 隧道默认不加密（只有「访问认证」，没有传输加密），
+ * Bearer token 与所有 MCP 报文都会明文过公网。跨网阶段必须自带 TLS。
+ *
+ * 设计取舍：
+ * - 自签「CA-and-leaf」证书（basicConstraints CA:true + serverAuth EKU），这样对端
+ *   把 cert.pem 当作信任锚（NODE_EXTRA_CA_CERTS）就能通过校验，不需要额外 CA 基础设施。
+ * - SAN 里默认包含 localhost / 127.0.0.1 / 本机 hostname；樱花隧道建好后用
+ *   `--san <节点域名>` 重新生成（或首次生成时一次给全）。
+ * - 私钥 0600 落 `~/.dsh-mesh/tls/key.pem`，不进 git、不进任何快照。
+ */
+
+import { X509Certificate } from 'node:crypto'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { hostname as osHostname } from 'node:os'
+import { join } from 'node:path'
+import selfsigned from 'selfsigned'
+
+/** TLS 文件目录。 */
+export function tlsDir(home) {
+  return join(home, 'tls')
+}
+
+/** 证书路径（可在 config.tls.cert 覆盖）。 */
+export function certPath(home) {
+  return join(tlsDir(home), 'cert.pem')
+}
+
+/** 私钥路径（可在 config.tls.key 覆盖）。 */
+export function keyPath(home) {
+  return join(tlsDir(home), 'key.pem')
+}
+
+/** 是否已生成证书。 */
+export function hasCert(home) {
+  return existsSync(certPath(home)) && existsSync(keyPath(home))
+}
+
+/** 判断字符串是不是 IPv4/IPv6 字面量。 */
+function isIp(value) {
+  return /^(\d{1,3}\.){3}\d{1,3}$/.test(value) || /^[0-9a-f:]+$/i.test(value) && value.includes(':')
+}
+
+/** 构造 SAN 列表：总是包含本机可用的默认项，再合并调用方给的。 */
+export function buildAltNames(extra = []) {
+  const names = new Set(['localhost', '127.0.0.1', osHostname()])
+  for (const item of extra) {
+    const value = String(item).trim()
+    if (value.length > 0) names.add(value)
+  }
+  return [...names].map(value => (isIp(value) ? { type: 7, ip: value } : { type: 2, value }))
+}
+
+/**
+ * 生成自签证书。
+ * @returns {{certPath: string, keyPath: string, info: object}}
+ */
+export async function generateCert({ home, sans = [], days = 825, keySize = 2048, commonName, force = false }) {
+  const dir = tlsDir(home)
+  mkdirSync(dir, { recursive: true })
+  if (!force && hasCert(home)) {
+    return { certPath: certPath(home), keyPath: keyPath(home), info: describeCert(home), reused: true }
+  }
+  const altNames = buildAltNames(sans)
+  const attrs = [{ name: 'commonName', value: commonName ?? `dsh-mesh-${osHostname()}` }]
+  const pems = await selfsigned.generate(attrs, {
+    days,
+    keySize,
+    algorithm: 'sha256',
+    extensions: [
+      { name: 'basicConstraints', cA: true },
+      { name: 'keyUsage', digitalSignature: true, keyEncipherment: true, keyCertSign: true },
+      { name: 'extKeyUsage', serverAuth: true, clientAuth: true },
+      { name: 'subjectAltName', altNames },
+    ],
+  })
+  writeFileSync(certPath(home), pems.cert, { mode: 0o644 })
+  writeFileSync(keyPath(home), pems.private, { mode: 0o600 })
+  return { certPath: certPath(home), keyPath: keyPath(home), info: describeCert(home), reused: false, sans: altNames }
+}
+
+/** 读取证书的人类可读信息（也用于 `tls info`）。 */
+export function describeCert(home) {
+  if (!hasCert(home)) return { present: false }
+  const cert = new X509Certificate(readFileSync(certPath(home)))
+  return {
+    present: true,
+    certPath: certPath(home),
+    keyPath: keyPath(home),
+    subject: cert.subject.replace(/\n/g, ', '),
+    issuer: cert.issuer.replace(/\n/g, ', '),
+    validFrom: cert.validFrom,
+    validTo: cert.validTo,
+    validToDate: new Date(cert.validTo).toISOString(),
+    fingerprint256: cert.fingerprint256,
+    serialNumber: cert.serialNumber,
+    subjectAltName: cert.subjectAltName,
+    selfSigned: cert.subject === cert.issuer,
+  }
+}
+
+/** 供 https.createServer 使用的证书对。路径缺失时抛结构化错误。 */
+export function loadTlsMaterial({ home, cert, key }) {
+  const certFile = cert || certPath(home)
+  const keyFile = key || keyPath(home)
+  if (!existsSync(certFile) || !existsSync(keyFile)) {
+    const error = new Error(`TLS 已启用但缺少证书：${certFile} / ${keyFile}，先跑 \`node src/cli.js tls init\``)
+    error.code = 'E_TLS_MISSING'
+    throw error
+  }
+  return { cert: readFileSync(certFile), key: readFileSync(keyFile), certFile, keyFile }
+}
+
+/**
+ * 证书指纹规范化：大小写无关、去掉冒号/空格，统一成 64 位大写 hex。
+ *
+ * 为什么需要它：`mesh_self` / `tls info` / `pair --code` 打印的是
+ * `AA:BB:...` 形式（X509Certificate.fingerprint256），而 socket 拿到的也是这种，
+ * 但人手工粘贴时常带上小写或漏冒号 —— 直接字符串比较会假失败。
+ */
+export function normalizeFingerprint(value) {
+  const compact = String(value || '')
+    .replace(/[^0-9a-fA-F]/g, '')
+    .toUpperCase()
+  if (compact.length !== 64) {
+    const error = new Error(`证书指纹应为 64 位 hex（SHA-256），收到 ${compact.length} 位`)
+    error.code = 'E_BAD_FINGERPRINT'
+    throw error
+  }
+  return compact
+}
+
+/** 从 TLS socket 上取对端证书指纹，返回规范化的 64 位 hex。 */
+export function fingerprintOfSocket(socket) {
+  const cert = socket?.getPeerCertificate?.()
+  if (!cert || !cert.fingerprint256) {
+    const error = new Error('对端没有提供证书，无法核对指纹')
+    error.code = 'E_NO_PEER_CERT'
+    throw error
+  }
+  return normalizeFingerprint(cert.fingerprint256)
+}
+
+/** 固定指纹校验：expected / actual 都规范化后比较，失败抛 E_PIN_MISMATCH。 */
+export function assertFingerprint(expected, actual) {
+  const want = normalizeFingerprint(expected)
+  const got = normalizeFingerprint(actual)
+  if (want !== got) {
+    const error = new Error(
+      `证书指纹不匹配（可能被中间人替换或证书已轮换）\n  期望 ${want}\n  实际 ${got}`
+    )
+    error.code = 'E_PIN_MISMATCH'
+    error.expected = want
+    error.actual = got
+    throw error
+  }
+  return got
+}

package/src/core/tunnels.js

@@ -0,0 +1,212 @@
+// dsh-mesh 隧道采集（只读）：自建 frps（.runtime/frpc/frpc.toml）+ Sakura Launcher 日志/进程 + 端口探测
+// 用途：/health 上报给其它节点、mesh-health 聚合、面板显示、可独立 CLI 调用
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import net from 'node:net'
+import { execFileSync } from 'node:child_process'
+import { collectSakuraAccount } from './sakura-api.js'
+
+const SAKURA_LOG_DIR_WIN = 'C:\\ProgramData\\SakuraFrpService\\Logs'
+const SAKURA_LOG_DIR_LINUX = '/var/log/sakurafrp'
+
+function readText(p) {
+  try {
+    return readFileSync(p, 'utf8')
+  } catch {
+    return ''
+  }
+}
+
+function frpcToml(repo) {
+  const file = join(repo || '', '.runtime', 'frpc', 'frpc.toml')
+  const text = readText(file)
+  if (!text) return null
+  const grab = (key) => {
+    const m = new RegExp('^\\s*' + key + '\\s*=\\s*"?([^"\\r\\n]+)"?', 'm').exec(text)
+    return m ? m[1].trim() : null
+  }
+  const host = grab('serverAddr')
+  const port = grab('remotePort')
+  if (!host || !port) return null
+  return { host, port, serverPort: grab('serverPort') || null, localPort: grab('localPort') || null, name: grab('name') || null, configPath: file }
+}
+
+function sakuraTunnels() {
+  const dir = process.platform === 'win32' ? SAKURA_LOG_DIR_WIN : SAKURA_LOG_DIR_LINUX
+  try {
+    if (!existsSync(dir)) return []
+    const files = readdirSync(dir)
+      .filter((n) => n.endsWith('.log'))
+      .sort()
+    if (!files.length) return []
+    const text = readText(join(dir, files[files.length - 1]))
+    const tail = text.slice(-400000)
+    const found = new Map()
+    const re = /frpc\[([^\]|]+)[^\]]*\][^\n]*?使用 >>([^\s:]+):(\d+)<</g
+    let m
+    while ((m = re.exec(tail))) found.set(m[1].trim(), { name: m[1].trim(), host: m[2], port: m[3] })
+    return [...found.values()]
+  } catch {
+    return []
+  }
+}
+
+function processes() {
+  const out = { frpc: [], sakura: [], error: null }
+  try {
+    if (process.platform === 'win32') {
+      const ps = execFileSync(
+        'powershell.exe',
+        [
+          '-NoProfile',
+          '-Command',
+          "Get-CimInstance Win32_Process | Where-Object { $_.Name -match '^(frpc|SakuraLauncher|SakuraFrpService)\\.exe$' } | Select-Object ProcessId,Name,CommandLine | ConvertTo-Json -Compress"
+        ],
+        { encoding: 'utf8', timeout: 8000, windowsHide: true }
+      ).trim()
+      const parsed = ps ? JSON.parse(ps) : []
+      const list = Array.isArray(parsed) ? parsed : [parsed]
+      for (const p of list) {
+        const name = String(p.Name || '')
+        const cmd = String(p.CommandLine || '')
+        if (name.toLowerCase() === 'frpc.exe') {
+          out.frpc.push({ pid: p.ProcessId || null, kind: /SakuraFrpLauncher/i.test(cmd) ? 'sakura' : 'self-hosted', cmd: cmd.slice(0, 200) })
+        } else {
+          out.sakura.push({ pid: p.ProcessId || null, name })
+        }
+      }
+    } else {
+      const txt = execFileSync('ps', ['-eo', 'pid,comm,args'], { encoding: 'utf8', timeout: 5000 }).toString()
+      for (const line of txt.split('\n')) {
+        if (!/frpc/i.test(line)) continue
+        const m = /^\s*(\d+)\s+(\S+)\s+(.*)$/.exec(line)
+        if (!m) continue
+        out.frpc.push({ pid: Number(m[1]), kind: /sakura/i.test(m[3]) ? 'sakura' : 'self-hosted', cmd: m[3].slice(0, 200) })
+      }
+    }
+  } catch (error) {
+    out.error = String(error?.message || error)
+  }
+  return out
+}
+
+/** 已知公网隧道端点（~/.dsh-mesh/tunnels-known.json）：不依赖对端上报即可探测樱花/公网入口。 */
+function knownEndpoints(home) {
+  if (!home) return []
+  try {
+    const raw = JSON.parse(readFileSync(join(home, 'tunnels-known.json'), 'utf8'))
+    const list = Array.isArray(raw?.endpoints) ? raw.endpoints : []
+    return list.filter((x) => x && x.host && x.port).map((x) => ({
+      node: String(x.node || ""),
+      kind: String(x.kind || 'sakura'),
+      host: String(x.host),
+      port: Number(x.port),
+      label: String(x.label || "")
+    }))
+  } catch {
+    return []
+  }
+}
+
+function probe(host, port, timeoutMs) {
+  return new Promise((resolve) => {
+    const startedAt = Date.now()
+    let settled = false
+    const sock = net.connect({ host, port: Number(port) })
+    sock.setTimeout(timeoutMs, () => finish(false, 'timeout'))
+    const finish = (up, error) => {
+      if (settled) return
+      settled = true
+      try {
+        sock.destroy()
+      } catch {
+        /* ignore */
+      }
+      resolve({ up, latencyMs: Date.now() - startedAt, error: error || null })
+    }
+    sock.once('connect', () => finish(true))
+    sock.once('error', (error) => finish(false, String(error?.code || error?.message || error)))
+  })
+}
+
+/**
+ * 采集本机隧道状态（只读，会做少量端口探测，默认 ~2.5s 超时）。
+ * 返回：{ generatedAt, processes, selfHosted, sakura } —— 供 /health / mesh-health / 面板使用。
+ */
+export async function collectTunnels({ repo, home, timeoutMs = 2500 } = {}) {
+  const procs = processes()
+  const selfHosted = frpcToml(repo)
+  const sakura = sakuraTunnels()
+  const selfProbe = selfHosted ? await probe(selfHosted.host, selfHosted.port, timeoutMs) : null
+  const sakuraProbes = await Promise.all(
+    sakura.slice(0, 4).map(async (t) => ({ ...t, probe: await probe(t.host, t.port, timeoutMs) }))
+  )
+  const sakuraAlive = procs.sakura.length > 0 || procs.frpc.some((p) => p.kind === 'sakura')
+  const sakuraAccount = await collectSakuraAccount({ ttlMs: 60_000 })
+  const known = await Promise.all(
+    knownEndpoints(home).map(async (x) => ({ ...x, probe: await probe(x.host, x.port, timeoutMs) }))
+  )
+  return {
+    generatedAt: new Date().toISOString(),
+    processes: procs,
+    selfHosted: selfHosted ? { ...selfHosted, probe: selfProbe } : null,
+    sakura: { launcherRunning: sakuraAlive, tunnels: sakuraProbes },
+    known,
+    sakuraAccount,
+    summary: {
+      selfHostedUp: Boolean(selfProbe && selfProbe.up),
+      sakuraRunning: sakuraAlive,
+      sakuraTunnels: sakuraProbes.length,
+      sakuraUp: sakuraProbes.filter((t) => t.probe && t.probe.up).length,
+      knownUp: known.filter((x) => x.probe && x.probe.up).length,
+      knownTotal: known.length,
+      accountTotal: sakuraAccount.total || 0,
+      accountOnline: sakuraAccount.online || 0,
+      accountError: sakuraAccount.available ? null : (sakuraAccount.error || "unavailable")
+    }
+  }
+}
+
+/** 后台缓存：/health 每次请求都探测会拖慢 peer 探测，这里 60s 刷新一次。 */
+export function createTunnelCache({ repo, home, refreshMs = 60_000, log } = {}) {
+  let value = null
+  let timer = null
+  let running = false
+  const file = home ? join(home, 'TUNNEL.json') : null
+  const refresh = async () => {
+    if (running) return value
+    running = true
+    try {
+      value = await collectTunnels({ repo, home })
+      if (file) {
+        try {
+          const { writeFileSync } = await import('node:fs')
+          writeFileSync(file, JSON.stringify(value, null, 2))
+        } catch {
+          /* ignore */
+        }
+      }
+    } catch (error) {
+      if (log) log('tunnel cache: ' + String(error?.message || error))
+    } finally {
+      running = false
+    }
+    return value
+  }
+  return {
+    start() {
+      refresh().catch(() => {})
+      timer = setInterval(() => refresh().catch(() => {}), refreshMs)
+      if (timer.unref) timer.unref()
+      return this
+    },
+    stop() {
+      if (timer) clearInterval(timer)
+      timer = null
+    },
+    get() {
+      return value
+    },
+    refresh
+  }
+}

package/src/core/util.js

@@ -0,0 +1,68 @@
+import { execFile } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+
+/** Run a command without a shell; resolves (never rejects) with stdout/stderr/error. */
+export function run(cmd, args, { timeout = 20000, cwd, signal, maxBuffer = 8 * 1024 * 1024 } = {}) {
+  return new Promise((resolvePromise) => {
+    execFile(
+      cmd,
+      args,
+      { cwd, timeout, signal, encoding: 'utf8', windowsHide: true, maxBuffer },
+      (error, stdout, stderr) => {
+        resolvePromise({
+          error,
+          stdout: stdout || '',
+          stderr: stderr || '',
+          code: typeof error?.code === 'number' ? error.code : 0,
+          killed: Boolean(error?.killed),
+          timedOut: Boolean(error?.killed && error?.signal === 'SIGTERM')
+        })
+      }
+    )
+  })
+}
+
+/** Trim a string to a byte budget without splitting a UTF-8 code point badly. */
+export function clip(text, maxBytes) {
+  const buf = Buffer.from(text, 'utf8')
+  if (buf.length <= maxBytes) return { text, truncated: false, bytes: buf.length }
+  return { text: buf.subarray(0, maxBytes).toString('utf8'), truncated: true, bytes: buf.length }
+}
+
+export function sha256(text) {
+  return createHash('sha256').update(text, 'utf8').digest('hex')
+}
+
+export function short(text, n = 500) {
+  const s = String(text ?? '')
+  return s.length <= n ? s : s.slice(0, n) + '…'
+}
+
+/** ISO timestamp helper. */
+export function nowIso() {
+  return new Date().toISOString()
+}
+
+/**
+ * Strip a UTF-8 BOM. Windows editors (and PowerShell's Set-Content) love adding one,
+ * and `JSON.parse` chokes on it — a BOM'd config.json used to kill the node at boot.
+ */
+export function stripBom(text) {
+  return String(text).replace(/^\uFEFF/, '')
+}
+
+/** Read a JSON file, tolerating a BOM. */
+export function readJsonFile(path) {
+  return JSON.parse(stripBom(readFileSync(path, 'utf8')))
+}
+
+/** Wrap a promise with a hard timeout so a stuck tool cannot hang a request forever. */
+export function withTimeout(promise, ms, onTimeout) {
+  let timer
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(onTimeout || new Error(`timed out after ${ms}ms`)), ms)
+    timer.unref?.()
+  })
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer))
+}

package/src/e2e-autostart.js

@@ -0,0 +1,58 @@
+// e2e: autostart helper (Windows only). Read-only: never registers/removes a task.
+// Proves (a) status is safe on a clean machine, (b) both mutating paths refuse without --yes,
+// (c) the generated logon command points at this checkout's cli.js.
+import assert from 'node:assert/strict'
+import {
+  TASK_NAME,
+  autostartCommand,
+  autostartInstall,
+  autostartRemove,
+  autostartStatus
+} from './core/autostart.js'
+
+const checks = []
+function check(name, fn) {
+  checks.push({ name, fn })
+}
+
+check('Windows guard / status shape', async () => {
+  if (process.platform !== 'win32') return 'skipped: not win32'
+  const st = await autostartStatus()
+  assert.equal(typeof st.installed, 'boolean')
+  assert.equal(st.name, TASK_NAME)
+  if (st.installed) {
+    assert.ok(st.taskToRun, 'installed task must report taskToRun')
+  } else {
+    assert.ok(typeof st.detail === 'string')
+  }
+  return `installed=${st.installed}`
+})
+
+check('command quotes node + cli.js + port', () => {
+  const cmd = autostartCommand(TASK_NAME, 8124)
+  assert.match(cmd, /^".*node(\.exe)?"/)
+  assert.ok(cmd.includes('cli.js'), 'command must point at the CLI')
+  assert.match(cmd, /serve --port 8124$/)
+  return cmd
+})
+
+check('install refuses without --yes', async () => {
+  await assert.rejects(() => autostartInstall({ yes: false }), /--yes/)
+})
+
+check('remove refuses without --yes', async () => {
+  await assert.rejects(() => autostartRemove({ yes: false }), /--yes/)
+})
+
+let failed = 0
+for (const c of checks) {
+  try {
+    const detail = await c.fn()
+    console.log(`PASS  ${c.name}${detail ? `  (${detail})` : ''}`)
+  } catch (err) {
+    failed += 1
+    console.error(`FAIL  ${c.name}\n      ${err.message}`)
+  }
+}
+console.log(`\n${checks.length - failed}/${checks.length} passed`)
+process.exit(failed === 0 ? 0 : 1)