Skip to content

Formerly KrillinAI, VideoTranslation and Dubbing Tool for 120+ Languages. Open-source AI workspace for creators, powered by Codex. Video downloader, video translation, create videos, images, audios, and edits with Agents in one place. For your Social Media like YouTube, TikTok, Instagram, etc.

feat: add cli self update command

wulien297d44a203a8
diff --git a/.goreleaser.yaml b/.goreleaser.yaml
index 6134ec0a..abcc73cb 100644
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@@ -14,6 +14,8 @@ builds:
binary: krillinai-cli
env:
- CGO_ENABLED=0
+ ldflags:
+ - -s -w -X krillin-ai/internal/cli.Version={{.Version}}
goos:
- darwin
- linux
diff --git a/cmd/cli/main.go b/cmd/cli/main.go
index 40d6e297..0282f0bb 100644
--- a/cmd/cli/main.go
+++ b/cmd/cli/main.go
@@ -29,6 +29,10 @@ func main() {
writeAndExit(cli.Execute(context.Background(), nil, cmd))
return
}
+ if cmd.Name == "update" {
+ writeAndExit(cli.Execute(context.Background(), nil, cmd))
+ return
+ }
if !config.LoadConfig() {
writeAndExit(pipeline.Response{
diff --git a/internal/cli/commands.go b/internal/cli/commands.go
index 415e4245..95e38f58 100644
--- a/internal/cli/commands.go
+++ b/internal/cli/commands.go
@@ -8,6 +8,7 @@ import (
"io"
"krillin-ai/internal/pipeline"
subtitlestyle "krillin-ai/internal/subtitle_style"
+ "krillin-ai/internal/updater"
"os"
"path/filepath"
"runtime"
@@ -50,6 +51,14 @@ type Command struct {
Render pipeline.RenderRequest
Cover pipeline.CoverRequest
Pipeline pipeline.PipelineRequest
+ Update UpdateRequest
+}
+
+type UpdateRequest struct {
+ Repo string
+ Version string
+ Target string
+ Force bool
}
func Parse(args []string) (Command, error) {
@@ -73,6 +82,8 @@ func Parse(args []string) (Command, error) {
return parsePipeline(name, args[1:])
case "cover":
return parseCover(name, args[1:])
+ case "update":
+ return parseUpdate(name, args[1:])
case "status":
if hasHelpArg(args[1:]) {
return Command{Name: name, Help: true}, nil
@@ -170,6 +181,18 @@ Flags:
--size <size> Image size, such as 1024x1024 or 1536x1024
--dry-run Validate and write manifest without external calls
-h, --help Show this help
+`
+ case "update":
+ return `Usage:
+ krillinai-cli update [flags]
+
+Flags:
+ --repo <owner/name> GitHub repository to update from (default krillinai/KrillinAI)
+ --version <tag> Specific release tag, such as v2.0.3; default latest release
+ --target <file> Executable path to replace; default current executable
+ --force Reinstall even when current version matches latest
+ --dry-run Validate command without downloading or replacing files
+ -h, --help Show this help
`
case "status":
return `Usage:
@@ -188,6 +211,7 @@ Commands:
render-vertical Render portrait subtitle or dubbed videos
pipeline Plan or run multi-stage workflows when supported
cover Generate a cover image from a prompt
+ update Update krillinai-cli from GitHub releases
status Reserved status query surface
Run "krillinai-cli <command> --help" for command-specific flags.
@@ -222,6 +246,8 @@ func Execute(ctx context.Context, svc pipeline.StageService, cmd Command) pipeli
case "cover":
resp, err := pipeline.GenerateCover(ctx, svc, cmd.Cover)
return responseWithError(resp, err)
+ case "update":
+ return executeUpdate(ctx, cmd.Update)
default:
return pipeline.Response{
OK: false,
@@ -234,6 +260,76 @@ func Execute(ctx context.Context, svc pipeline.StageService, cmd Command) pipeli
}
}
+func parseUpdate(name string, args []string) (Command, error) {
+ if hasHelpArg(args) {
+ return Command{Name: name, Help: true}, nil
+ }
+ fs := newFlagSet(name)
+ repo := fs.String("repo", updater.DefaultRepo, "GitHub repository")
+ version := fs.String("version", "", "release tag")
+ target := fs.String("target", "", "target executable")
+ force := fs.Bool("force", false, "force reinstall")
+ dryRun := fs.Bool("dry-run", false, "validate command without running update")
+ if err := fs.Parse(args); err != nil {
+ return Command{}, err
+ }
+ if fs.NArg() != 0 {
+ return Command{}, errors.New("update does not accept positional arguments")
+ }
+ return Command{
+ Name: name,
+ DryRun: *dryRun,
+ Update: UpdateRequest{
+ Repo: *repo,
+ Version: *version,
+ Target: *target,
+ Force: *force,
+ },
+ }, nil
+}
+
+func executeUpdate(ctx context.Context, req UpdateRequest) pipeline.Response {
+ result, err := updater.Run(ctx, updater.Request{
+ Repo: req.Repo,
+ Version: req.Version,
+ Target: req.Target,
+ Force: req.Force,
+ CurrentVersion: Version,
+ }, updater.HTTPRunner{})
+ if err != nil {
+ return pipeline.Response{
+ OK: false,
+ Stage: pipeline.StageUpdate,
+ Error: &pipeline.Error{
+ Kind: pipeline.ErrorKindRetryable,
+ Code: "update_failed",
+ Message: err.Error(),
+ Retryable: true,
+ },
+ }
+ }
+ inputs := map[string]string{
+ "repo": req.Repo,
+ }
+ if req.Version != "" {
+ inputs["version"] = req.Version
+ }
+ if req.Target != "" {
+ inputs["target"] = req.Target
+ }
+ if result.Asset != "" {
+ inputs["asset"] = result.Asset
+ }
+ return pipeline.Response{
+ OK: true,
+ Stage: pipeline.StageUpdate,
+ Inputs: inputs,
+ Warnings: []string{
+ result.Message,
+ },
+ }
+}
+
func parseCover(name string, args []string) (Command, error) {
if hasHelpArg(args) {
return Command{Name: name, Help: true}, nil
@@ -429,6 +525,21 @@ func dryRun(cmd Command) pipeline.Response {
})
case "pipeline":
return pipeline.Response{OK: true, Stage: pipeline.StagePipeline}
+ case "update":
+ inputs := map[string]string{
+ "repo": cmd.Update.Repo,
+ }
+ if cmd.Update.Version != "" {
+ inputs["version"] = cmd.Update.Version
+ }
+ if cmd.Update.Target != "" {
+ inputs["target"] = cmd.Update.Target
+ }
+ return pipeline.Response{
+ OK: true,
+ Stage: pipeline.StageUpdate,
+ Inputs: inputs,
+ }
default:
return pipeline.Response{
OK: false,
diff --git a/internal/cli/commands_test.go b/internal/cli/commands_test.go
index 3dab1a85..7d2951c9 100644
--- a/internal/cli/commands_test.go
+++ b/internal/cli/commands_test.go
@@ -94,6 +94,48 @@ func TestParseRenderCommandAcceptsSubtitleStyleFile(t *testing.T) {
}
}
+func TestParseUpdateCommand(t *testing.T) {
+ cmd, err := Parse([]string{
+ "update",
+ "--repo", "krillinai/KrillinAI",
+ "--target", "/usr/local/bin/krillinai-cli",
+ "--version", "v2.0.3",
+ "--force",
+ })
+ if err != nil {
+ t.Fatalf("Parse() error = %v", err)
+ }
+ if cmd.Name != "update" {
+ t.Fatalf("Name = %q, want update", cmd.Name)
+ }
+ if cmd.Update.Repo != "krillinai/KrillinAI" {
+ t.Fatalf("Repo = %q", cmd.Update.Repo)
+ }
+ if cmd.Update.Target != "/usr/local/bin/krillinai-cli" {
+ t.Fatalf("Target = %q", cmd.Update.Target)
+ }
+ if cmd.Update.Version != "v2.0.3" {
+ t.Fatalf("Version = %q", cmd.Update.Version)
+ }
+ if !cmd.Update.Force {
+ t.Fatal("Force = false, want true")
+ }
+}
+
+func TestUpdateHelp(t *testing.T) {
+ cmd, err := Parse([]string{"update", "--help"})
+ if err != nil {
+ t.Fatalf("Parse() error = %v", err)
+ }
+ if !cmd.Help || cmd.Name != "update" {
+ t.Fatalf("Command = %#v, want update help", cmd)
+ }
+ help := Help(cmd)
+ if !strings.Contains(help, "krillinai-cli update") || !strings.Contains(help, "--version") {
+ t.Fatalf("Help() = %q, want update usage", help)
+ }
+}
+
func TestParseRootHelp(t *testing.T) {
cmd, err := Parse([]string{"--help"})
if err != nil {
@@ -106,6 +148,9 @@ func TestParseRootHelp(t *testing.T) {
if !strings.Contains(help, "Usage:") || !strings.Contains(help, "subtitle") {
t.Fatalf("Help() = %q, want root usage with commands", help)
}
+ if !strings.Contains(help, "update") {
+ t.Fatalf("Help() = %q, want update command", help)
+ }
}
func TestParseSubcommandHelp(t *testing.T) {
@@ -203,6 +248,23 @@ func TestExecuteDryRunSubtitleReturnsJSONReadyResponse(t *testing.T) {
}
}
+func TestExecuteDryRunUpdateReturnsJSONReadyResponse(t *testing.T) {
+ cmd, err := Parse([]string{"update", "--dry-run"})
+ if err != nil {
+ t.Fatalf("Parse() error = %v", err)
+ }
+ resp := Execute(context.Background(), nil, cmd)
+ if !resp.OK {
+ t.Fatalf("OK = false, error = %#v", resp.Error)
+ }
+ if resp.Stage != pipeline.StageUpdate {
+ t.Fatalf("Stage = %s, want update", resp.Stage)
+ }
+ if resp.Inputs["repo"] != "krillinai/KrillinAI" {
+ t.Fatalf("repo input = %q", resp.Inputs["repo"])
+ }
+}
+
func TestExecuteDryRunRenderRejectsInvalidSubtitleStyleFile(t *testing.T) {
cmd, err := Parse([]string{
"render-horizontal",
diff --git a/internal/cli/version.go b/internal/cli/version.go
new file mode 100644
index 00000000..2c815800
--- /dev/null
+++ b/internal/cli/version.go
@@ -0,0 +1,3 @@
+package cli
+
+var Version = "dev"
diff --git a/internal/pipeline/types.go b/internal/pipeline/types.go
index 697fca5c..696f5d3c 100644
--- a/internal/pipeline/types.go
+++ b/internal/pipeline/types.go
@@ -11,6 +11,7 @@ const (
StageRenderVertical Stage = "render-vertical"
StageCover Stage = "cover"
StagePipeline Stage = "pipeline"
+ StageUpdate Stage = "update"
)
type CaptionSource string
diff --git a/internal/updater/updater.go b/internal/updater/updater.go
new file mode 100644
index 00000000..a0cb8601
--- /dev/null
+++ b/internal/updater/updater.go
@@ -0,0 +1,251 @@
+package updater
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "path/filepath"
+ "runtime"
+ "strings"
+)
+
+const DefaultRepo = "krillinai/KrillinAI"
+
+type Request struct {
+ Repo string
+ Version string
+ CurrentVersion string
+ Target string
+ Force bool
+ GOOS string
+ GOARCH string
+}
+
+type Result struct {
+ Updated bool
+ Version string
+ Asset string
+ Target string
+ Message string
+}
+
+type Release struct {
+ TagName string `json:"tag_name"`
+ Assets []Asset `json:"assets"`
+}
+
+type Asset struct {
+ Name string `json:"name"`
+ BrowserDownloadURL string `json:"browser_download_url"`
+}
+
+type Runner interface {
+ CurrentExecutable() (string, error)
+ FetchRelease(context.Context, string, string) (Release, error)
+ DownloadFile(context.Context, string, string) error
+ ReplaceExecutable(string, string) error
+}
+
+func Run(ctx context.Context, req Request, runner Runner) (Result, error) {
+ if req.Repo == "" {
+ req.Repo = DefaultRepo
+ }
+ if req.GOOS == "" {
+ req.GOOS = runtime.GOOS
+ }
+ if req.GOARCH == "" {
+ req.GOARCH = runtime.GOARCH
+ }
+ release, err := runner.FetchRelease(ctx, req.Repo, req.Version)
+ if err != nil {
+ return Result{}, err
+ }
+ if !req.Force && sameVersion(req.CurrentVersion, release.TagName) {
+ return Result{
+ Updated: false,
+ Version: release.TagName,
+ Message: "已经是最新版本",
+ }, nil
+ }
+ target := req.Target
+ if target == "" {
+ var err error
+ target, err = runner.CurrentExecutable()
+ if err != nil {
+ return Result{}, err
+ }
+ }
+ asset, err := resolveAsset(release, req.GOOS, req.GOARCH)
+ if err != nil {
+ return Result{}, err
+ }
+ tempPath := target + ".download"
+ if err := runner.DownloadFile(ctx, asset.BrowserDownloadURL, tempPath); err != nil {
+ _ = os.Remove(tempPath)
+ return Result{}, err
+ }
+ if req.GOOS != "windows" {
+ if err := os.Chmod(tempPath, 0755); err != nil {
+ _ = os.Remove(tempPath)
+ return Result{}, err
+ }
+ } else {
+ return Result{
+ Updated: false,
+ Version: release.TagName,
+ Asset: asset.Name,
+ Target: tempPath,
+ Message: fmt.Sprintf("Windows 不支持替换正在运行的可执行文件,新版本已下载到 %s,请退出程序后手动替换 %s", tempPath, target),
+ }, nil
+ }
+ if err := runner.ReplaceExecutable(tempPath, target); err != nil {
+ _ = os.Remove(tempPath)
+ return Result{}, err
+ }
+ return Result{
+ Updated: true,
+ Version: release.TagName,
+ Asset: asset.Name,
+ Target: target,
+ Message: "更新完成",
+ }, nil
+}
+
+func resolveAsset(release Release, goos, goarch string) (Asset, error) {
+ name, err := assetName(release.TagName, goos, goarch)
+ if err != nil {
+ return Asset{}, err
+ }
+ for _, asset := range release.Assets {
+ if asset.Name == name {
+ return asset, nil
+ }
+ }
+ return Asset{}, fmt.Errorf("release %s does not contain asset %s", release.TagName, name)
+}
+
+func assetName(version, goos, goarch string) (string, error) {
+ version = strings.TrimPrefix(strings.TrimSpace(version), "v")
+ if version == "" {
+ return "", errors.New("version is required")
+ }
+ switch goos {
+ case "darwin":
+ return fmt.Sprintf("KrillinAI-cli_%s_macOS_%s", version, goarch), nil
+ case "linux":
+ return fmt.Sprintf("KrillinAI-cli_%s_Linux_%s", version, releaseArch(goarch)), nil
+ case "windows":
+ arch := ""
+ switch goarch {
+ case "amd64", "":
+ arch = ""
+ case "386":
+ arch = "_i386"
+ default:
+ arch = "_" + goarch
+ }
+ return fmt.Sprintf("KrillinAI-cli_%s_Windows%s.exe", version, arch), nil
+ default:
+ return "", fmt.Errorf("unsupported platform: %s/%s", goos, goarch)
+ }
+}
+
+func releaseArch(goarch string) string {
+ switch goarch {
+ case "amd64", "":
+ return "x86_64"
+ case "386":
+ return "i386"
+ default:
+ return goarch
+ }
+}
+
+func sameVersion(current, latest string) bool {
+ current = strings.TrimPrefix(strings.TrimSpace(current), "v")
+ latest = strings.TrimPrefix(strings.TrimSpace(latest), "v")
+ return current != "" && current == latest
+}
+
+type HTTPRunner struct {
+ Client *http.Client
+}
+
+func (r HTTPRunner) CurrentExecutable() (string, error) {
+ return os.Executable()
+}
+
+func (r HTTPRunner) FetchRelease(ctx context.Context, repo, version string) (Release, error) {
+ if repo == "" {
+ repo = DefaultRepo
+ }
+ ref := "latest"
+ if strings.TrimSpace(version) != "" {
+ ref = "tags/" + strings.TrimSpace(version)
+ }
+ url := fmt.Sprintf("https://api.github.com/repos/%s/releases/%s", repo, ref)
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+ if err != nil {
+ return Release{}, err
+ }
+ req.Header.Set("Accept", "application/vnd.github+json")
+ client := r.Client
+ if client == nil {
+ client = http.DefaultClient
+ }
+ resp, err := client.Do(req)
+ if err != nil {
+ return Release{}, err
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+ body, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
+ return Release{}, fmt.Errorf("fetch release failed: status %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
+ }
+ var release Release
+ if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+ return Release{}, err
+ }
+ if release.TagName == "" {
+ return Release{}, errors.New("release response missing tag_name")
+ }
+ return release, nil
+}
+
+func (r HTTPRunner) DownloadFile(ctx context.Context, url, path string) error {
+ if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+ return err
+ }
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+ if err != nil {
+ return err
+ }
+ client := r.Client
+ if client == nil {
+ client = http.DefaultClient
+ }
+ resp, err := client.Do(req)
+ if err != nil {
+ return err
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+ body, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
+ return fmt.Errorf("download update failed: status %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
+ }
+ out, err := os.Create(path)
+ if err != nil {
+ return err
+ }
+ defer out.Close()
+ _, err = io.Copy(out, resp.Body)
+ return err
+}
+
+func (r HTTPRunner) ReplaceExecutable(source, target string) error {
+ return os.Rename(source, target)
+}
diff --git a/internal/updater/updater_test.go b/internal/updater/updater_test.go
new file mode 100644
index 00000000..8861be7d
--- /dev/null
+++ b/internal/updater/updater_test.go
@@ -0,0 +1,194 @@
+package updater
+
+import (
+ "context"
+ "errors"
+ "os"
+ "path/filepath"
+ "reflect"
+ "testing"
+)
+
+func TestAssetNameForCurrentPlatform(t *testing.T) {
+ got, err := assetName("2.0.3", "darwin", "arm64")
+ if err != nil {
+ t.Fatalf("assetName() error = %v", err)
+ }
+ if got != "KrillinAI-cli_2.0.3_macOS_arm64" {
+ t.Fatalf("asset name = %q", got)
+ }
+
+ got, err = assetName("v2.0.3", "linux", "amd64")
+ if err != nil {
+ t.Fatalf("assetName() error = %v", err)
+ }
+ if got != "KrillinAI-cli_2.0.3_Linux_x86_64" {
+ t.Fatalf("asset name = %q", got)
+ }
+
+ got, err = assetName("v2.0.3", "windows", "amd64")
+ if err != nil {
+ t.Fatalf("assetName() error = %v", err)
+ }
+ if got != "KrillinAI-cli_2.0.3_Windows.exe" {
+ t.Fatalf("asset name = %q", got)
+ }
+}
+
+func TestResolveAssetFindsMatchingReleaseAsset(t *testing.T) {
+ release := Release{
+ TagName: "v2.0.3",
+ Assets: []Asset{
+ {Name: "KrillinAI_2.0.3_macOS_arm64", BrowserDownloadURL: "server"},
+ {Name: "KrillinAI-cli_2.0.3_macOS_arm64", BrowserDownloadURL: "cli"},
+ },
+ }
+
+ asset, err := resolveAsset(release, "darwin", "arm64")
+ if err != nil {
+ t.Fatalf("resolveAsset() error = %v", err)
+ }
+ if asset.BrowserDownloadURL != "cli" {
+ t.Fatalf("download url = %q, want cli", asset.BrowserDownloadURL)
+ }
+}
+
+func TestRunSkipsSameVersionWithoutForce(t *testing.T) {
+ runner := &fakeRunner{
+ release: Release{TagName: "v2.0.3"},
+ }
+ result, err := Run(context.Background(), Request{
+ Repo: "krillinai/KrillinAI",
+ CurrentVersion: "v2.0.3",
+ }, runner)
+ if err != nil {
+ t.Fatalf("Run() error = %v", err)
+ }
+ if result.Updated {
+ t.Fatal("Updated = true, want false")
+ }
+ if len(runner.downloads) != 0 {
+ t.Fatalf("downloads = %#v, want none", runner.downloads)
+ }
+}
+
+func TestRunDownloadsAndReplacesCurrentExecutable(t *testing.T) {
+ dir := t.TempDir()
+ target := filepath.Join(dir, "krillinai-cli")
+ if err := os.WriteFile(target, []byte("old"), 0755); err != nil {
+ t.Fatal(err)
+ }
+ runner := &fakeRunner{
+ executable: target,
+ release: Release{
+ TagName: "v2.0.3",
+ Assets: []Asset{{
+ Name: "KrillinAI-cli_2.0.3_macOS_arm64",
+ BrowserDownloadURL: "https://example.test/KrillinAI-cli_2.0.3_macOS_arm64",
+ }},
+ },
+ }
+
+ result, err := Run(context.Background(), Request{
+ Repo: "krillinai/KrillinAI",
+ CurrentVersion: "v2.0.2",
+ Target: target,
+ GOOS: "darwin",
+ GOARCH: "arm64",
+ }, runner)
+ if err != nil {
+ t.Fatalf("Run() error = %v", err)
+ }
+ if !result.Updated {
+ t.Fatal("Updated = false, want true")
+ }
+ if result.Version != "v2.0.3" {
+ t.Fatalf("Version = %q", result.Version)
+ }
+ data, err := os.ReadFile(target)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if string(data) != "new binary" {
+ t.Fatalf("target content = %q", data)
+ }
+ wantDownloads := []string{"https://example.test/KrillinAI-cli_2.0.3_macOS_arm64"}
+ if !reflect.DeepEqual(runner.downloads, wantDownloads) {
+ t.Fatalf("downloads = %#v, want %#v", runner.downloads, wantDownloads)
+ }
+}
+
+func TestRunDownloadsWindowsUpdateBesideExecutable(t *testing.T) {
+ dir := t.TempDir()
+ target := filepath.Join(dir, "krillinai-cli.exe")
+ if err := os.WriteFile(target, []byte("old"), 0755); err != nil {
+ t.Fatal(err)
+ }
+ runner := &fakeRunner{
+ executable: target,
+ release: Release{
+ TagName: "v2.0.3",
+ Assets: []Asset{{
+ Name: "KrillinAI-cli_2.0.3_Windows.exe",
+ BrowserDownloadURL: "https://example.test/KrillinAI-cli_2.0.3_Windows.exe",
+ }},
+ },
+ }
+
+ result, err := Run(context.Background(), Request{
+ Repo: "krillinai/KrillinAI",
+ CurrentVersion: "v2.0.2",
+ Target: target,
+ GOOS: "windows",
+ GOARCH: "amd64",
+ }, runner)
+ if err != nil {
+ t.Fatalf("Run() error = %v", err)
+ }
+ if result.Updated {
+ t.Fatal("Updated = true, want false because Windows requires manual replacement")
+ }
+ if result.Target != target+".download" {
+ t.Fatalf("Target = %q, want downloaded sidecar", result.Target)
+ }
+ data, err := os.ReadFile(target)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if string(data) != "old" {
+ t.Fatalf("original target content = %q, want old", data)
+ }
+ data, err = os.ReadFile(target + ".download")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if string(data) != "new binary" {
+ t.Fatalf("downloaded content = %q", data)
+ }
+}
+
+type fakeRunner struct {
+ executable string
+ release Release
+ downloads []string
+}
+
+func (f *fakeRunner) CurrentExecutable() (string, error) {
+ if f.executable == "" {
+ return "", errors.New("missing executable")
+ }
+ return f.executable, nil
+}
+
+func (f *fakeRunner) FetchRelease(context.Context, string, string) (Release, error) {
+ return f.release, nil
+}
+
+func (f *fakeRunner) DownloadFile(_ context.Context, url, path string) error {
+ f.downloads = append(f.downloads, url)
+ return os.WriteFile(path, []byte("new binary"), 0644)
+}
+
+func (f *fakeRunner) ReplaceExecutable(source, target string) error {
+ return os.Rename(source, target)
+}