@casatwy/deyo 0.2.1 → 0.2.3

package/README.md

@@ -2,7 +2,7 @@
 
 `deyo` 是 [https://deyo.miaobi.fun](https://deyo.miaobi.fun) 的命令行工具。你可以直接在终端里提交音视频链接或本地音视频文件进行转写，并把结果输出到终端或保存到本地文件。
 
-CLI `0.2.1` 在保留可选稳定正文事件的同时，改为在省略 `--language` 时请求服务端自动检测转写语言；只有用户明确指定语言时，CLI 才会把 `language` 字段发送给链接或本地文件任务。默认不会把正文写入进度日志；只有显式使用 `--stream-transcript --progress-format jsonl`，且最终格式为 `text` 时，才会在 stderr JSONL 中输出稳定的 Whisper 正文增量。stdout 或 `-O` 始终只接收最终 Whisper 原稿，CLI 本身不做 AI 整理。
+CLI `0.2.2` 保留省略 `--language` 时的自动检测和可选稳定正文事件，并新增由 npm CLI 管理的 OpenClaw 更新登记、离线状态与显式确认流程。默认不会把正文写入进度日志；只有显式使用 `--stream-transcript --progress-format jsonl`，且最终格式为 `text` 时，才会在 stderr JSONL 中输出稳定的 Whisper 正文增量。stdout 或 `-O` 始终只接收最终 Whisper 原稿，CLI 本身不做 AI 整理。
 
 当前支持 8 类链接来源 + 本地音视频上传。链接来源包括小宇宙单集、喜马拉雅单集（含 `xima.tv` 短链）、B 站单视频、抖音单视频、小红书单视频笔记、YouTube 单视频、Apple Podcasts 单集和 Twitter/X 单条推文。其中 YouTube 如果命中可直接使用的字幕，会直接输出字幕或文本结果，不进入完整转写、不扣分钟；喜马拉雅合集链接会返回 422 并提示选择单集，不会扣分钟或创建转写任务；抖音图文内容、小红书图文笔记、Twitter/X 文本或图片推文会返回不支持转写的提示。B 站支持普通 BV 链接、`b23.tv` 短链、带 `bvid` 的 `player.bilibili.com/player.html` 嵌入播放器链接，以及可由 Whisper 解出 BV 页面的 `bilibili://video/...` App 分享视频链接；CLI 会识别并透传 App 链接，不在本地解码或推导 BV。
 
@@ -28,7 +28,7 @@ deyo --help
 
 ## 安装 Deyo Skill
 
-Deyo CLI 和 Deyo Skill 是两个独立产物：CLI 负责登录、上传、转写、结构化进度和 Whisper 原稿；Skill 负责让 Codex、Claude、Gemini 或 OpenClaw 正确调用 CLI，并在普通 text 场景按约束整理正文。它们独立安装、独立版本、独立更新，版本号不要求相同。下一版 Skill 要求 CLI 至少为 `0.2.1`。
+Deyo CLI 和 Deyo Skill 是两个独立产物：CLI 负责登录、上传、转写、结构化进度和 Whisper 原稿；Skill 负责让 Codex、Claude、Gemini 或 OpenClaw 正确调用 CLI，并在普通 text 场景按约束整理正文。它们独立安装、独立版本、独立更新，版本号不要求相同。Skill `1.0.11` 要求 CLI 至少为 `0.2.2`。
 
 先确认 CLI 版本，再交给 Deyo CLI 调用各平台的原生管理器安装 Skill：
 
@@ -47,7 +47,7 @@ deyo skill install --platform openclaw
 - Codex：添加 `casatwy/deyo-skill` Git marketplace 并安装 `deyo@deyo-official`；新会话生效，后续由宿主刷新 marketplace。
 - Claude：合并同名官方 marketplace 配置、设置 `autoUpdate: true`，再安装 `deyo@deyo-official`；运行 `/reload-plugins` 或开始新会话后生效。
 - Gemini：从 Deyo 官方 Git 仓库安装 extension 并启用 `--auto-update`；不会添加固定 `--ref` 或跳过来源确认的 `--consent`，更新后重启 Gemini CLI。
-- OpenClaw：使用 owner-qualified 的 `@casatwy/deyo`；默认只处理 global scope，workspace 安装时只处理当前 workspace。已有官方安装只会执行同一 scope 的单项 update，不使用 `--all` 或 `--force`。
+- OpenClaw：使用 owner-qualified 的 `@casatwy/deyo`；fresh install 成功后严格回读官方 managed origin 并登记调用时检查，已有官方 managed 安装只登记、不在安装命令中更新。直接运行 OpenClaw 原生命令安装的副本不会被自动登记。
 
 离线查看本地安装状态：
 
@@ -59,6 +59,15 @@ deyo skill status --platform claude --json
 
 `status` 只读取本地设置、安装 metadata 和 manifest；它不会启动平台 CLI、访问网络或触发更新。
 
+OpenClaw 的调用时检查默认每 24 小时至多验证一次 owner-qualified `latest` 候选，只接受稳定版本、`resolvedFrom: tag`、`tag: latest` 和 security `pass/clean`，不会直接安装。发现候选后，Skill 会先展示候选、来源和安全结果并询问 `是否现在更新Deyo到latest`。只有本轮得到明确同意后，才执行：
+
+```bash
+deyo skill update --platform openclaw --scope global \
+  --confirm-latest 'update @casatwy/deyo to latest now'
+```
+
+workspace 登记必须把 scope 改为 `workspace`。更新前 CLI 会重新验证 `latest`；候选变化时旧确认立即失效并要求重新确认。成功、origin 变化或结果不确定时要求重新调用 `/deyo`，已知失败且 origin 未变化时继续使用旧版。所有原生管理器输出都与转写 stdout、JSONL、raw 和 cleaned 文件隔离；流程不会使用 `--all`、`--force`、`--force-install` 或风险确认绕过，也不会创建 Cron。设置 `DEYO_OPENCLAW_AUTO_UPDATE=0` 可退出调用时检查。
+
 如果检测到旧版手工复制的 `deyo` Skill 目录，安装会停止并显示完整目录树 SHA-256。只有目录路径、文件、内容、类型、模式和 symlink 都与已知官方历史版本完全一致时，才允许把该摘要原样传回：
 
 ```bash

package/deyo.mjs

@@ -82,7 +82,7 @@ function printUsage() {
   deyo [选项] <url|file>
   deyo [选项] --file <file>
   deyo auth <login|logout|status> [选项]
-  deyo skill <install|status> [选项]
+  deyo skill <install|status|update> [选项]
 
 转写选项:
   --api-key <key>       可选，Deyo API key
@@ -106,6 +106,8 @@ auth 子命令:
 Skill 管理:
   deyo skill install --platform codex|claude|gemini|openclaw [--scope user|workspace|global]
   deyo skill status [--platform codex|claude|gemini|openclaw] [--json]
+  deyo skill update --platform openclaw [--scope workspace|global]
+                    --confirm-latest 'update @casatwy/deyo to latest now'
 
 API key 读取优先级:
   1. --api-key
@@ -2528,7 +2530,8 @@ async function main() {
   }
 
   if (primaryCommand === 'skill') {
-    await handleSkillCommand(argv, CLI_VERSION)
+    const exitCode = await handleSkillCommand(argv, CLI_VERSION)
+    if (Number.isSafeInteger(exitCode)) process.exitCode = exitCode
     return
   }
 

package/openclaw-skill-update.mjs

@@ -0,0 +1,794 @@
+import { constants as fsConstants } from 'node:fs'
+import { createHash, randomBytes } from 'node:crypto'
+import { spawn } from 'node:child_process'
+import {
+  chmod,
+  lstat,
+  mkdir,
+  open,
+  readFile,
+  rename,
+  rm,
+} from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+const DAY_MS = 24 * 60 * 60 * 1000
+const TIMEOUT_MS = 20_000
+const OWNER = 'casatwy'
+const SLUG = 'deyo'
+const REGISTRY = 'https://clawhub.ai'
+const OWNER_QUALIFIED_SKILL = `@${OWNER}/${SLUG}`
+export const CONFIRM_LATEST_PHRASE = `update ${OWNER_QUALIFIED_SKILL} to latest now`
+const UPDATED_EXIT_CODE = 10
+const CONFIRMATION_EXIT_CODE = 11
+const STABLE_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/
+const PRIVATE_DIRECTORY_MODE = 0o700
+const PRIVATE_FILE_MODE = 0o600
+
+function normalizeOwner(value) {
+  return typeof value === 'string' ? value.trim().replace(/^@/, '').toLowerCase() : ''
+}
+
+function normalizeSlug(value) {
+  if (typeof value !== 'string') return ''
+  return value.trim().replace(/^@casatwy\//i, '').toLowerCase()
+}
+
+function compareSemver(left, right) {
+  if (!STABLE_SEMVER.test(left) || !STABLE_SEMVER.test(right)) return null
+  const a = left.split('.').map(Number)
+  const b = right.split('.').map(Number)
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) return a[index] - b[index]
+  }
+  return 0
+}
+
+function absoluteConfiguredPath(name, value, fallback) {
+  const selected = String(value || fallback || '').trim()
+  if (!selected || !path.isAbsolute(selected)) {
+    throw new Error(`${name} must be an absolute path`)
+  }
+  return path.normalize(selected)
+}
+
+function homeDirectory(environment) {
+  return absoluteConfiguredPath(
+    'HOME',
+    environment.HOME || environment.USERPROFILE,
+    os.homedir(),
+  )
+}
+
+function openClawStateDirectory(environment) {
+  const home = homeDirectory(environment)
+  if (environment.OPENCLAW_STATE_DIR) {
+    return absoluteConfiguredPath('OPENCLAW_STATE_DIR', environment.OPENCLAW_STATE_DIR)
+  }
+  const openClawHome = absoluteConfiguredPath('OPENCLAW_HOME', environment.OPENCLAW_HOME, home)
+  return path.join(openClawHome, '.openclaw')
+}
+
+function configRoot(environment) {
+  return absoluteConfiguredPath(
+    'XDG_CONFIG_HOME',
+    environment.XDG_CONFIG_HOME,
+    path.join(homeDirectory(environment), '.config'),
+  )
+}
+
+function stateRoot(environment) {
+  return absoluteConfiguredPath(
+    'XDG_STATE_HOME',
+    environment.XDG_STATE_HOME,
+    path.join(homeDirectory(environment), '.local', 'state'),
+  )
+}
+
+export function resolveManagedOriginPath({ scope, cwd = process.cwd(), env = process.env }) {
+  if (scope === 'workspace') {
+    return path.resolve(cwd, 'skills', SLUG, '.clawhub', 'origin.json')
+  }
+  if (scope !== 'global') throw new Error('OpenClaw scope must be global or workspace')
+  return path.join(openClawStateDirectory(env), 'skills', SLUG, '.clawhub', 'origin.json')
+}
+
+function installIdentity(scope, originPath) {
+  return createHash('sha256')
+    .update(`${scope}\0${path.normalize(originPath)}`, 'utf8')
+    .digest('hex')
+}
+
+export function resolveOpenClawUpdatePaths({ scope, cwd = process.cwd(), env = process.env }) {
+  const originPath = resolveManagedOriginPath({ scope, cwd, env })
+  const identity = installIdentity(scope, originPath)
+  const enrollmentDirectory = path.join(configRoot(env), 'deyo', 'openclaw-skill-update')
+  const runtimeDirectory = path.join(stateRoot(env), 'deyo', 'openclaw-skill-update')
+  return {
+    identity,
+    originPath,
+    enrollmentDirectory,
+    enrollmentPath: path.join(enrollmentDirectory, `${identity}.json`),
+    runtimeDirectory,
+    runtimePath: path.join(runtimeDirectory, `${identity}.json`),
+    lockPath: path.join(runtimeDirectory, `${identity}.lock`),
+  }
+}
+
+async function pathLstat(target) {
+  try {
+    return await lstat(target)
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+async function inspectPrivateJson(target) {
+  const directory = path.dirname(target)
+  const ownedRoot = path.dirname(directory)
+  const [directoryStats, ownedRootStats] = await Promise.all([
+    pathLstat(directory),
+    pathLstat(ownedRoot),
+  ])
+  if (!directoryStats) return { exists: false, safe: true, value: null }
+  if (
+    path.basename(ownedRoot) !== 'deyo'
+    || !ownedRootStats
+    || ownedRootStats.isSymbolicLink()
+    || !ownedRootStats.isDirectory()
+    || (ownedRootStats.mode & 0o077) !== 0
+    ||
+    directoryStats.isSymbolicLink()
+    || !directoryStats.isDirectory()
+    || (directoryStats.mode & 0o077) !== 0
+  ) {
+    return { exists: false, safe: false, value: null }
+  }
+  const stats = await pathLstat(target)
+  if (!stats) return { exists: false, safe: true, value: null }
+  if (stats.isSymbolicLink() || !stats.isFile() || (stats.mode & 0o077) !== 0) {
+    return { exists: true, safe: false, value: null }
+  }
+  try {
+    return { exists: true, safe: true, value: JSON.parse(await readFile(target, 'utf8')) }
+  } catch {
+    return { exists: true, safe: false, value: null }
+  }
+}
+
+async function ensurePrivateDirectory(target) {
+  const ownedParent = path.dirname(target)
+  const parentStats = await pathLstat(ownedParent)
+  if (
+    path.basename(ownedParent) === 'deyo'
+    && (parentStats?.isSymbolicLink() || (parentStats && !parentStats.isDirectory()))
+  ) {
+    throw new Error(`Unsafe private directory: ${ownedParent}`)
+  }
+  const existing = await pathLstat(target)
+  if (existing?.isSymbolicLink() || (existing && !existing.isDirectory())) {
+    throw new Error(`Unsafe private directory: ${target}`)
+  }
+  await mkdir(target, { recursive: true, mode: PRIVATE_DIRECTORY_MODE })
+  const createdParent = await lstat(ownedParent)
+  if (
+    path.basename(ownedParent) === 'deyo'
+    && (createdParent.isSymbolicLink() || !createdParent.isDirectory())
+  ) {
+    throw new Error(`Unsafe private directory: ${ownedParent}`)
+  }
+  if (path.basename(ownedParent) === 'deyo') await chmod(ownedParent, PRIVATE_DIRECTORY_MODE)
+  const created = await lstat(target)
+  if (created.isSymbolicLink() || !created.isDirectory()) {
+    throw new Error(`Unsafe private directory: ${target}`)
+  }
+  await chmod(target, PRIVATE_DIRECTORY_MODE)
+}
+
+async function syncDirectory(target) {
+  let handle
+  try {
+    handle = await open(target, 'r')
+    await handle.sync()
+  } catch {
+    // Directory fsync is not available on every supported platform.
+  } finally {
+    await handle?.close().catch(() => {})
+  }
+}
+
+async function writePrivateJson(target, value) {
+  const parent = path.dirname(target)
+  await ensurePrivateDirectory(parent)
+  const existing = await pathLstat(target)
+  if (existing?.isSymbolicLink() || (existing && !existing.isFile())) {
+    throw new Error(`Unsafe private state file: ${target}`)
+  }
+  const temporary = path.join(
+    parent,
+    `.${path.basename(target)}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`,
+  )
+  const handle = await open(temporary, 'wx', PRIVATE_FILE_MODE)
+  let temporaryExists = true
+  try {
+    try {
+      await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, 'utf8')
+      await handle.sync()
+    } finally {
+      await handle.close()
+    }
+    await chmod(temporary, PRIVATE_FILE_MODE)
+    const rechecked = await pathLstat(target)
+    if (rechecked?.isSymbolicLink() || (rechecked && !rechecked.isFile())) {
+      throw new Error(`Unsafe private state file: ${target}`)
+    }
+    await rename(temporary, target)
+    temporaryExists = false
+    await chmod(target, PRIVATE_FILE_MODE)
+    await syncDirectory(parent)
+  } finally {
+    if (temporaryExists) await rm(temporary, { force: true })
+  }
+}
+
+async function acquireLock(lockPath) {
+  await ensurePrivateDirectory(path.dirname(lockPath))
+  try {
+    const handle = await open(
+      lockPath,
+      fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY,
+      PRIVATE_FILE_MODE,
+    )
+    await handle.writeFile(`${process.pid}\n`)
+    await handle.sync()
+    await chmod(lockPath, PRIVATE_FILE_MODE)
+    return handle
+  } catch (error) {
+    if (error?.code === 'EEXIST') return null
+    throw error
+  }
+}
+
+function validOrigin(raw, originPath) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null
+  const registry = typeof raw.registry === 'string' ? raw.registry.replace(/\/+$/, '') : ''
+  const ownerHandle = normalizeOwner(raw.ownerHandle)
+  const slug = normalizeSlug(raw.slug)
+  const version = raw.installedVersion
+  const fingerprint = raw.fingerprint
+  if (
+    raw.version !== 1
+    || registry !== REGISTRY
+    || ownerHandle !== OWNER
+    || slug !== SLUG
+    || typeof version !== 'string'
+    || !STABLE_SEMVER.test(version)
+    || !Number.isFinite(raw.installedAt)
+    || !/^[a-f0-9]{64}$/.test(fingerprint || '')
+  ) return null
+  return { originPath, registry, ownerHandle, slug, version, fingerprint }
+}
+
+export async function readManagedOrigin(originPath) {
+  try {
+    const skillDirectory = path.dirname(path.dirname(originPath))
+    const metadataDirectory = path.dirname(originPath)
+    const [skillStats, metadataStats, originStats] = await Promise.all([
+      lstat(skillDirectory),
+      lstat(metadataDirectory),
+      lstat(originPath),
+    ])
+    if (
+      skillStats.isSymbolicLink()
+      || !skillStats.isDirectory()
+      || metadataStats.isSymbolicLink()
+      || !metadataStats.isDirectory()
+      || originStats.isSymbolicLink()
+      || !originStats.isFile()
+    ) return { ok: false, reason: 'unsafe_origin', path: originPath }
+    const origin = validOrigin(JSON.parse(await readFile(originPath, 'utf8')), originPath)
+    return origin
+      ? { ok: true, ...origin }
+      : { ok: false, reason: 'invalid_origin', path: originPath }
+  } catch (error) {
+    return {
+      ok: false,
+      reason: error?.code === 'ENOENT' ? 'missing_origin' : 'unreadable_origin',
+      path: originPath,
+    }
+  }
+}
+
+function validEnrollment(value, { scope, identity, originPath }) {
+  return Boolean(
+    value
+    && value.schema === 1
+    && value.enabled === true
+    && value.scope === scope
+    && value.identity === identity
+    && value.originPath === originPath
+    && value.registry === REGISTRY
+    && normalizeOwner(value.ownerHandle) === OWNER
+    && normalizeSlug(value.slug) === SLUG
+    && typeof value.enrolledAt === 'string'
+    && typeof value.enrolledByCliVersion === 'string'
+  )
+}
+
+function validRuntime(value, identity) {
+  return Boolean(
+    value
+    && value.schema === 3
+    && value.identity === identity
+    && Number.isSafeInteger(value.attempt)
+    && value.attempt >= 0
+    && (value.lastAttemptAt === null || typeof value.lastAttemptAt === 'string')
+    && typeof value.status === 'string'
+  )
+}
+
+export function isDue(state, now = Date.now()) {
+  const lastAttempt = Date.parse(state?.lastAttemptAt ?? '')
+  return !Number.isFinite(lastAttempt) || now - lastAttempt >= DAY_MS
+}
+
+export function isAutoUpdateDisabled(environment = process.env) {
+  return environment.DEYO_OPENCLAW_AUTO_UPDATE === '0'
+}
+
+export function isVerificationClean(envelope, expectedInstalledVersion, selector = 'tag') {
+  const candidateVersion = envelope?.version
+  const installedVersion = envelope?.openclaw?.resolution?.installedVersion
+  const selectorMatches = selector === 'tag'
+    ? envelope?.resolvedFrom === 'tag' && envelope?.tag === 'latest'
+    : false
+  return envelope?.schema === 'clawhub.skill.verify.v1'
+    && normalizeOwner(envelope?.publisherHandle) === OWNER
+    && normalizeSlug(envelope?.slug) === SLUG
+    && typeof candidateVersion === 'string'
+    && STABLE_SEMVER.test(candidateVersion)
+    && selectorMatches
+    && envelope?.openclaw?.resolution?.source === 'installed'
+    && envelope?.openclaw?.resolution?.selector === selector
+    && installedVersion === expectedInstalledVersion
+    && compareSemver(candidateVersion, expectedInstalledVersion) >= 0
+    && envelope?.ok === true
+    && envelope?.decision === 'pass'
+    && envelope?.security?.passed === true
+    && envelope?.security?.status === 'clean'
+}
+
+export async function runWithDeadline(command, args, options = {}) {
+  const remainingMs = options.deadline - Date.now()
+  if (remainingMs <= 0) throw new Error('OpenClaw operation timed out')
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    const stdout = []
+    const stderr = []
+    let timedOut = false
+    const timer = setTimeout(() => {
+      timedOut = true
+      child.kill('SIGKILL')
+    }, remainingMs)
+    child.stdout.on('data', chunk => stdout.push(Buffer.from(chunk)))
+    child.stderr.on('data', chunk => stderr.push(Buffer.from(chunk)))
+    child.on('error', (error) => {
+      clearTimeout(timer)
+      reject(error)
+    })
+    child.on('close', (code, signal) => {
+      clearTimeout(timer)
+      if (timedOut) {
+        reject(new Error('OpenClaw operation timed out'))
+        return
+      }
+      resolve({
+        code: code ?? 1,
+        signal: signal || null,
+        stdout: Buffer.concat(stdout).toString('utf8'),
+        stderr: Buffer.concat(stderr).toString('utf8'),
+      })
+    })
+  })
+}
+
+function baseRuntime(identity, attempt, attemptedAt, origin, status) {
+  return {
+    schema: 3,
+    identity,
+    lastAttemptAt: attemptedAt,
+    attempt,
+    status,
+    fromVersion: origin?.version ?? null,
+    fromFingerprint: origin?.fingerprint ?? null,
+    candidateVersion: null,
+    candidateVerifiedAt: null,
+    verificationDecision: null,
+    securityStatus: null,
+  }
+}
+
+function pendingRuntime(base, candidateVersion, verifiedAt) {
+  return {
+    ...base,
+    status: 'pending_confirmation',
+    candidateVersion,
+    candidateVerifiedAt: verifiedAt,
+    verificationDecision: 'pass',
+    securityStatus: 'clean',
+  }
+}
+
+async function readEnrollmentAndRuntime(paths, scope) {
+  const [enrollmentMetadata, runtimeMetadata] = await Promise.all([
+    inspectPrivateJson(paths.enrollmentPath),
+    inspectPrivateJson(paths.runtimePath),
+  ])
+  const enrollmentState = !enrollmentMetadata.exists
+    ? 'not_enrolled'
+    : enrollmentMetadata.safe && validEnrollment(enrollmentMetadata.value, {
+      scope,
+      identity: paths.identity,
+      originPath: paths.originPath,
+    })
+      ? 'enrolled'
+      : 'invalid'
+  const runtimeState = !runtimeMetadata.exists
+    ? 'missing'
+    : runtimeMetadata.safe && validRuntime(runtimeMetadata.value, paths.identity)
+      ? 'valid'
+      : 'invalid'
+  return {
+    enrollmentState,
+    enrollment: enrollmentState === 'enrolled' ? enrollmentMetadata.value : null,
+    runtimeState,
+    runtime: runtimeState === 'valid' ? runtimeMetadata.value : null,
+  }
+}
+
+export async function enrollOpenClawAutoUpdate({
+  scope,
+  cliVersion,
+  cwd = process.cwd(),
+  env = process.env,
+  now = Date.now(),
+}) {
+  process.umask(0o077)
+  const paths = resolveOpenClawUpdatePaths({ scope, cwd, env })
+  const origin = await readManagedOrigin(paths.originPath)
+  if (!origin.ok) throw new Error(`Cannot enroll an unverified OpenClaw origin: ${origin.reason}`)
+  await writePrivateJson(paths.runtimePath, {
+    ...baseRuntime(paths.identity, 0, null, origin, 'enrolled'),
+  })
+  await writePrivateJson(paths.enrollmentPath, {
+    schema: 1,
+    enabled: true,
+    identity: paths.identity,
+    scope,
+    originPath: paths.originPath,
+    registry: REGISTRY,
+    ownerHandle: OWNER,
+    slug: SLUG,
+    enrolledAt: new Date(now).toISOString(),
+    enrolledByCliVersion: cliVersion,
+    enrolledVersion: origin.version,
+    enrolledFingerprint: origin.fingerprint,
+  })
+  return {
+    state: 'enrolled',
+    enrollmentPath: paths.enrollmentPath,
+    runtimePath: paths.runtimePath,
+    version: origin.version,
+  }
+}
+
+export async function inspectOpenClawAutoUpdate({
+  scope,
+  cwd = process.cwd(),
+  env = process.env,
+}) {
+  try {
+    const paths = resolveOpenClawUpdatePaths({ scope, cwd, env })
+    const local = await readEnrollmentAndRuntime(paths, scope)
+    return {
+      enrollment: local.enrollmentState,
+      runtime: local.runtimeState,
+      lastAttemptAt: local.runtime?.lastAttemptAt ?? null,
+      status: local.runtime?.status ?? null,
+      fromVersion: local.runtime?.fromVersion ?? null,
+      fromFingerprint: local.runtime?.fromFingerprint ?? null,
+      candidateVersion: local.runtime?.candidateVersion ?? null,
+      candidateVerifiedAt: local.runtime?.candidateVerifiedAt ?? null,
+      reloadRequiredAt: local.runtime?.reloadRequiredAt ?? null,
+    }
+  } catch {
+    return {
+      enrollment: 'invalid',
+      runtime: 'invalid',
+      lastAttemptAt: null,
+      status: null,
+      fromVersion: null,
+      fromFingerprint: null,
+      candidateVersion: null,
+      candidateVerifiedAt: null,
+      reloadRequiredAt: null,
+    }
+  }
+}
+
+async function verifyLatest({ before, scope, cwd, env, deadline, run }) {
+  const scopeArgs = scope === 'global' ? ['--global'] : []
+  const verification = await run('openclaw', [
+    'skills', 'verify', OWNER_QUALIFIED_SKILL, '--tag', 'latest', ...scopeArgs,
+  ], { deadline, cwd, env })
+  if (verification.code !== 0) return { ok: false }
+  let envelope
+  try {
+    envelope = JSON.parse(verification.stdout)
+  } catch {
+    return { ok: false }
+  }
+  if (!isVerificationClean(envelope, before.version)) return { ok: false }
+  return { ok: true, envelope, candidateVersion: envelope.version }
+}
+
+export async function runOpenClawInvocationCheck({
+  scope,
+  cwd = process.cwd(),
+  env = process.env,
+  now = Date.now(),
+  run = runWithDeadline,
+}) {
+  if (isAutoUpdateDisabled(env)) return { exitCode: 0, status: 'disabled' }
+  process.umask(0o077)
+  let paths
+  try {
+    paths = resolveOpenClawUpdatePaths({ scope, cwd, env })
+    const local = await readEnrollmentAndRuntime(paths, scope)
+    if (local.enrollmentState !== 'enrolled') {
+      return { exitCode: 0, status: local.enrollmentState }
+    }
+    if (local.runtimeState === 'invalid') return { exitCode: 0, status: 'invalid_runtime' }
+    if (!isDue(local.runtime, now)) return { exitCode: 0, status: 'not_due' }
+  } catch {
+    return { exitCode: 0, status: 'state_unavailable' }
+  }
+
+  let lock
+  try {
+    lock = await acquireLock(paths.lockPath)
+  } catch {
+    return { exitCode: 0, status: 'state_unavailable' }
+  }
+  if (!lock) return { exitCode: 0, status: 'busy' }
+  try {
+    const local = await readEnrollmentAndRuntime(paths, scope)
+    if (local.enrollmentState !== 'enrolled') return { exitCode: 0, status: 'not_enrolled' }
+    if (local.runtimeState === 'invalid') return { exitCode: 0, status: 'invalid_runtime' }
+    if (!isDue(local.runtime, now)) return { exitCode: 0, status: 'not_due' }
+
+    const before = await readManagedOrigin(paths.originPath)
+    if (!before.ok) return { exitCode: 0, status: 'origin_unavailable' }
+    const attemptedAt = new Date(now).toISOString()
+    const attempt = (local.runtime?.attempt ?? 0) + 1
+    const base = baseRuntime(paths.identity, attempt, attemptedAt, before, 'attempting')
+    try {
+      await writePrivateJson(paths.runtimePath, base)
+    } catch {
+      return { exitCode: 0, status: 'state_unavailable' }
+    }
+
+    let verified
+    try {
+      verified = await verifyLatest({
+        before,
+        scope,
+        cwd,
+        env,
+        deadline: now + TIMEOUT_MS,
+        run,
+      })
+    } catch {
+      await writePrivateJson(paths.runtimePath, { ...base, status: 'verification_failed' }).catch(() => {})
+      return { exitCode: 0, status: 'verification_failed' }
+    }
+    if (!verified.ok) {
+      await writePrivateJson(paths.runtimePath, { ...base, status: 'verification_failed' }).catch(() => {})
+      return { exitCode: 0, status: 'verification_failed' }
+    }
+
+    if (compareSemver(verified.candidateVersion, before.version) === 0) {
+      await writePrivateJson(paths.runtimePath, {
+        ...base,
+        status: 'up_to_date',
+        candidateVersion: verified.candidateVersion,
+        candidateVerifiedAt: new Date().toISOString(),
+        verificationDecision: 'pass',
+        securityStatus: 'clean',
+      }).catch(() => {})
+      return { exitCode: 0, status: 'up_to_date' }
+    }
+
+    const candidateVerifiedAt = new Date().toISOString()
+    try {
+      await writePrivateJson(
+        paths.runtimePath,
+        pendingRuntime(base, verified.candidateVersion, candidateVerifiedAt),
+      )
+    } catch {
+      return { exitCode: 0, status: 'state_unavailable' }
+    }
+    return {
+      exitCode: CONFIRMATION_EXIT_CODE,
+      status: 'pending_confirmation',
+      fromVersion: before.version,
+      candidateVersion: verified.candidateVersion,
+      message: `Deyo Skill update available: ${OWNER_QUALIFIED_SKILL} ${before.version} -> ${verified.candidateVersion}; source=ClawHub owner=${OWNER}; security=pass/clean. Ask the current user: 是否现在更新Deyo到latest？`,
+    }
+  } catch {
+    return { exitCode: 0, status: 'check_failed' }
+  } finally {
+    await lock.close().catch(() => {})
+    await rm(paths.lockPath, { force: true })
+  }
+}
+
+export async function runOpenClawConfirmedUpdate({
+  scope,
+  confirmation,
+  cwd = process.cwd(),
+  env = process.env,
+  now = Date.now(),
+  run = runWithDeadline,
+}) {
+  if (confirmation !== CONFIRM_LATEST_PHRASE) {
+    return { exitCode: 1, status: 'confirmation_required' }
+  }
+  if (isAutoUpdateDisabled(env)) return { exitCode: 0, status: 'disabled' }
+  process.umask(0o077)
+  let paths
+  try {
+    paths = resolveOpenClawUpdatePaths({ scope, cwd, env })
+  } catch {
+    return { exitCode: 0, status: 'state_unavailable' }
+  }
+  let lock
+  try {
+    lock = await acquireLock(paths.lockPath)
+  } catch {
+    return { exitCode: 0, status: 'state_unavailable' }
+  }
+  if (!lock) return { exitCode: 0, status: 'busy' }
+  try {
+    const local = await readEnrollmentAndRuntime(paths, scope)
+    if (local.enrollmentState !== 'enrolled') return { exitCode: 0, status: 'not_enrolled' }
+    if (
+      local.runtimeState !== 'valid'
+      || local.runtime?.status !== 'pending_confirmation'
+      || !STABLE_SEMVER.test(local.runtime?.candidateVersion || '')
+      || !STABLE_SEMVER.test(local.runtime?.fromVersion || '')
+      || !/^[a-f0-9]{64}$/.test(local.runtime?.fromFingerprint || '')
+    ) return { exitCode: 0, status: 'confirmation_missing' }
+
+    const before = await readManagedOrigin(paths.originPath)
+    if (
+      !before.ok
+      || before.version !== local.runtime.fromVersion
+      || before.fingerprint !== local.runtime.fromFingerprint
+    ) {
+      return {
+        exitCode: UPDATED_EXIT_CODE,
+        status: before.ok ? 'origin_changed' : 'origin_indeterminate',
+        message: 'Deyo Skill origin changed or became unreadable after confirmation; invoke /deyo again before transcription.',
+      }
+    }
+
+    const deadline = now + TIMEOUT_MS
+    let verified
+    try {
+      verified = await verifyLatest({ before, scope, cwd, env, deadline, run })
+    } catch {
+      return { exitCode: 0, status: 'verification_failed' }
+    }
+    if (!verified.ok) return { exitCode: 0, status: 'verification_failed' }
+    if (verified.candidateVersion !== local.runtime.candidateVersion) {
+      const refreshed = pendingRuntime(
+        baseRuntime(
+          paths.identity,
+          local.runtime.attempt + 1,
+          new Date(now).toISOString(),
+          before,
+          'pending_confirmation',
+        ),
+        verified.candidateVersion,
+        new Date().toISOString(),
+      )
+      try {
+        await writePrivateJson(paths.runtimePath, refreshed)
+      } catch {
+        return { exitCode: 0, status: 'state_unavailable' }
+      }
+      return {
+        exitCode: CONFIRMATION_EXIT_CODE,
+        status: 'confirmation_stale',
+        fromVersion: before.version,
+        candidateVersion: verified.candidateVersion,
+        message: `Deyo Skill latest candidate changed to ${verified.candidateVersion}; source=ClawHub owner=${OWNER}; security=pass/clean. Ask the current user again: 是否现在更新Deyo到latest？`,
+      }
+    }
+
+    const scopeArgs = scope === 'global' ? ['--global'] : []
+    let update
+    let indeterminate = false
+    try {
+      update = await run('openclaw', [
+        'skills', 'update', OWNER_QUALIFIED_SKILL, ...scopeArgs,
+      ], { deadline, cwd, env })
+    } catch {
+      indeterminate = true
+    }
+
+    const after = await readManagedOrigin(paths.originPath)
+    const changed = after.ok && (
+      after.version !== before.version || after.fingerprint !== before.fingerprint
+    )
+    const knownFailureUnchanged = !indeterminate && after.ok && !changed && update?.code !== 0
+    const reloadRequired = !knownFailureUnchanged
+    const status = indeterminate || !after.ok
+      ? 'update_indeterminate'
+      : changed
+        ? after.version === verified.candidateVersion ? 'updated' : 'updated_other_trusted'
+        : update?.code === 0 ? 'update_indeterminate' : 'update_failed'
+    const finalState = {
+      ...baseRuntime(
+        paths.identity,
+        local.runtime.attempt + 1,
+        new Date(now).toISOString(),
+        before,
+        status,
+      ),
+      status,
+      candidateVersion: verified.candidateVersion,
+      candidateVerifiedAt: new Date().toISOString(),
+      verificationDecision: 'pass',
+      securityStatus: 'clean',
+      toVersion: after.ok ? after.version : null,
+      toFingerprint: after.ok ? after.fingerprint : null,
+      ...(reloadRequired ? { reloadRequiredAt: new Date().toISOString() } : {}),
+    }
+    try {
+      await writePrivateJson(paths.runtimePath, finalState)
+    } catch {
+      if (!reloadRequired) return { exitCode: 0, status: 'state_unavailable' }
+    }
+    if (reloadRequired) {
+      return {
+        exitCode: UPDATED_EXIT_CODE,
+        status,
+        fromVersion: before.version,
+        toVersion: after.ok ? after.version : null,
+        message: 'Deyo Skill may have changed; invoke Deyo again to load or re-check the active version.',
+      }
+    }
+    return { exitCode: 0, status, fromVersion: before.version, toVersion: before.version }
+  } catch {
+    return { exitCode: 0, status: 'update_failed' }
+  } finally {
+    await lock.close().catch(() => {})
+    await rm(paths.lockPath, { force: true })
+  }
+}
+
+export const __test = {
+  CONFIRM_LATEST_PHRASE,
+  CONFIRMATION_EXIT_CODE,
+  OWNER_QUALIFIED_SKILL,
+  UPDATED_EXIT_CODE,
+  writePrivateJson,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@casatwy/deyo",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Deyo transcription CLI with link/file input, JSONL progress, and opt-in stable transcript streaming",
   "homepage": "https://deyo.miaobi.fun/docs",
   "license": "UNLICENSED",
@@ -8,6 +8,7 @@
   "files": [
     "deyo.mjs",
     "skill-manager.mjs",
+    "openclaw-skill-update.mjs",
     "README.md"
   ],
   "keywords": [
@@ -28,4 +29,4 @@
   "bin": {
     "deyo": "deyo.mjs"
   }
-}
+}

package/skill-manager.mjs

@@ -16,6 +16,13 @@ import { createHash, randomBytes } from 'node:crypto'
 import { homedir } from 'node:os'
 import { basename, dirname, isAbsolute, join, normalize, resolve } from 'node:path'
 import process from 'node:process'
+import {
+  CONFIRM_LATEST_PHRASE,
+  enrollOpenClawAutoUpdate,
+  inspectOpenClawAutoUpdate,
+  runOpenClawConfirmedUpdate,
+  runOpenClawInvocationCheck,
+} from './openclaw-skill-update.mjs'
 
 export const SKILL_PLATFORMS = ['codex', 'claude', 'gemini', 'openclaw']
 export const SKILL_SCOPES = ['user', 'workspace', 'global']
@@ -189,13 +196,17 @@ export function printSkillUsage(stream = process.stdout) {
                      [--replace-legacy sha256:<observed-hash>]
                      [--json]
   deyo skill status [--platform codex|claude|gemini|openclaw] [--json]
+  deyo skill update --platform openclaw [--scope workspace|global]
+                    --confirm-latest 'update @casatwy/deyo to latest now'
 
 默认 scope:
   codex=user，claude=user，gemini=user，openclaw=global
 
 说明:
   status 只读取本地配置和 manifest，不联网、不检查更新，也不修改 cache/lockfile。
-  install 只调用各平台原生管理器；不会用 --force、--all、固定 --ref 或 --consent。
+  install 只调用各平台原生管理器；OpenClaw 安装成功后登记调用时检查，不会自动更新已有安装。
+  update 仅用于当前用户明确同意后更新 OpenClaw；执行前会重新验证 latest，候选变化时必须重新确认。
+  所有原生命令都不会使用 --force、--all、--force-install、风险确认、固定 --ref 或 --consent。
   legacy 目录只有在完整树哈希属于官方历史版本，且 --replace-legacy 精确匹配时才会备份迁移。
 `)
 }
