mugit @ d00a3f1ada9adfc98d435b4417f4a271db92ee0c

···
        113
        113
         							&cli.StringArg{Name: "name"},

      
        114
        114
         						},

      
        115
        115
         					},

      
        
        116
        +					{

      
        
        117
        +						Name:   "sync",

      
        
        118
        +						Usage:  "trigger sync for a mirror repository",

      
        
        119
        +						Action: c.repoSyncAction,

      
        
        120
        +						Arguments: []cli.Argument{

      
        
        121
        +							&cli.StringArg{Name: "name"},

      
        
        122
        +						},

      
        
        123
        +					},

      
        116
        124
         				},

      
        117
        125
         			},

      
        118
        126
         			{

      

···
        50
        50
         		if err := repo.SetMirrorRemote(mirrorURL); err != nil {

      
        51
        51
         			return fmt.Errorf("failed to set mirror remote: %w", err)

      
        52
        52
         		}

      
        
        53
        +

      
        
        54
        +		slog.Info("performing initial sync for mirror", "repo", name)

      
        
        55
        +		if err := c.syncRepo(ctx, name); err != nil {

      
        
        56
        +			return err

      
        
        57
        +		}

      
        
        58
        +		slog.Info("initial mirror sync completed", "repo", name)

      
        53
        59
         	}

      
        54
        60
         

      
        55
        61
         	desc := cmd.String("description")

      ···
        141
        147
         	return err

      
        142
        148
         }

      
        143
        149
         

      
        
        150
        +func (c *Cli) repoSyncAction(ctx context.Context, cmd *cli.Command) error {

      
        
        151
        +	name, err := c.getRepoNameArg(cmd)

      
        
        152
        +	if name == "" {

      
        
        153
        +		return err

      
        
        154
        +	}

      
        
        155
        +

      
        
        156
        +	repo, err := c.openRepo(name)

      
        
        157
        +	if err != nil {

      
        
        158
        +		return fmt.Errorf("failed to open repo: %w", err)

      
        
        159
        +	}

      
        
        160
        +

      
        
        161
        +	isMirror, err := repo.IsMirror()

      
        
        162
        +	if err != nil {

      
        
        163
        +		return fmt.Errorf("failed to check mirror status: %w", err)

      
        
        164
        +	}

      
        
        165
        +	if !isMirror {

      
        
        166
        +		return fmt.Errorf("repository is not a mirror: %s", name)

      
        
        167
        +	}

      
        
        168
        +

      
        
        169
        +	if err := c.syncRepo(ctx, name); err != nil {

      
        
        170
        +		return err

      
        
        171
        +	}

      
        
        172
        +

      
        
        173
        +	slog.Info("mirror sync triggered", "repo", name)

      
        
        174
        +	return nil

      
        
        175
        +}

      
        
        176
        +

      
        144
        177
         func (c *Cli) getRepoNameArg(cmd *cli.Command) (string, error) {

      
        145
        178
         	name := cmd.StringArg("name")

      
        146
        179
         	if name == "" {

      ···
        148
        181
         	}

      
        149
        182
         	return git.ResolveName(name), nil

      
        150
        183
         }

      
        
        184
        +

      
        
        185
        +func (c *Cli) syncRepo(ctx context.Context, name string) error {

      
        
        186
        +	worker := mirror.NewWorker(c.cfg)

      
        
        187
        +	if err := worker.SyncRepo(ctx, name); err != nil {

      
        
        188
        +		return fmt.Errorf("failed to sync mirror: %w", err)

      
        
        189
        +	}

      
        
        190
        +	return nil

      
        
        191
        +}

      

···
        55
        55
         	}

      
        56
        56
         }

      
        57
        57
         

      
        
        58
        +func (w *Worker) SyncRepo(ctx context.Context, name string) error {

      
        
        59
        +	path, err := git.ResolvePath(w.c.Repo.Dir, git.ResolveName(name))

      
        
        60
        +	if err != nil {

      
        
        61
        +		return fmt.Errorf("failed to resolve repo path: %w", err)

      
        
        62
        +	}

      
        
        63
        +

      
        
        64
        +	repo, err := git.Open(path, "")

      
        
        65
        +	if err != nil {

      
        
        66
        +		return fmt.Errorf("failed to open repo: %w", err)

      
        
        67
        +	}

      
        
        68
        +

      
        
        69
        +	isMirror, err := repo.IsMirror()

      
        
        70
        +	if err != nil {

      
        
        71
        +		return fmt.Errorf("failed to check mirror status: %w", err)

      
        
        72
        +	}

      
        
        73
        +	if !isMirror {

      
        
        74
        +		return fmt.Errorf("repository is not a mirror")

      
        
        75
        +	}

      
        
        76
        +

      
        
        77
        +	return w.syncRepo(ctx, repo)

      
        
        78
        +}

      
        
        79
        +

      
        58
        80
         func (w *Worker) mirror(ctx context.Context) error {

      
        59
        81
         	repos, err := w.findMirrorRepos()

      
        60
        82
         	if err != nil {