@clawos-dev/clawd 0.2.546 → 0.2.548

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.546",
+  "version": "0.2.548",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",

package/dist/deploy-kit/.secrets/aliyun.env.example

@@ -1,7 +0,0 @@
-# 阿里云 RAM AccessKey（publish.sh / remove-extension.sh 经 ensure-credentials.sh source）。
-# clawd 不随包 ship 任何一把 AK：把自己的 AK/SK 写进同目录的 aliyun.env.local（推荐，永不被 OTA 覆盖）
-# 或 aliyun.env；两个都不进 git（clawd/.gitignore 只放行 *.example）。云上不用文件，gateway 经 env 注入。
-# 需要权限（按 90 天 ActionTrail 反推）：FC（cn-hangzhou）+ SLS 的 serverless-cn-hangzhou-* project + 证书只读；
-# 没见到 OSS 调用（大代码包是否走 OSS 中转未验证，缺了 s deploy 会在 ActionTrail 里报 NoPermission）。
-ALIBABA_CLOUD_ACCESS_KEY_ID=replace-me
-ALIBABA_CLOUD_ACCESS_KEY_SECRET=replace-me

package/dist/deploy-kit/.secrets/aliyun.env.local.example

@@ -1,12 +0,0 @@
-# 阿里云 RAM AccessKey（本机专用）
-#
-# 复制这份为同目录下 aliyun.env.local，填自己的 AK/SK。publish.sh / remove-extension.sh 会依次
-# source aliyun.env（如果有）→ aliyun.env.local，后者的值覆盖前者。
-#
-# .local 后缀由 daemon refreshDeployKit 特判：**永远不会被 OTA 覆盖**。
-#
-# 2026-09-18 起 clawd 不再随包 ship 共享 demo AK（上一把随 npm 包发出去 69 秒就被 TruffleHog 收割，
-# 主账号被阿里云风控锁；见 specs/2026-09-18-aliyun-ak-leak-rotate-design.md）——本机发布必须配这份。
-# 老机器上 OTA 留下的 aliyun.env 里那把 AK 已泄露、不可再用，不用删，配了 .local 就会盖过它。
-ALIBABA_CLOUD_ACCESS_KEY_ID=replace-me
-ALIBABA_CLOUD_ACCESS_KEY_SECRET=replace-me

package/dist/deploy-kit/scripts/ensure-credentials.sh

