// Package libraryhandoff 把一份已封存快照在"本机控制面"与"云测试发布执行器"之间搬运, // 并保证"字节在到达前不可用"。 // // 为什么不是"把归档目录 rsync 过去":发布链路在装配阶段会用 Load 逐 blob 重算 sha256, // 半拷贝的归档会让发布在维护窗口里失败——正好落在最不该失败的时刻。所以搬运单位是 // 自描述 bundle(清单先写、blob 以 sha256 命名、下载侧边收边算),并且**只有** // 远端 `libraryctl snapshot-unpack` 成功、版本清单摘要自证、身份与请求一致之后, // 调用方才允许把发布作业入队。 // // 通道只用已批准的本机→云端 SSH(BatchMode、0600 配置+私钥)。远端命令是固定 argv: // 容器名、归档根、暂存目录全部来自部署配置,调用方只能给快照 ID 与期望身份。 package libraryhandoff import ( "context" "crypto/sha256" "encoding/hex" "errors" "fmt" "io" "os" "os/exec" "path/filepath" "regexp" "sort" "strings" "syscall" "time" "knowledge-governance/internal/librarysnapshot" ) // Identity 是一次搬运期望的快照身份。它必须来自治理库里的作业/版本记录, // 不能从 bundle 自己读到的值"回填"——那就是让数据自己证明自己。 type Identity struct { SnapshotID string Scope string TenantID uint64 KnowledgeBaseID string } // Config 是部署注入的搬运配置。缺项即未接线:未接线时调用方保持旧行为(本机目标)。 type Config struct { // SSHTarget 是 ssh 配置里的 Host 别名;SSHConfig 是 `ssh -F` 用的 0600 文件。 SSHTarget string SSHConfig string // ExecutorContainer 是云端 release-executor 容器名(libraryctl 在 /app/libraryctl)。 ExecutorContainer string // BundleDir 是云端暂存目录(只放传输中的 bundle,不参与保留策略)。 BundleDir string // RemoteArchive 是云端执行器的归档根(与执行器 env 的 LIBRARY_ARCHIVE_ROOT 一致)。 RemoteArchive string // LocalArchive 是本机归档根(只读读取;回传时写入)。 LocalArchive string // StagingDir 是本机暂存(0600,放本次 pack 出来的 bundle)。 StagingDir string // MaxBundleBytes 是单份 bundle 的上限;超过即拒绝(防止把整机磁盘拖垮)。 MaxBundleBytes int64 // OpTimeout 是单个远端动作的超时。 OpTimeout time.Duration // PullInterval 是"云端版本回传本机"的扫描间隔(只有 capture 角色用)。 PullInterval time.Duration // Transport 是 "ssh"(默认)或 "local"(仅限隔离 fixture 测试)。 Transport string // LocalRoot 是 local transport 的"云端根目录"(fixture 用)。 LocalRoot string } const ( TransportSSH = "ssh" TransportLocal = "local" ) func (c *Config) validate() error { missing := make([]string, 0, 6) if c.Transport == TransportLocal { // fixture 通道没有 ssh,但必须有显式隔离根:否则"本地目录"会被当成云端。 if c.LocalRoot == "" || !filepath.IsAbs(c.LocalRoot) { missing = append(missing, "LOCAL_ROOT") } } else { if c.SSHTarget == "" { missing = append(missing, "SSH_TARGET") } if c.SSHConfig == "" || !filepath.IsAbs(c.SSHConfig) { missing = append(missing, "SSH_CONFIG") } } if c.ExecutorContainer == "" { missing = append(missing, "EXECUTOR_CONTAINER") } for name, value := range map[string]string{"BUNDLE_DIR": c.BundleDir, "REMOTE_ARCHIVE": c.RemoteArchive, "LOCAL_ARCHIVE": c.LocalArchive, "STAGING_DIR": c.StagingDir} { if value == "" || !filepath.IsAbs(value) || filepath.Clean(value) != value || strings.Contains(value, "..") { missing = append(missing, name) } } if len(missing) > 0 { sort.Strings(missing) return fmt.Errorf("快照搬运未接线:缺少 %s", strings.Join(missing, "、")) } if c.MaxBundleBytes <= 0 { c.MaxBundleBytes = 8 << 30 } if c.OpTimeout <= 0 { c.OpTimeout = 10 * time.Minute } return nil } // Evidence 是一次搬运留下的可审计事实(写进作业阶段/日志,不写凭据)。 type Evidence struct { Snapshot string `json:"snapshot"` Scope string `json:"scope"` TenantID uint64 `json:"tenant_id"` KnowledgeBase string `json:"knowledge_base_id"` Parts int `json:"parts"` Bytes int64 `json:"bytes"` Reused bool `json:"reused"` Direction string `json:"direction"` VerifiedAt time.Time `json:"verified_at"` } // Remote 是"云端那一侧"的动作集合。两种实现:ssh(真实通道)与 local(隔离 fixture)。 type Remote interface { PutBundle(ctx context.Context, name string, body io.Reader) error OpenBundle(ctx context.Context, name string) (io.ReadCloser, error) RemoveBundle(ctx context.Context, name string) error RunLibraryctl(ctx context.Context, args ...string) ([]byte, error) ReadVersionManifest(ctx context.Context, id string) ([]byte, error) // VerifySnapshot 要求远端对这份快照做**整版**校验(逐部件重算字节), // 复用一份已有清单前必须通过它:清单存在不等于字节还在。 VerifySnapshot(ctx context.Context, id string) error } // Handoff 是搬运的执行者(一套实现,两个方向)。 type Handoff struct { config Config remote Remote now func() time.Time } var snapshotIDPattern = regexp.MustCompile(`^[0-9a-f]{64}$`) // bundleName 只接受内容寻址的快照 ID:暂存目录里不允许出现调用方可控的文件名。 func bundleName(id string) (string, error) { if !snapshotIDPattern.MatchString(id) { return "", errors.New("快照 ID 必须是 64 位小写十六进制") } return id + ".tar", nil } // New 装配搬运执行器。transport 选择失败一律报错,不做"降级到本机"。 func New(config Config, now func() time.Time) (*Handoff, error) { if err := config.validate(); err != nil { return nil, err } if now == nil { now = time.Now } if config.Transport == "" { config.Transport = TransportSSH } var remote Remote switch config.Transport { case TransportSSH: remote = &sshRemote{config: config} case TransportLocal: // 只看配置不足以证明这是测试:必须显式给出隔离根,且不得同时配 SSH 目标, // 否则等于把"本地目录"冒充成云端。 if config.LocalRoot == "" || !filepath.IsAbs(config.LocalRoot) { return nil, errors.New("local transport 必须显式给出隔离根目录") } remote = &localRemote{config: config} default: return nil, fmt.Errorf("未知搬运通道 %q(只允许 ssh/local)", config.Transport) } return &Handoff{config: config, remote: remote, now: now}, nil } // Push 把本机快照送到云端执行器,并在云端**再校验一遍**后才算成功。 // // 返回成功即代表:云端 `versions/.json` 存在、摘要 == id、逐 blob 校验通过、 // 清单身份与请求一致。任何一步不满足都返回错误,调用方不得入队发布作业。 func (h *Handoff) Push(ctx context.Context, want Identity) (Evidence, error) { if err := validateIdentity(want); err != nil { return Evidence{}, err } name, err := bundleName(want.SnapshotID) if err != nil { return Evidence{}, err } // 远端已有同 ID:必须字节一致且身份一致才复用;否则拒绝(同 ID 异内容)。 if evidence, ok, err := h.remoteEvidence(ctx, want); err != nil { return Evidence{}, err } else if ok { evidence.Direction = "push" evidence.Bytes = 0 return evidence, nil } unlock, err := h.lock(ctx, want.SnapshotID) if err != nil { return Evidence{}, err } defer unlock() // 拿锁后再查一次:并发调用里后到的那个直接复用先到的结果。 if evidence, ok, err := h.remoteEvidence(ctx, want); err != nil { return Evidence{}, err } else if ok { evidence.Direction = "push" return evidence, nil } archive, err := librarysnapshot.Open(h.config.LocalArchive, 256*1024*1024) if err != nil { return Evidence{}, fmt.Errorf("本机归档不可读,无法搬运:%w", err) } defer archive.Close() // Load 逐 blob 重算 sha256:只搬"在这台机器上验证过"的字节。 manifest, err := archive.Load(want.SnapshotID) if err != nil { return Evidence{}, fmt.Errorf("本机快照不可用(可能只存在于云端,走 Fetch):%w", err) } if err := matchesIdentity(manifest, want); err != nil { return Evidence{}, err } bundle, cleanup, err := h.packLocally(archive, want.SnapshotID, name) if err != nil { return Evidence{}, err } defer cleanup() file, err := os.Open(bundle) if err != nil { return Evidence{}, errors.New("打开本机 bundle 失败") } defer file.Close() if info, statErr := file.Stat(); statErr != nil || info.Size() <= 0 || info.Size() > h.config.MaxBundleBytes { return Evidence{}, errors.New("bundle 大小超出允许范围") } if err := h.remote.PutBundle(ctx, name, file); err != nil { return Evidence{}, fmt.Errorf("把快照送到执行器失败:%w", err) } if _, err := h.remote.RunLibraryctl(ctx, "snapshot-unpack", "-archive", h.config.RemoteArchive, "-bundle", filepath.Join(h.config.BundleDir, name), "-snapshot", want.SnapshotID); err != nil { return Evidence{}, fmt.Errorf("执行器侧校验/装入失败:%w", err) } manifestRaw, err := h.remote.ReadVersionManifest(ctx, want.SnapshotID) if err != nil { return Evidence{}, fmt.Errorf("执行器侧版本清单不可读:%w", err) } sum := sha256.Sum256(manifestRaw) if hex.EncodeToString(sum[:]) != want.SnapshotID { return Evidence{}, errors.New("执行器侧版本清单摘要与快照 ID 不一致") } remoteManifest, err := librarysnapshot.DecodeManifest(manifestRaw, want.SnapshotID) if err != nil { return Evidence{}, fmt.Errorf("执行器侧清单不可解析:%w", err) } if err := matchesIdentity(remoteManifest, want); err != nil { return Evidence{}, err } // 只删本次传输的暂存文件;归档本体(versions/blobs)一律不动。 _ = h.remote.RemoveBundle(ctx, name) return Evidence{Snapshot: want.SnapshotID, Scope: want.Scope, TenantID: want.TenantID, KnowledgeBase: want.KnowledgeBaseID, Parts: len(remoteManifest.Parts), Bytes: manifestBytes(remoteManifest), Direction: "push", VerifiedAt: h.now().UTC()}, nil } // Fetch 把云端存在的快照取回本机归档(预备份/云端产物的读回路径)。 // // 成功即代表:本机 versions/.json 已落位、逐 blob 校验通过。失败则本机不留下版本, // 页面照旧按"没有这份版本"展示,绝不显示成可恢复。 func (h *Handoff) Fetch(ctx context.Context, id string) (Evidence, error) { name, err := bundleName(id) if err != nil { return Evidence{}, err } archive, err := librarysnapshot.Open(h.config.LocalArchive, 256*1024*1024) if err != nil { return Evidence{}, fmt.Errorf("本机归档不可用:%w", err) } defer archive.Close() if manifest, loadErr := archive.Load(id); loadErr == nil { return Evidence{Snapshot: id, Scope: manifest.Scope, TenantID: manifest.TenantID, KnowledgeBase: manifest.KnowledgeBaseID, Parts: len(manifest.Parts), Bytes: manifestBytes(manifest), Reused: true, Direction: "fetch", VerifiedAt: h.now().UTC()}, nil } unlock, err := h.lock(ctx, id) if err != nil { return Evidence{}, err } defer unlock() if manifest, loadErr := archive.Load(id); loadErr == nil { return Evidence{Snapshot: id, Scope: manifest.Scope, TenantID: manifest.TenantID, KnowledgeBase: manifest.KnowledgeBaseID, Parts: len(manifest.Parts), Bytes: manifestBytes(manifest), Reused: true, Direction: "fetch", VerifiedAt: h.now().UTC()}, nil } remoteBundle := filepath.Join(h.config.BundleDir, name) defer func() { _ = h.remote.RemoveBundle(context.WithoutCancel(ctx), name) }() if _, err := h.remote.RunLibraryctl(ctx, "snapshot-pack", "-archive", h.config.RemoteArchive, "-snapshot", id, "-bundle", remoteBundle); err != nil { return Evidence{}, fmt.Errorf("云端快照不可打包(可能不存在或校验失败):%w", err) } body, err := h.remote.OpenBundle(ctx, name) if err != nil { return Evidence{}, fmt.Errorf("读取云端 bundle 失败:%w", err) } defer body.Close() localBundle := filepath.Join(h.config.StagingDir, name) _ = os.Remove(localBundle) out, err := os.OpenFile(localBundle, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600) if err != nil { return Evidence{}, errors.New("无法创建本机暂存 bundle") } written, copyErr := io.Copy(out, io.LimitReader(body, h.config.MaxBundleBytes+1)) syncErr := out.Sync() closeErr := out.Close() defer os.Remove(localBundle) if copyErr != nil || syncErr != nil || closeErr != nil { return Evidence{}, errors.New("回传快照字节失败(连接中断或被截断)") } if written > h.config.MaxBundleBytes { return Evidence{}, errors.New("回传 bundle 超过上限,拒绝导入") } // 读回的是权威云端副本:本地同名 blob 字节不符按损坏修复(普通导入仍默认拒绝)。 manifest, err := archive.UnpackWithOptions(localBundle, id, librarysnapshot.UnpackOptions{RepairCorruptBlobs: true}) if err != nil { return Evidence{}, fmt.Errorf("回传快照校验失败(截断/篡改/缺部件):%w", err) } return Evidence{Snapshot: id, Scope: manifest.Scope, TenantID: manifest.TenantID, KnowledgeBase: manifest.KnowledgeBaseID, Parts: len(manifest.Parts), Bytes: manifestBytes(manifest), Direction: "fetch", VerifiedAt: h.now().UTC()}, nil } // remoteEvidence 判断"云端已经有这份快照且身份一致"。 func (h *Handoff) remoteEvidence(ctx context.Context, want Identity) (Evidence, bool, error) { raw, err := h.remote.ReadVersionManifest(ctx, want.SnapshotID) if err != nil { if errors.Is(err, os.ErrNotExist) || strings.Contains(strings.ToLower(err.Error()), "no such file") { return Evidence{}, false, nil } return Evidence{}, false, fmt.Errorf("读取执行器侧版本清单失败:%w", err) } sum := sha256.Sum256(raw) if hex.EncodeToString(sum[:]) != want.SnapshotID { return Evidence{}, false, errors.New("执行器侧已有同名版本但清单摘要不符:拒绝复用") } manifest, err := librarysnapshot.DecodeManifest(raw, want.SnapshotID) if err != nil { return Evidence{}, false, err } if err := matchesIdentity(manifest, want); err != nil { return Evidence{}, false, err } // 关键:清单存在只证明"这个名字有主",不证明 blob 还在、还对。 // 复用前让远端整版重算一遍,缺失/篡改必须在这里就失败(尚未入发布队列)。 if err := h.remote.VerifySnapshot(ctx, want.SnapshotID); err != nil { return Evidence{}, false, fmt.Errorf("执行器侧已有清单但字节校验失败,拒绝复用:%w", err) } return Evidence{Snapshot: want.SnapshotID, Scope: manifest.Scope, TenantID: manifest.TenantID, KnowledgeBase: manifest.KnowledgeBaseID, Parts: len(manifest.Parts), Bytes: manifestBytes(manifest), Reused: true, VerifiedAt: h.now().UTC()}, true, nil } func (h *Handoff) packLocally(archive *librarysnapshot.Archive, id, name string) (string, func(), error) { if err := os.MkdirAll(h.config.StagingDir, 0700); err != nil { return "", func() {}, errors.New("本机暂存目录不可用") } path := filepath.Join(h.config.StagingDir, name) _ = os.Remove(path) if _, err := archive.Pack(id, path); err != nil { return "", func() {}, fmt.Errorf("打包快照失败:%w", err) } return path, func() { _ = os.Remove(path) }, nil } // lock 用 flock 串行化"同一份快照"的本机搬运(并发点击/重试不会同时写暂存)。 func (h *Handoff) lock(ctx context.Context, id string) (func(), error) { dir := filepath.Join(h.config.LocalArchive, ".handoff") if err := os.MkdirAll(dir, 0700); err != nil { return nil, errors.New("无法创建搬运锁目录") } file, err := os.OpenFile(filepath.Join(dir, id+".lock"), os.O_CREATE|os.O_RDWR, 0600) if err != nil { return nil, errors.New("无法创建搬运锁") } deadline := time.Now().Add(h.config.OpTimeout) for { if err := syscall.Flock(int(file.Fd()), syscall.LOCK_EX|syscall.LOCK_NB); err == nil { return func() { _ = syscall.Flock(int(file.Fd()), syscall.LOCK_UN) _ = file.Close() }, nil } if time.Now().After(deadline) { file.Close() return nil, errors.New("另一份搬运正在处理同一个快照,等待超时") } select { case <-ctx.Done(): file.Close() return nil, ctx.Err() case <-time.After(100 * time.Millisecond): } } } func validateIdentity(want Identity) error { if !snapshotIDPattern.MatchString(want.SnapshotID) { return errors.New("快照 ID 必须是 64 位小写十六进制") } if want.Scope != "internal" && want.Scope != "external" { return errors.New("快照 scope 必须是 internal 或 external") } if want.TenantID == 0 { return errors.New("缺少租户身份,无法核对快照归属") } if strings.TrimSpace(want.KnowledgeBaseID) == "" { return errors.New("缺少目标知识库身份,无法核对快照归属") } return nil } // matchesIdentity 用治理库里的期望值核对 bundle 自报的身份。 func matchesIdentity(manifest librarysnapshot.Manifest, want Identity) error { if manifest.Scope != want.Scope { return fmt.Errorf("快照 scope=%q 与请求 %q 不一致", manifest.Scope, want.Scope) } if manifest.TenantID != want.TenantID { return fmt.Errorf("快照 tenant=%d 与请求 %d 不一致", manifest.TenantID, want.TenantID) } if manifest.KnowledgeBaseID != want.KnowledgeBaseID { return fmt.Errorf("快照知识库 %s 与请求 %s 不一致", manifest.KnowledgeBaseID, want.KnowledgeBaseID) } return nil } func manifestBytes(manifest librarysnapshot.Manifest) int64 { var total int64 seen := map[string]bool{} for _, part := range manifest.Parts { if seen[part.SHA256] { continue } seen[part.SHA256] = true total += part.Bytes } return total } // ---- ssh 传输:固定 argv,路径全部来自配置 ---- type sshRemote struct { config Config } // remoteExitError 保留远端退出码:只有"文件不存在(44)"才能当成"还没有这份版本", // 网络断、权限错、docker 不可用都必须原样上抛——否则会把"读不到"当成"没有", // 于是继续搬一份没人验证过的快照。 type remoteExitError struct { code int detail string } func (e *remoteExitError) Error() string { return fmt.Sprintf("ssh exit %d: %s", e.code, e.detail) } func (r *sshRemote) run(ctx context.Context, stdin io.Reader, stdout io.Writer, remote string) error { bounded, cancel := context.WithTimeout(ctx, r.config.OpTimeout) defer cancel() argv := []string{"-F", r.config.SSHConfig, "-o", "BatchMode=yes", "-o", "ConnectTimeout=10", r.config.SSHTarget, remote} command := exec.CommandContext(bounded, "ssh", argv...) command.Stdin = stdin command.Stdout = stdout var stderr strings.Builder command.Stderr = &stderr if err := command.Run(); err != nil { if bounded.Err() != nil { return fmt.Errorf("ssh %s 超时", r.config.SSHTarget) } detail := strings.TrimSpace(stderr.String()) if len(detail) > 300 { detail = detail[:300] } var exit *exec.ExitError if errors.As(err, &exit) { return &remoteExitError{code: exit.ExitCode(), detail: detail} } return fmt.Errorf("ssh %s 失败: %s", r.config.SSHTarget, detail) } return nil } func (r *sshRemote) PutBundle(ctx context.Context, name string, body io.Reader) error { path := filepath.Join(r.config.BundleDir, name) if err := r.run(ctx, nil, io.Discard, fmt.Sprintf("install -d -m 0700 %s", shellQuote(r.config.BundleDir))); err != nil { return err } if err := r.run(ctx, body, io.Discard, fmt.Sprintf("cat > %s", shellQuote(path+".part"))); err != nil { return err } return r.run(ctx, nil, io.Discard, fmt.Sprintf("mv -f %s %s", shellQuote(path+".part"), shellQuote(path))) } func (r *sshRemote) OpenBundle(ctx context.Context, name string) (io.ReadCloser, error) { path := filepath.Join(r.config.BundleDir, name) reader, writer := io.Pipe() go func() { writer.CloseWithError(r.run(ctx, nil, writer, fmt.Sprintf("cat %s", shellQuote(path)))) }() return reader, nil } func (r *sshRemote) RemoveBundle(ctx context.Context, name string) error { path := filepath.Join(r.config.BundleDir, name) return r.run(ctx, nil, io.Discard, fmt.Sprintf("rm -f %s %s", shellQuote(path), shellQuote(path+".part"))) } func (r *sshRemote) RunLibraryctl(ctx context.Context, args ...string) ([]byte, error) { quoted := make([]string, 0, len(args)+2) quoted = append(quoted, "docker", "exec", shellQuote(r.config.ExecutorContainer), "/app/libraryctl") for _, arg := range args { quoted = append(quoted, shellQuote(arg)) } var out strings.Builder if err := r.run(ctx, nil, &out, strings.Join(quoted, " ")); err != nil { return nil, err } return []byte(out.String()), nil } func (r *sshRemote) VerifySnapshot(ctx context.Context, id string) error { _, err := r.RunLibraryctl(ctx, "snapshot-verify", "-archive", r.config.RemoteArchive, "-snapshot", id) return err } func (r *sshRemote) ReadVersionManifest(ctx context.Context, id string) ([]byte, error) { path := filepath.Join(r.config.RemoteArchive, "versions", id+".json") var out strings.Builder // 只有 "文件不存在" 才算"还没有这份版本";其它失败必须让调用方停下来。 // RemoteArchive belongs to the executor filesystem, not the SSH host. read := fmt.Sprintf("if [ -f %s ]; then cat %s; else exit 44; fi", shellQuote(path), shellQuote(path)) command := "docker exec " + shellQuote(r.config.ExecutorContainer) + " sh -c " + shellQuote(read) if err := r.run(ctx, nil, &out, command); err != nil { var exit *remoteExitError if errors.As(err, &exit) && exit.code == 44 { return nil, fmt.Errorf("%w", os.ErrNotExist) } return nil, err } return []byte(out.String()), nil } func shellQuote(value string) string { return "'" + strings.ReplaceAll(value, "'", `'\''`) + "'" } // ---- local 传输:只用于隔离 fixture(跨进程执行真正的 libraryctl) ---- type localRemote struct { config Config } func (r *localRemote) path(name string) (string, error) { if _, err := bundleName(strings.TrimSuffix(name, ".tar")); err != nil { return "", err } return filepath.Join(r.config.BundleDir, name), nil } func (r *localRemote) PutBundle(ctx context.Context, name string, body io.Reader) error { path, err := r.path(name) if err != nil { return err } if err := os.MkdirAll(r.config.BundleDir, 0700); err != nil { return err } out, err := os.OpenFile(path+".part", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0600) if err != nil { return err } if _, err := io.Copy(out, io.LimitReader(body, r.config.MaxBundleBytes+1)); err != nil { out.Close() return err } if err := out.Sync(); err != nil { out.Close() return err } if err := out.Close(); err != nil { return err } return os.Rename(path+".part", path) } func (r *localRemote) OpenBundle(ctx context.Context, name string) (io.ReadCloser, error) { path, err := r.path(name) if err != nil { return nil, err } return os.Open(path) } func (r *localRemote) RemoveBundle(ctx context.Context, name string) error { path, err := r.path(name) if err != nil { return err } for _, candidate := range []string{path, path + ".part"} { if err := os.Remove(candidate); err != nil && !errors.Is(err, os.ErrNotExist) { return err } } return nil } // RunLibraryctl 在 fixture 里跨进程执行真正的 libraryctl 二进制(不是进程内模拟)。 func (r *localRemote) RunLibraryctl(ctx context.Context, args ...string) ([]byte, error) { binary := os.Getenv("LIBRARY_HANDOFF_LIBRARYCTL") if binary == "" { return nil, errors.New("fixture 缺少 LIBRARY_HANDOFF_LIBRARYCTL(libraryctl 可执行路径)") } bounded, cancel := context.WithTimeout(ctx, r.config.OpTimeout) defer cancel() command := exec.CommandContext(bounded, binary, args...) command.Env = append(os.Environ(), "LIBRARY_HANDOFF_FIXTURE=1") var stderr strings.Builder command.Stderr = &stderr out, err := command.Output() if err != nil { detail := strings.TrimSpace(stderr.String()) if len(detail) > 300 { detail = detail[:300] } return nil, fmt.Errorf("libraryctl 失败: %s", detail) } return out, nil } func (r *localRemote) VerifySnapshot(ctx context.Context, id string) error { _, err := r.RunLibraryctl(ctx, "snapshot-verify", "-archive", r.config.RemoteArchive, "-snapshot", id) return err } func (r *localRemote) ReadVersionManifest(ctx context.Context, id string) ([]byte, error) { path := filepath.Join(r.config.RemoteArchive, "versions", id+".json") raw, err := os.ReadFile(path) if err != nil { return nil, err } return raw, nil }