@@ -208,6 +219,7 @@ function parseSkillCommandArgs(argv) {
     platform: '',
     scope: '',
     replaceLegacy: '',
+    confirmLatest: '',
     json: false,
     help: requestedAction === '-h' || requestedAction === '--help',
   }
@@ -257,13 +269,19 @@ function parseSkillCommandArgs(argv) {
       index += 1
       continue
     }
+    if (current === '--confirm-latest') {
+      markSeen(current)
+      result.confirmLatest = readOptionValue(current, index)
+      index += 1
+      continue
+    }
     throw new SkillManagerError(`未知 skill 参数：${current}`, 'unknown_argument')
   }
 
   if (!action && !result.help) {
     throw new SkillManagerError('缺少 skill 子命令 install 或 status', 'missing_action')
   }
-  if (!['install', 'status'].includes(action) && !result.help) {
+  if (!['install', 'status', 'update', '_openclaw-check'].includes(action) && !result.help) {
     throw new SkillManagerError(`不支持的 skill 子命令：${action}`, 'invalid_action')
   }
   if (action === 'install' && !result.platform && !result.help) {
@@ -275,6 +293,38 @@ function parseSkillCommandArgs(argv) {
   if (action === 'status' && result.replaceLegacy) {
     throw new SkillManagerError('skill status 不接受 --replace-legacy', 'status_replace_legacy')
   }
+  if (action === 'status' && result.confirmLatest) {
+    throw new SkillManagerError('skill status 不接受 --confirm-latest', 'status_confirm_latest')
+  }
+  if (action === 'install' && result.confirmLatest) {
+    throw new SkillManagerError('skill install 不接受 --confirm-latest', 'install_confirm_latest')
+  }
+  if (action === 'update' && result.platform !== 'openclaw') {
+    throw new SkillManagerError('skill update 目前只支持 --platform openclaw', 'update_platform')
+  }
+  if (action === 'update' && result.replaceLegacy) {
+    throw new SkillManagerError('skill update 不接受 --replace-legacy', 'update_replace_legacy')
+  }
+  if (action === 'update' && result.json) {
+    throw new SkillManagerError('skill update 不接受 --json；更新输出不会写入 stdout', 'update_json')
+  }
+  if (action === 'update' && !result.confirmLatest) {
+    throw new SkillManagerError('skill update 必须提供 --confirm-latest', 'confirmation_required')
+  }
+  if (action === 'update' && result.confirmLatest !== CONFIRM_LATEST_PHRASE) {
+    throw new SkillManagerError(
+      `--confirm-latest 必须精确为 '${CONFIRM_LATEST_PHRASE}'`,
+      'confirmation_required',
+    )
+  }
+  if (action === '_openclaw-check') {
+    if (result.platform || result.replaceLegacy || result.confirmLatest || result.json) {
+      throw new SkillManagerError('内部 OpenClaw 检查只接受 --scope', 'internal_check_arguments')
+    }
+    if (!result.scope) {
+      throw new SkillManagerError('内部 OpenClaw 检查必须提供 --scope', 'missing_scope')
+    }
+  }
 
   return result
 }
@@ -1062,7 +1112,7 @@ async function inspectOpenClawSkill(scope) {
   }
 }
 
-async function buildOpenClawInstallPlan(scope, jsonMode) {
+async function buildOpenClawInstallPlan(scope, jsonMode, cliVersion) {
   const openclaw = await requireExecutable('openclaw')
   const skill = await inspectOpenClawSkill(scope)
   if (skill.managed && !skill.officialSource) {
@@ -1074,24 +1124,41 @@ async function buildOpenClawInstallPlan(scope, jsonMode) {
 
   return async () => {
     const scopeArgs = scope === 'global' ? ['--global'] : []
+    const actions = []
     if (skill.managed) {
+      actions.push('already_installed')
+    } else {
       await runManager(openclaw, [
-        'skills', 'update', OPENCLAW_SKILL, ...scopeArgs,
+        'skills', 'install', OPENCLAW_SKILL, ...scopeArgs,
       ], { interactive: true, jsonMode })
-      return { actions: ['skill_updated'], activation: 'invoke_again_if_updated' }
+      actions.push('skill_installed')
     }
-    await runManager(openclaw, [
-      'skills', 'install', OPENCLAW_SKILL, ...scopeArgs,
-    ], { interactive: true, jsonMode })
-    return { actions: ['skill_installed'], activation: 'next_invocation' }
+    const installed = await inspectOpenClawSkill(scope)
+    if (!installed.installed || !installed.officialSource) {
+      throw new SkillManagerError(
+        'OpenClaw 原生安装已返回，但无法从当前 scope 的 origin.json 确认 @casatwy/deyo',
+        'openclaw_origin_unverified',
+      )
+    }
+    let autoUpdate
+    try {
+      autoUpdate = await enrollOpenClawAutoUpdate({ scope, cliVersion })
+    } catch (error) {
+      throw new SkillManagerError(
+        `OpenClaw Skill 已处理，但调用时更新检查登记失败：${error instanceof Error ? error.message : String(error)}`,
+        'openclaw_enrollment_failed',
+      )
+    }
+    actions.push('invocation_update_check_enrolled')
+    return { actions, activation: 'next_invocation', autoUpdate }
   }
 }
 
-async function buildPlatformInstallPlan(platform, scope, jsonMode) {
+async function buildPlatformInstallPlan(platform, scope, jsonMode, cliVersion) {
   if (platform === 'codex') return await buildCodexInstallPlan(jsonMode)
   if (platform === 'claude') return await buildClaudeInstallPlan(scope, jsonMode)
   if (platform === 'gemini') return await buildGeminiInstallPlan(jsonMode)
-  return await buildOpenClawInstallPlan(scope, jsonMode)
+  return await buildOpenClawInstallPlan(scope, jsonMode, cliVersion)
 }
 
 function extractTomlSection(content, sectionName) {
@@ -1187,12 +1254,19 @@ async function inspectPlatformManaged(platform, scope) {
     }
   }
   const skill = await inspectOpenClawSkill(scope)
+  const update = await inspectOpenClawAutoUpdate({
+    scope,
+    ...(scope === 'workspace' ? { cwd: process.cwd() } : {}),
+  })
   return {
     installed: skill.installed,
     version: skill.version,
     source: skill.origin,
     officialSource: skill.officialSource,
-    autoUpdate: 'throttled_on_invocation',
+    autoUpdate: update.enrollment === 'enrolled'
+      ? 'confirmation_required_on_invocation'
+      : update.enrollment,
+    autoUpdateState: update,
     installPath: skill.path,
   }
 }
@@ -1216,7 +1290,7 @@ async function getSkillStatus(platform) {
   }
 }
 
-async function installSkill(options) {
+async function installSkill(options, cliVersion) {
   validatePlatform(options.platform)
   const scope = options.scope || getDefaultScope(options.platform)
   validateScope(options.platform, scope)
@@ -1224,7 +1298,7 @@ async function installSkill(options) {
 
   // All source-conflict and manager checks happen before the legacy directory
   // is moved or any provider configuration is mutated.
-  const execute = await buildPlatformInstallPlan(options.platform, scope, options.json)
+  const execute = await buildPlatformInstallPlan(options.platform, scope, options.json, cliVersion)
   const legacy = await inspectLegacy(options.platform, scope)
   let migration = null
   try {
@@ -1290,6 +1364,7 @@ function printStatusResult(result) {
 
 export async function handleSkillCommand(argv, cliVersion) {
   const wantsJson = argv.includes('--json')
+  const isolatesStdout = argv[1] === 'update' || argv[1] === '_openclaw-check'
   try {
     const args = parseSkillCommandArgs(argv)
     if (args.help) {
@@ -1299,13 +1374,32 @@ export async function handleSkillCommand(argv, cliVersion) {
     if (args.platform) validatePlatform(args.platform)
 
     if (args.action === 'install') {
-      const result = await installSkill(args)
+      const result = await installSkill(args, cliVersion)
       const output = { cliVersion, ...result }
       if (args.json) process.stdout.write(`${JSON.stringify(output)}\n`)
       else printInstallResult(output)
       return
     }
 
+    if (args.action === '_openclaw-check') {
+      const scope = args.scope
+      validateScope('openclaw', scope)
+      const result = await runOpenClawInvocationCheck({ scope })
+      if (result.message) process.stderr.write(`${result.message}\n`)
+      return result.exitCode
+    }
+
+    if (args.action === 'update') {
+      const scope = args.scope || getDefaultScope('openclaw')
+      validateScope('openclaw', scope)
+      const result = await runOpenClawConfirmedUpdate({
+        scope,
+        confirmation: args.confirmLatest,
+      })
+      if (result.message) process.stderr.write(`${result.message}\n`)
+      return result.exitCode
+    }
+
     const platforms = args.platform ? [args.platform] : SKILL_PLATFORMS
     const result = {
       command: 'skill.status',
@@ -1318,13 +1412,14 @@ export async function handleSkillCommand(argv, cliVersion) {
     }
     if (args.json) process.stdout.write(`${JSON.stringify(result)}\n`)
     else printStatusResult(result)
+    return 0
   } catch (error) {
     const payload = {
       command: 'skill.error',
       error: error?.code || 'skill_error',
       message: error instanceof Error ? error.message : String(error),
     }
-    if (wantsJson) process.stdout.write(`${JSON.stringify(payload)}\n`)
+    if (wantsJson && !isolatesStdout) process.stdout.write(`${JSON.stringify(payload)}\n`)
     else process.stderr.write(`Deyo Skill 操作失败：${payload.message}\n`)
     throw new SkillCommandReportedError(1)
   }