@@ -1,111 +0,0 @@
-#!/usr/bin/env bash
-# ============================================================
-# 发布/清理动手前把阿里云凭证准备好（publish.sh / remove-extension.sh 共用）。
-# 被 `source` 进来，再调 ensure_credentials。跟 ensure-toolchain.sh 是一对：
-# 那个管「命令在不在」，这个管「命令拿什么身份跑」。
-#
-# 硬约束：**全程不碰用户全局 ~/.s**。clawd 发布用的是 deploy-kit 自己那份 AK（本机 .secrets/
-# 下使用者写的文件，云上是 gateway 注入的 env），而 ~/.s/access.yaml 里的 default 是用户自己账号的
-# Serverless Devs 凭证——它是用户的东西，不是我们的。做法对齐本 kit 处理 aliyun CLI 的方式（凭证只进本次进程的 env，
-# 全局 ~/.aliyun/ 一个字节不碰）：把 Serverless Devs 的配置家目录整个指到 deploy-kit
-# 名下，access.yaml 写在那里。
-# ============================================================
-
-# s 的 profile 名。刻意不叫 default：万一哪天某个版本的 s 不认 serverless_devs_config_home，
-# 隔离失效时它会退回去用户的 ~/.s/access.yaml 里找 clawd-fc —— 找不到就
-# `Not found access: clawd-fc` 硬报错，而不是默默拿用户的 default 凭证把 extension
-# 部署进别人的账号。调 s 时都显式带 `--access "$S_ACCESS_ALIAS"`：命令行参数覆盖 s.yaml
-# 里的 access 字段，本改动前 scaffold 的老项目（s.yaml 写着 default）照样走这条。
-S_ACCESS_ALIAS=clawd-fc
-
-# 分层加载阿里云 AK 进 env，三层平铺、后读的覆盖先读的：
-#   1. `$KIT_DIR/.secrets/aliyun.env`      —— 使用者自己写的（或 2026-09-18 之前 OTA 留下的旧文件）；
-#   2. `$KIT_DIR/.secrets/aliyun.env.local` —— 使用者自己写的，refreshDeployKit 永不覆盖；
-#   3. 进程 env 里已有的 `ALIBABA_CLOUD_ACCESS_KEY_ID/_SECRET` —— 云上容器那条路：Pod 里没有
-#      `.secrets/`（`cloud-host/provision/build-image.mjs` 刻意把它剔出镜像层——镜像要分发，凭据
-#      进层就洗不掉了），AK 由 gateway 经 **MCP server 的 per-server env** 交到调用本脚本的那个
-#      进程里（M1b Step 9）。不落盘是有意的：写成文件的话 agent 一个 `cat` 就看见了。
-#
-# clawd **不再随包 ship 任何一把 AK**（2026-09-18 起，见 specs/2026-09-18-aliyun-ak-leak-rotate-design.md：
-# 上一把随 npm 包发出去 69 秒就被 TruffleHog 收割，主账号被风控锁）。三层都空 = 使用者还没配，fail-loud。
-ensure_aliyun_env() {
-  local kit="${KIT_DIR:?ensure_aliyun_env 需要调用方先设 KIT_DIR}"
-  local f
-  # 写成 if 而不是 `[ -f ] && { }`：后者在函数末尾会把「文件不存在」变成函数返回 1，调用方 set -e 直接中止。
-  for f in "$kit/.secrets/aliyun.env" "$kit/.secrets/aliyun.env.local"; do
-    if [ -f "$f" ]; then
-      set -a; . "$f"; set +a
-    fi
-  done
-  if [ -z "${ALIBABA_CLOUD_ACCESS_KEY_ID:-}" ] || [ -z "${ALIBABA_CLOUD_ACCESS_KEY_SECRET:-}" ]; then
-    echo "❌ 没有阿里云 AK：把自己的 AK/SK 写进 $kit/.secrets/aliyun.env.local（参考同目录 aliyun.env.local.example；这个文件不会被 OTA 覆盖），云上则由 gateway 经 env 注入。" >&2
-    return 1
-  fi
-  export ALIBABA_CLOUD_REGION_ID="${REGION:?config.env 缺 REGION}"
-}
-
-# 调 aliyun CLI 的**唯一入口**：把凭证和 region 作为显式参数交出去，不依赖环境变量的隐式优先级。
-#
-# 为什么非这样不可（实测 aliyun 3.3.17，`--mode AK`）：`ALIBABA_CLOUD_ACCESS_KEY_ID` /
-# `_SECRET` / `_REGION_ID` 这三个环境变量在这个模式下**根本不被消费**，于是
-#   - 机器上没有 `~/.aliyun/config.json`（全新用户的常态，ensure_toolchain 只装 CLI、
-#     从不跑 `aliyun configure`）→ `ERROR: region can't be empty`，第一次发布就跑不起来；
-#   - 机器上有 profile（比如用户自己配过阿里云）→ **静默走用户自己的 profile**，等于拿
-#     用户的阿里云身份去部署 extension，跟 access.yaml 那个坑是同一类。
-# 补 `--region` 一个 flag 不够，AK 也必须是 flag——两者都试过。
-#
-# 用法跟 aliyun 一样，省掉 `--mode AK` 和三个凭证参数：aliyun_ak sts GetCallerIdentity
-aliyun_ak() {
-  aliyun --mode AK \
-    --access-key-id "${ALIBABA_CLOUD_ACCESS_KEY_ID:?aliyun_ak 需要先 ensure_aliyun_env}" \
-    --access-key-secret "${ALIBABA_CLOUD_ACCESS_KEY_SECRET:?aliyun_ak 需要先 ensure_aliyun_env}" \
-    --region "${ALIBABA_CLOUD_REGION_ID:?aliyun_ak 需要先 ensure_aliyun_env}" \
-    "$@"
-}
-
-# 把 Serverless Devs 的配置家目录（access.yaml / 组件缓存 / 日志）指到 deploy-kit 名下，
-# 再把当前 env 里的凭证写成 $S_ACCESS_ALIAS profile。
-# s v3 的 rootHome = `$serverless_devs_config_home/.s`（默认 `$HOME/.s`），`s -v` 打印的 s-home 就是它——
-# 注意差一层：env 指到 X，文件落 X/.s/，所以下面是 "$s_home/.s/access.yaml" 而不是 "$s_home/access.yaml"。
-# 前置：ensure_toolchain（aliyun 可执行）+ ensure_aliyun_env（AK 进 env）。
-# 放 $KIT_DIR 下而不是另起路径：跟它写的那份凭证同源，且 refreshDeployKit 只覆盖
-# scripts/ contract/ .secrets/，OTA 不会动这里的组件缓存。
-ensure_s_access() {
-  local kit="${KIT_DIR:?ensure_s_access 需要调用方先设 KIT_DIR}"
-  local s_home="$kit/.s-home"
-  local ident acc
-
-  ident="$(aliyun_ak sts GetCallerIdentity 2>&1)" || {
-    # 别只说「检查凭证」——凭证不对只是可能之一，region 缺失 / CLI 装坏 / 网络不通报的是别的话。
-    # 把 CLI 原文摆出来，让读的人按原文判断。
-    echo "❌ aliyun sts GetCallerIdentity 失败，拿不到 AccountId。aliyun 原文：" >&2
-    echo "$ident" >&2
-    echo "   排查顺序：① 上面这行 CLI 原文说的是什么 ② $kit/.secrets/aliyun.env.local（或 aliyun.env）里的 AK 是否有效——2026-09-18 之前 OTA 发的那把已泄露、不可再用，得换自己的 ③ config.env 的 REGION" >&2
-    return 1
-  }
-  # 用 node 不用 python3：目标机器保证有 node（clawd 本身就是 node 跑的），不保证有 python
-  # —— 清理路径尤其不该多一个装不上就跑不了的依赖。
-  acc="$(printf '%s' "$ident" | node -e 'console.log(JSON.parse(require("fs").readFileSync(0,"utf8")).AccountId)')" || {
-    echo "❌ 解析 AccountId 失败,aliyun 输出非 JSON:" >&2
-    echo "$ident" >&2
-    return 1
-  }
-
-  export serverless_devs_config_home="$s_home"
-  mkdir -p "$s_home/.s"
-  # umask 管「新建」：SK 从落盘第一个字节起就是 0600，不留「先 644 写完再 chmod」的窗口。
-  # 后面的 chmod 管「文件已存在」：umask 不改已有文件的 mode，重复发布时靠它兜底。
-  ( umask 077; cat > "$s_home/.s/access.yaml" <<EOF
-$S_ACCESS_ALIAS:
-  AccountID: '$acc'
-  AccessKeyID: $ALIBABA_CLOUD_ACCESS_KEY_ID
-  AccessKeySecret: $ALIBABA_CLOUD_ACCESS_KEY_SECRET
-EOF
-  )
-  chmod 600 "$s_home/.s/access.yaml"
-}
-
-ensure_credentials() {
-  ensure_aliyun_env
-  ensure_s_access
-}

package/dist/deploy-kit/scripts/ensure-credentials.spec.ts

@@ -1,438 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { execFileSync } from 'node:child_process'
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, statSync, cpSync, rmSync } from 'node:fs'
-import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-
-// ensure-credentials.sh 的契约测试。核心不变量：**发布/清理全程不碰用户全局 ~/.s**。
-// 老实现 `cat > ~/.s/access.yaml` 会把用户自己的 Serverless Devs default 凭证顶掉且不可恢复
-// （所有装了 clawd 的用户点一次「发布上线」就中招），这些用例就是钉死那个回归。
-//
-// 真脚本 + 真 bash 跑，只把两个外部 CLI（aliyun / s）换成记录 argv 的 shim：
-// 断言的是脚本自己的行为（写哪、写什么、传什么 flag），没有 mock 掉被测逻辑。
-
-const SCRIPTS_DIR = __dirname
-
-interface Sandbox {
-  root: string
-  kit: string
-  home: string
-  bin: string
-}
-
-let box: Sandbox
-
-/** 用户自己的 ~/.s/access.yaml —— 全程必须一个字节都不变。 */
-const USER_ACCESS_YAML = `default:
-  AccountID: '1999888877776666'
-  AccessKeyID: LTAI-USER-OWN-KEY
-  AccessKeySecret: user-own-secret
-`
-
-/**
- * aliyun CLI shim —— **照真 CLI 的凭证优先级建模**（实测 aliyun 3.3.17，`--mode AK`）：
- *
- * - `--access-key-id` / `--access-key-secret` / `--region` 三个 **flag 缺一不可**；
- * - `ALIBABA_CLOUD_*` 环境变量在这个模式下**根本不被消费**——没有 `~/.aliyun/config.json`
- *   的干净机器上只会得到 `region can't be empty`（rc=3），有 profile 的机器上则**静默走用户
- *   自己的 profile**（等于拿用户身份部署）。
- *
- * 所以 shim 只认 flag、不认 env：脚本要是退回去依赖 env 优先级，这里当场红。
- */
-function writeAliyunShim(bin: string, accountId = '5566778899001122', argvLog?: string): void {
-  writeFileSync(
-    join(bin, 'aliyun'),
-    `#!/usr/bin/env bash
-${argvLog ? `printf '%s\\n' "$*" >> "${argvLog}"` : ''}
-argv=" $* "
-for f in --access-key-id --access-key-secret --region; do
-  case "$argv" in
-    *" $f "*) ;;
-    *) echo "ERROR: region can't be empty" >&2; exit 3 ;;
-  esac
-done
-case "$argv" in
-  *" sts "*) printf '{"AccountId":"${accountId}","Arn":"acs:ram::${accountId}:user/clawd-fc-developer"}\\n' ;;
-  *) printf '{"customDomains":[]}\\n' ;;
-esac
-`,
-    { mode: 0o755 },
-  )
-}
-
-/** s shim：把每次调用的 argv 追加到 $S_ARGV_LOG，供断言 --access 传对了没。 */
-function writeSShim(bin: string, log: string): void {
-  writeFileSync(
-    join(bin, 's'),
-    `#!/usr/bin/env bash\nprintf '%s\\n' "$*" >> "${log}"\n`,
-    { mode: 0o755 },
-  )
-}
-
-beforeEach(() => {
-  const root = mkdtempSync(join(tmpdir(), 'ensure-creds-'))
-  const kit = join(root, 'deploy-kit')
-  const home = join(root, 'home')
-  const bin = join(root, 'bin')
-  mkdirSync(join(kit, '.secrets'), { recursive: true })
-  mkdirSync(join(home, '.s'), { recursive: true })
-  mkdirSync(bin, { recursive: true })
-
-  // 真脚本进沙箱 kit。.secrets 按生产形状：bundle 只带 *.example（2026-09-18 起 AK 不再随包
-  // 分发，见 specs/2026-09-18-aliyun-ak-leak-rotate-design.md），本机凭证是使用者自己写的 .local。
-  cpSync(SCRIPTS_DIR, join(kit, 'scripts'), { recursive: true })
-  writeFileSync(
-    join(kit, '.secrets', 'aliyun.env.local'),
-    'ALIBABA_CLOUD_ACCESS_KEY_ID=LTAI-MY-OWN\nALIBABA_CLOUD_ACCESS_KEY_SECRET=my-own-secret\n',
-  )
-  writeFileSync(join(home, '.s', 'access.yaml'), USER_ACCESS_YAML)
-  writeAliyunShim(bin)
-
-  box = { root, kit, home, bin }
-})
-
-afterEach(() => {
-  rmSync(box.root, { recursive: true, force: true })
-})
-
-/** 在沙箱里 source ensure-credentials.sh 并跑一段 bash，返回 stdout。 */
-function runInKit(body: string): string {
-  const script = `
-set -euo pipefail
-KIT_DIR="${box.kit}"
-REGION="\${REGION:-cn-hangzhou}"
-source "$KIT_DIR/scripts/ensure-credentials.sh"
-${body}
-`
-  return execFileSync('bash', ['-c', script], {
-    env: { ...process.env, HOME: box.home, PATH: `${box.bin}:${process.env.PATH}` },
-    encoding: 'utf8',
-  })
-}
-
-function userAccessYaml(): string {
-  return readFileSync(join(box.home, '.s', 'access.yaml'), 'utf8')
-}
-
-function kitAccessYaml(): string {
-  return readFileSync(join(box.kit, '.s-home', '.s', 'access.yaml'), 'utf8')
-}
-
-describe('ensure_credentials', () => {
-  it('不碰用户全局 ~/.s/access.yaml', () => {
-    runInKit('ensure_credentials')
-    expect(userAccessYaml()).toBe(USER_ACCESS_YAML)
-  })
-
-  it('凭证写进 kit 私有 s-home', () => {
-    runInKit('ensure_credentials')
-    const yaml = kitAccessYaml()
-    expect(yaml).toContain("AccountID: '5566778899001122'")
-    expect(yaml).toContain('AccessKeyID: LTAI-MY-OWN')
-    expect(yaml).toContain('AccessKeySecret: my-own-secret')
-  })
-
-  it('profile 名是 clawd-fc 而不是 default', () => {
-    // 隔离万一失效（某版本 s 不认 serverless_devs_config_home）时，s 会去用户
-    // ~/.s/access.yaml 找 clawd-fc —— 找不到就硬报错，而不是默默拿用户的 default
-    // 凭证把 extension 部署进别人的账号。
-    runInKit('ensure_credentials')
-    expect(kitAccessYaml()).toMatch(/^clawd-fc:$/m)
-    expect(kitAccessYaml()).not.toMatch(/^default:$/m)
-  })
-
-  it('把 Serverless Devs 的家目录指向 kit 私有目录', () => {
-    const out = runInKit('ensure_credentials; echo "S_HOME=$serverless_devs_config_home"')
-    expect(out).toContain(`S_HOME=${box.kit}/.s-home`)
-  })
-
-  it('access.yaml 权限 600（含 SK，不给同机其它用户读）', () => {
-    runInKit('ensure_credentials')
-    const mode = statSync(join(box.kit, '.s-home', '.s', 'access.yaml')).mode & 0o777
-    expect(mode.toString(8)).toBe('600')
-  })
-
-  // 存量机器：OTA 停发 aliyun.env 之后 refreshDeployKit 不再覆盖也不删它，旧文件会留在盘上。
-  // 有 .local 时 .local 必须盖过它（否则老用户配了自己的 AK 还在用那把已停用的）。
-  it('legacy aliyun.env 仍被读，但 .local 覆盖它', () => {
-    writeFileSync(
-      join(box.kit, '.secrets', 'aliyun.env'),
-      'ALIBABA_CLOUD_ACCESS_KEY_ID=LTAI-STALE-OTA\nALIBABA_CLOUD_ACCESS_KEY_SECRET=stale-ota-secret\n',
-    )
-    runInKit('ensure_credentials')
-    expect(kitAccessYaml()).toContain('AccessKeyID: LTAI-MY-OWN')
-    expect(kitAccessYaml()).not.toContain('LTAI-STALE-OTA')
-  })
-
-  it('只有 aliyun.env 没有 .local 也能用（使用者直接写 aliyun.env 的老习惯）', () => {
-    rmSync(join(box.kit, '.secrets', 'aliyun.env.local'))
-    writeFileSync(
-      join(box.kit, '.secrets', 'aliyun.env'),
-      'ALIBABA_CLOUD_ACCESS_KEY_ID=LTAI-PLAIN-FILE\nALIBABA_CLOUD_ACCESS_KEY_SECRET=plain-file-secret\n',
-    )
-    runInKit('ensure_credentials')
-    expect(kitAccessYaml()).toContain('AccessKeyID: LTAI-PLAIN-FILE')
-  })
-
-  it('调 aliyun 时显式传 AK 和 region，不靠环境变量的隐式优先级', () => {
-    // 真 CLI 在 `--mode AK` 下不消费 ALIBABA_CLOUD_*：干净机器上报 `region can't be empty`
-    // 直接跑不起来；有 ~/.aliyun/config.json 的机器上更坏——静默走用户自己的 profile，
-    // 等于拿用户的阿里云身份去部署。两种都必须由显式 flag 堵死。
-    const log = join(box.root, 'aliyun-argv.log')
-    writeAliyunShim(box.bin, '5566778899001122', log)
-    runInKit('ensure_credentials')
-    const argv = readFileSync(log, 'utf8')
-    expect(argv).toContain('--access-key-id LTAI-MY-OWN')
-    expect(argv).toContain('--access-key-secret my-own-secret')
-    expect(argv).toContain('--region cn-hangzhou')
-  })
-
-  it('机器上没有 aliyun profile 也能拿到 AccountId', () => {
-    // 全新用户机器：ensure_toolchain 只装 CLI、从不跑 `aliyun configure`，所以 HOME 下
-    // 没有 .aliyun/config.json。严格 shim 复现真 CLI 的这条路径。
-    rmSync(join(box.home, '.aliyun'), { recursive: true, force: true })
-    runInKit('ensure_credentials')
-    expect(kitAccessYaml()).toContain("AccountID: '5566778899001122'")
-  })
-
-  it('aliyun.env / .local 都没有、env 里也没有 AK 时 fail-loud，文案指到 .local', () => {
-    rmSync(join(box.kit, '.secrets', 'aliyun.env.local'))
-    expect(() => runInKit('ensure_credentials')).toThrow(/aliyun\.env\.local/)
-    expect(existsSync(join(box.kit, '.s-home', '.s', 'access.yaml'))).toBe(false)
-  })
-
-  // 云上分支（persona 上云 M1b Step 9）：容器里没有 `.secrets/`——`build-image.mjs` 刻意把它
-  // 剔出镜像层（镜像要分发，凭据进层洗不掉）。AK 由 gateway 经 **MCP server 的 per-server env**
-  // 交到调用本脚本的那个子进程里，不落文件：写成文件的话 agent 一个 `cat` 就看见了。
-  it('没有 .secrets/ 凭证文件但 env 里有 AK 时用 env（云上容器那条路）', () => {
-    rmSync(join(box.kit, '.secrets', 'aliyun.env.local'))
-    const out = execFileSync(
-      'bash',
-      [
-        '-c',
-        `set -euo pipefail
-KIT_DIR="${box.kit}"
-REGION=cn-hangzhou
-source "$KIT_DIR/scripts/ensure-credentials.sh"
-ensure_credentials
-printf 'ok %s\\n' "$ALIBABA_CLOUD_ACCESS_KEY_ID"`,
-      ],
-      {
-        env: {
-          ...process.env,
-          HOME: box.home,
-          PATH: `${box.bin}:${process.env.PATH}`,
-          ALIBABA_CLOUD_ACCESS_KEY_ID: 'LTAI-FROM-ENV',
-          ALIBABA_CLOUD_ACCESS_KEY_SECRET: 'secret-from-env',
-        },
-        encoding: 'utf8',
-      },
-    )
-    expect(out).toContain('ok LTAI-FROM-ENV')
-    // 走 env 分支照样把凭证落进 kit 私有 s-home（publish 用的是那份 profile），仍不碰用户全局
-    expect(kitAccessYaml()).toContain('LTAI-FROM-ENV')
-    expect(userAccessYaml()).toContain('LTAI-USER-OWN-KEY')
-  })
-
-  it('文件在就优先用文件（云上那条只是兜底，不能反过来盖掉本机 .local 凭证）', () => {
-    const out = execFileSync(
-      'bash',
-      [
-        '-c',
-        `set -euo pipefail
-KIT_DIR="${box.kit}"
-REGION=cn-hangzhou
-source "$KIT_DIR/scripts/ensure-credentials.sh"
-ensure_aliyun_env
-printf 'id=%s\\n' "$ALIBABA_CLOUD_ACCESS_KEY_ID"`,
-      ],
-      {
-        env: {
-          ...process.env,
-          HOME: box.home,
-          PATH: `${box.bin}:${process.env.PATH}`,
-          ALIBABA_CLOUD_ACCESS_KEY_ID: 'LTAI-FROM-ENV',
-          ALIBABA_CLOUD_ACCESS_KEY_SECRET: 'secret-from-env',
-        },
-        encoding: 'utf8',
-      },
-    )
-    expect(out).toContain('id=LTAI-MY-OWN')
-    expect(out).not.toContain('LTAI-FROM-ENV')
-  })
-})
-
-describe('publish.sh', () => {
-  /** 最小 persona kit + 项目目录；模板只留跟本文件断言相关的占位符。 */
-  function publishFixture(): { ext: string; persona: string } {
-    // 严格 shim 的自定义域名查询回空 → publish.sh 在 verify 段 exit 1。deploy 之后的事，
-    // 不影响本用例要断言的凭证 / 渲染行为，省掉 curl shim。
-    writeAliyunShim(box.bin, '5566778899001122', join(box.root, 'aliyun-argv.log'))
-    const ext = join(box.root, 'proj')
-    const persona = join(box.root, 'persona')
-    mkdirSync(join(ext, 'server'), { recursive: true })
-    mkdirSync(join(persona, 'extension-kit', 'contract'), { recursive: true })
-    mkdirSync(join(box.kit, 'contract'), { recursive: true })
-    writeFileSync(join(box.kit, 'contract', 'bootstrap'), '#!/usr/bin/env bash\n')
-    writeFileSync(join(ext, 'ext.conf'), 'APP_NAME=demo\nSLUG=ab12\nCODE_DIR=./server\n')
-    writeFileSync(join(persona, 'extension-kit', 'config.env'), 'REGION=cn-hangzhou\n')
-    writeFileSync(
-      join(persona, 'extension-kit', 'contract', 's.yaml.tmpl'),
-      'name: __DEPLOY_NAME__-app\naccess: clawd-fc\nenv: __APP_ENV__\nprefix: __TABLE_PREFIX__\n',
-    )
-    return { ext, persona }
-  }
-  function runPublish(ext: string, persona: string, env: string): void {
-    expect(() =>
-      execFileSync('bash', [join(box.kit, 'scripts', 'publish.sh'), ext, persona, env], {
-        env: { ...process.env, HOME: box.home, PATH: `${box.bin}:${process.env.PATH}` },
-        encoding: 'utf8',
-        stdio: 'pipe',
-      }),
-    ).toThrow() // verify 段无域名 → exit 1，deploy 已经跑过了
-  }
-
-  it('用 clawd-fc profile 调 s deploy，不碰用户全局 ~/.s', () => {
-    const log = join(box.root, 's-argv.log')
-    writeSShim(box.bin, log)
-    const { ext, persona } = publishFixture()
-    runPublish(ext, persona, 'integration')
-    expect(readFileSync(log, 'utf8')).toContain('deploy -y -t s.int.yaml --access clawd-fc')
-    expect(userAccessYaml()).toBe(USER_ACCESS_YAML)
-  })
-
-  // 双环境（spec 2026-09-15-app-builder-integration-env-design §3.2）：同一个项目两个 env 各渲各的
-  // s 文件、各自的 DEPLOY_NAME / TABLE_PREFIX，prod 那份跟双环境之前的值一字不差（老地址不动）。
-  it('integration → s.int.yaml（-int / _int_），prod → s.prod.yaml（老值），两份并存互不覆盖', () => {
-    const log = join(box.root, 's-argv.log')
-    writeSShim(box.bin, log)
-    const { ext, persona } = publishFixture()
-    runPublish(ext, persona, 'integration')
-    runPublish(ext, persona, 'prod')
-    expect(readFileSync(join(ext, 's.int.yaml'), 'utf8')).toBe('name: demo-ab12-int-app\naccess: clawd-fc\nenv: integration\nprefix: demo_ab12_int_\n')
-    expect(readFileSync(join(ext, 's.prod.yaml'), 'utf8')).toBe('name: demo-ab12-app\naccess: clawd-fc\nenv: prod\nprefix: demo_ab12_\n')
-    expect(existsSync(join(ext, 's.yaml'))).toBe(false)
-    const argv = readFileSync(log, 'utf8')
-    expect(argv).toContain('deploy -y -t s.int.yaml --access clawd-fc')
-    expect(argv).toContain('deploy -y -t s.prod.yaml --access clawd-fc')
-  })
-
-  // 存量项目的 .gitignore 是 scaffold 时拷的一次性文件，只有 `s.yaml`：s.int.yaml 渲下去会被当成源码推上 GitHub
-  //（里面有 supabase key）。publish.sh 像 bake SLUG 那样幂等地补一行，模板项目已有的不重复。
-  it('项目 .gitignore 没有 s.*.yaml 就补上（幂等）；没有 .gitignore 也建', () => {
-    writeSShim(box.bin, join(box.root, 's-argv.log'))
-    const { ext, persona } = publishFixture()
-    writeFileSync(join(ext, '.gitignore'), 'node_modules/\ns.yaml\n')
-    runPublish(ext, persona, 'integration')
-    expect(readFileSync(join(ext, '.gitignore'), 'utf8')).toBe('node_modules/\ns.yaml\ns.*.yaml\n')
-    runPublish(ext, persona, 'prod')
-    expect(readFileSync(join(ext, '.gitignore'), 'utf8')).toBe('node_modules/\ns.yaml\ns.*.yaml\n')
-    rmSync(join(ext, '.gitignore'))
-    runPublish(ext, persona, 'integration')
-    expect(readFileSync(join(ext, '.gitignore'), 'utf8')).toBe('s.*.yaml\n')
-  })
-
-  it('缺 env / 非法 env：渲染和 deploy 都不跑', () => {
-    const log = join(box.root, 's-argv.log')
-    writeSShim(box.bin, log)
-    const { ext, persona } = publishFixture()
-    for (const args of [[ext, persona], [ext, persona, 'staging']]) {
-      expect(() =>
-        execFileSync('bash', [join(box.kit, 'scripts', 'publish.sh'), ...args], {
-          env: { ...process.env, HOME: box.home, PATH: `${box.bin}:${process.env.PATH}` },
-          encoding: 'utf8',
-          stdio: 'pipe',
-        }),
-      ).toThrow(/integration\|prod/)
-    }
-    expect(existsSync(log)).toBe(false)
-    expect(existsSync(join(ext, 's.int.yaml'))).toBe(false)
-  })
-})
-
-describe('remove-extension.sh', () => {
-  function removeFixture(opts: { sFiles: string[]; tables?: string; names?: Record<string, string> }): { ext: string; persona: string } {
-    const ext = join(box.root, 'proj')
-    const persona = join(box.root, 'persona')
-    mkdirSync(ext, { recursive: true })
-    mkdirSync(join(persona, 'extension-kit'), { recursive: true })
-    writeFileSync(join(ext, 'ext.conf'), `APP_NAME=demo\nSLUG=ab12\n${opts.tables !== undefined ? `SUPABASE_TABLES="${opts.tables}"\n` : ''}`)
-    writeFileSync(join(persona, 'extension-kit', 'config.env'), 'REGION=cn-hangzhou\n')
-    for (const f of opts.sFiles) writeFileSync(join(ext, f), `name: ${opts.names?.[f] ?? 'x'}\n`)
-    return { ext, persona }
-  }
-  function runRemove(ext: string, persona: string): string {
-    return execFileSync('bash', [join(box.kit, 'scripts', 'remove-extension.sh'), ext, persona], {
-      env: { ...process.env, HOME: box.home, PATH: `${box.bin}:${process.env.PATH}` },
-      encoding: 'utf8',
-    })
-  }
-
-  it('用 clawd-fc profile 调 s remove，不碰用户全局 ~/.s', () => {
-    const log = join(box.root, 's-argv.log')
-    writeSShim(box.bin, log)
-    const { ext, persona } = removeFixture({ sFiles: ['s.int.yaml'] })
-    runRemove(ext, persona)
-    expect(readFileSync(log, 'utf8')).toContain('remove -y -t s.int.yaml --access clawd-fc')
-    expect(userAccessYaml()).toBe(USER_ACCESS_YAML)
-  })
-
-  // 双环境：两个 env 各 s remove 一次（哪份 s 文件在删哪份；legacy s.yaml 也认），DROP 打两套前缀
-  it('s.int.yaml / s.prod.yaml 各 remove 一次（legacy s.yaml 与 s.prod.yaml 同指 prod 函数，有后者就不再对前者 remove）；基础表名展开成 _int_ 与无标签两套 DROP', () => {
-    const log = join(box.root, 's-argv.log')
-    writeSShim(box.bin, log)
-    const { ext, persona } = removeFixture({ sFiles: ['s.int.yaml', 's.prod.yaml', 's.yaml'], tables: 'visits notes' })
-    const out = runRemove(ext, persona)
-    const argv = readFileSync(log, 'utf8')
-    expect(argv).toContain('remove -y -t s.int.yaml --access clawd-fc')
-    expect(argv).toContain('remove -y -t s.prod.yaml --access clawd-fc')
-    expect(argv).not.toContain('-t s.yaml ')
-    for (const t of ['demo_ab12_int_visits', 'demo_ab12_visits', 'demo_ab12_int_notes', 'demo_ab12_notes']) {
-      expect(out).toContain(`DROP TABLE IF EXISTS public.${t} CASCADE;`)
-    }
-  })
-
-  it('双环境之前的完整表名（带完整前缀 <APP_NAME>_<SLUG>_）只打一条；别的前缀一律按基础名展开，DROP 永远落在自己前缀下', () => {
-    const log = join(box.root, 's-argv.log')
-    writeSShim(box.bin, log)
-    const { ext, persona } = removeFixture({ sFiles: ['s.yaml'], tables: 'demo_ab12_visits' })
-    const out = runRemove(ext, persona)
-    expect(readFileSync(log, 'utf8')).toContain('remove -y -t s.yaml --access clawd-fc')
-    expect(out.match(/DROP TABLE/g)).toHaveLength(1)
-    expect(out).toContain('DROP TABLE IF EXISTS public.demo_ab12_visits CASCADE;')
-    writeFileSync(join(ext, 'ext.conf'), 'APP_NAME=demo\nSLUG=ab12\nSUPABASE_TABLES="demo_other_visits"\n')
-    const out2 = runRemove(ext, persona)
-    expect(out2).not.toContain('public.demo_other_visits ')
-    expect(out2.match(/DROP TABLE IF EXISTS public\.demo_ab12_(int_)?demo_other_visits CASCADE;/g)).toHaveLength(2)
-  })
-
-  // dataclaw 双环境之前 functionName 不带 slug：老 s.yaml 与 s.prod.yaml 指**不同**函数（name: 不同），两份都要拆
-  it('老 s.yaml 的 name 与 s.prod.yaml 不同（指不同函数）：两份都 remove', () => {
-    const log = join(box.root, 's-argv.log')
-    writeSShim(box.bin, log)
-    const { ext, persona } = removeFixture({ sFiles: ['s.prod.yaml', 's.yaml'], names: { 's.yaml': 'demo-app', 's.prod.yaml': 'demo-ab12-app' } })
-    runRemove(ext, persona)
-    const argv = readFileSync(log, 'utf8')
-    expect(argv).toContain('remove -y -t s.prod.yaml --access clawd-fc')
-    expect(argv).toContain('remove -y -t s.yaml --access clawd-fc')
-  })
-
-  // #4：基础名恰好以 <APP_NAME>_ 开头（shop 的 shop_items）不能被当成 legacy 完整名——legacy 判据是完整前缀 <APP_NAME>_<SLUG>_
-  it('基础名以 <APP_NAME>_ 开头（shop_items）仍按基础名展开两套', () => {
-    writeSShim(box.bin, join(box.root, 's-argv.log'))
-    const { ext, persona } = removeFixture({ sFiles: ['s.prod.yaml'], tables: 'demo_items' })
-    const out = runRemove(ext, persona)
-    expect(out).toContain('DROP TABLE IF EXISTS public.demo_ab12_int_demo_items CASCADE;')
-    expect(out).toContain('DROP TABLE IF EXISTS public.demo_ab12_demo_items CASCADE;')
-    expect(out.match(/DROP TABLE/g)).toHaveLength(2)
-  })
-
-  it('从未发布过（没有任何 s 文件）：不调 s remove，退出 0', () => {
-    const log = join(box.root, 's-argv.log')
-    writeSShim(box.bin, log)
-    const { ext, persona } = removeFixture({ sFiles: [] })
-    const out = runRemove(ext, persona)
-    expect(existsSync(log)).toBe(false)
-    expect(out).toContain('从未发布过')
-  })
-})