Access repos by their ids (#1691)

closes #1295 
closes #648

# TODO
- [x] add new routes with `:repoID`
- [x] load repo in middleware using `:repoID` if present
- [x] update UI routes `:owner/:name` to `:repoID`
- [x] load repos using id in UI
- [x] add lookup endpoint `:owner/:name` to `:repoID`
- [x] redirect `:owner/:name` to `:repoID` in UI
- [x] use badge with `:repoID` route in UI
- [x] update `woodpecker-go`
- [x] check cli
- [x] add migrations / deprecation notes
- [x] check if #648 got solved directly
- [x] Test
  - [x] create repo
  - [x] repo pages
  - [x] ui redirects
  - [x] forge status links

cli/common/flags.go

@@ -70,5 +70,5 @@ func FormatFlag(tmpl string, hidden ...bool) *cli.StringFlag {
 var RepoFlag = &cli.StringFlag{
 	Name:    "repository",
 	Aliases: []string{"repo"},
-	Usage:   "repository name (e.g. octocat/hello-world)",
+	Usage:   "repository id or full-name (e.g. 134 or octocat/hello-world)",
 }

cli/cron/cron_add.go

@@ -14,7 +14,7 @@ import (
 var cronCreateCmd = &cli.Command{
 	Name:      "add",
 	Usage:     "add a cron job",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    cronCreate,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -38,29 +38,32 @@ var cronCreateCmd = &cli.Command{
 
 func cronCreate(c *cli.Context) error {
 	var (
-		jobName  = c.String("name")
-		branch   = c.String("branch")
-		schedule = c.String("schedule")
-		reponame = c.String("repository")
-		format   = c.String("format") + "\n"
+		jobName          = c.String("name")
+		branch           = c.String("branch")
+		schedule         = c.String("schedule")
+		repoIDOrFullName = c.String("repository")
+		format           = c.String("format") + "\n"
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
-	}
-	owner, name, err := internal.ParseRepo(reponame)
-	if err != nil {
-		return err
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
+
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
+
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
+
 	cron := &woodpecker.Cron{
 		Name:     jobName,
 		Branch:   branch,
 		Schedule: schedule,
 	}
-	cron, err = client.CronCreate(owner, name, cron)
+	cron, err = client.CronCreate(repoID, cron)
 	if err != nil {
 		return err
 	}

cli/cron/cron_info.go

@@ -13,7 +13,7 @@ import (
 var cronInfoCmd = &cli.Command{
 	Name:      "info",
 	Usage:     "display info about a cron job",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    cronInfo,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -28,22 +28,23 @@ var cronInfoCmd = &cli.Command{
 
 func cronInfo(c *cli.Context) error {
 	var (
-		jobID    = c.Int64("id")
-		reponame = c.String("repository")
-		format   = c.String("format") + "\n"
+		jobID            = c.Int64("id")
+		repoIDOrFullName = c.String("repository")
+		format           = c.String("format") + "\n"
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
-	}
-	owner, name, err := internal.ParseRepo(reponame)
-	if err != nil {
-		return err
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	cron, err := client.CronGet(owner, name, jobID)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
+
+	cron, err := client.CronGet(repoID, jobID)
 	if err != nil {
 		return err
 	}

cli/cron/cron_list.go

@@ -27,7 +27,7 @@ import (
 var cronListCmd = &cli.Command{
 	Name:      "ls",
 	Usage:     "list cron jobs",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    cronList,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -37,21 +37,21 @@ var cronListCmd = &cli.Command{
 
 func cronList(c *cli.Context) error {
 	var (
-		format   = c.String("format") + "\n"
-		reponame = c.String("repository")
+		format           = c.String("format") + "\n"
+		repoIDOrFullName = c.String("repository")
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
-	}
-	owner, name, err := internal.ParseRepo(reponame)
-	if err != nil {
-		return err
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	list, err := client.CronList(owner, name)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
+	list, err := client.CronList(repoID)
 	if err != nil {
 		return err
 	}

cli/cron/cron_rm.go

@@ -12,7 +12,7 @@ import (
 var cronDeleteCmd = &cli.Command{
 	Name:      "rm",
 	Usage:     "remove a cron job",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    cronDelete,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -26,21 +26,21 @@ var cronDeleteCmd = &cli.Command{
 
 func cronDelete(c *cli.Context) error {
 	var (
-		jobID    = c.Int64("id")
-		reponame = c.String("repository")
+		jobID            = c.Int64("id")
+		repoIDOrFullName = c.String("repository")
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
-	}
-	owner, name, err := internal.ParseRepo(reponame)
-	if err != nil {
-		return err
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	err = client.CronDelete(owner, name, jobID)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
+	err = client.CronDelete(repoID, jobID)
 	if err != nil {
 		return err
 	}

cli/cron/cron_update.go

@@ -14,7 +14,7 @@ import (
 var cronUpdateCmd = &cli.Command{
 	Name:      "update",
 	Usage:     "update a cron job",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    cronUpdate,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -41,21 +41,21 @@ var cronUpdateCmd = &cli.Command{
 
 func cronUpdate(c *cli.Context) error {
 	var (
-		reponame = c.String("repository")
-		jobID    = c.Int64("id")
-		jobName  = c.String("name")
-		branch   = c.String("branch")
-		schedule = c.String("schedule")
-		format   = c.String("format") + "\n"
+		repoIDOrFullName = c.String("repository")
+		jobID            = c.Int64("id")
+		jobName          = c.String("name")
+		branch           = c.String("branch")
+		schedule         = c.String("schedule")
+		format           = c.String("format") + "\n"
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
-	owner, name, err := internal.ParseRepo(reponame)
+	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	client, err := internal.NewClient(c)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -65,7 +65,7 @@ func cronUpdate(c *cli.Context) error {
 		Branch:   branch,
 		Schedule: schedule,
 	}
-	cron, err = client.CronUpdate(owner, name, cron)
+	cron, err = client.CronUpdate(repoID, cron)
 	if err != nil {
 		return err
 	}

cli/deploy/deploy.go

@@ -31,7 +31,7 @@ import (
 var Command = &cli.Command{
 	Name:      "deploy",
 	Usage:     "deploy code",
-	ArgsUsage: "<repo/name> <pipeline> <environment>",
+	ArgsUsage: "<repo-id|repo-full-name> <pipeline> <environment>",
 	Action:    deploy,
 	Flags: append(common.GlobalFlags,
 		common.FormatFlag(tmplDeployInfo),
@@ -59,13 +59,13 @@ var Command = &cli.Command{
 }
 
 func deploy(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
 
-	client, err := internal.NewClient(c)
+	repo := c.Args().First()
+	repoID, err := internal.ParseRepo(client, repo)
 	if err != nil {
 		return err
 	}
@@ -78,7 +78,7 @@ func deploy(c *cli.Context) error {
 	var number int
 	if pipelineArg == "last" {
 		// Fetch the pipeline number from the last pipeline
-		pipelines, berr := client.PipelineList(owner, name)
+		pipelines, berr := client.PipelineList(repoID)
 		if berr != nil {
 			return berr
 		}
@@ -113,7 +113,7 @@ func deploy(c *cli.Context) error {
 
 	params := internal.ParseKeyPair(c.StringSlice("param"))
 
-	deploy, err := client.Deploy(owner, name, number, env, params)
+	deploy, err := client.Deploy(repoID, number, env, params)
 	if err != nil {
 		return err
 	}

cli/internal/util.go

@@ -5,6 +5,7 @@ import (
 	"crypto/x509"
 	"fmt"
 	"net/http"
+	"strconv"
 	"strings"
 
 	"github.com/rs/zerolog/log"
@@ -76,15 +77,16 @@ func NewClient(c *cli.Context) (woodpecker.Client, error) {
 }
 
 // ParseRepo parses the repository owner and name from a string.
-func ParseRepo(str string) (user, repo string, err error) {
-	parts := strings.Split(str, "/")
-	if len(parts) != 2 {
-		err = fmt.Errorf("Error: Invalid or missing repository. eg octocat/hello-world")
-		return
+func ParseRepo(client woodpecker.Client, str string) (repoID int64, err error) {
+	if strings.Contains(str, "/") {
+		repo, err := client.RepoLookup(str)
+		if err != nil {
+			return 0, err
+		}
+		return repo.ID, nil
 	}
-	user = parts[0]
-	repo = parts[1]
-	return
+
+	return strconv.ParseInt(str, 10, 64)
 }
 
 // ParseKeyPair parses a key=value pair.

cli/log/log_purge.go

@@ -27,14 +27,18 @@ import (
 var logPurgeCmd = &cli.Command{
 	Name:      "purge",
 	Usage:     "purge a log",
-	ArgsUsage: "<repo/name> <pipeline>",
+	ArgsUsage: "<repo-id|repo-full-name> <pipeline>",
 	Action:    logPurge,
 	Flags:     common.GlobalFlags,
 }
 
 func logPurge(c *cli.Context) (err error) {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	client, err := internal.NewClient(c)
+	if err != nil {
+		return err
+	}
+	repoIDOrFullName := c.Args().First()
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -43,16 +47,11 @@ func logPurge(c *cli.Context) (err error) {
 		return err
 	}
 
-	client, err := internal.NewClient(c)
+	err = client.LogsPurge(repoID, number)
 	if err != nil {
 		return err
 	}
 
-	err = client.LogsPurge(owner, name, number)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Purging logs for pipeline %s/%s#%d\n", owner, name, number)
+	fmt.Printf("Purging logs for pipeline %s#%d\n", repoIDOrFullName, number)
 	return nil
 }

cli/pipeline/approve.go

@@ -27,14 +27,18 @@ import (
 var pipelineApproveCmd = &cli.Command{
 	Name:      "approve",
 	Usage:     "approve a pipeline",
-	ArgsUsage: "<repo/name> <pipeline>",
+	ArgsUsage: "<repo-id|repo-full-name> <pipeline>",
 	Action:    pipelineApprove,
 	Flags:     common.GlobalFlags,
 }
 
 func pipelineApprove(c *cli.Context) (err error) {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	repoIDOrFullName := c.Args().First()
+	client, err := internal.NewClient(c)
+	if err != nil {
+		return err
+	}
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -43,16 +47,11 @@ func pipelineApprove(c *cli.Context) (err error) {
 		return err
 	}
 
-	client, err := internal.NewClient(c)
+	_, err = client.PipelineApprove(repoID, number)
 	if err != nil {
 		return err
 	}
 
-	_, err = client.PipelineApprove(owner, name, number)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Approving pipeline %s/%s#%d\n", owner, name, number)
+	fmt.Printf("Approving pipeline %s#%d\n", repoIDOrFullName, number)
 	return nil
 }

cli/pipeline/create.go

@@ -30,7 +30,7 @@ import (
 var pipelineCreateCmd = &cli.Command{
 	Name:      "create",
 	Usage:     "create new pipeline",
-	ArgsUsage: "<repo/name>",
+	ArgsUsage: "<repo-id|repo-full-name>",
 	Action:    pipelineCreate,
 	Flags: append(common.GlobalFlags,
 		common.FormatFlag(tmplPipelineList),
@@ -47,14 +47,12 @@ var pipelineCreateCmd = &cli.Command{
 }
 
 func pipelineCreate(c *cli.Context) error {
-	repo := c.Args().First()
-
-	owner, name, err := internal.ParseRepo(repo)
+	repoIDOrFullName := c.Args().First()
+	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-
-	client, err := internal.NewClient(c)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -74,7 +72,7 @@ func pipelineCreate(c *cli.Context) error {
 		Variables: variables,
 	}
 
-	pipeline, err := client.PipelineCreate(owner, name, options)
+	pipeline, err := client.PipelineCreate(repoID, options)
 	if err != nil {
 		return err
 	}

cli/pipeline/decline.go

@@ -27,32 +27,32 @@ import (
 var pipelineDeclineCmd = &cli.Command{
 	Name:      "decline",
 	Usage:     "decline a pipeline",
-	ArgsUsage: "<repo/name> <pipeline>",
+	ArgsUsage: "<repo-id|repo-full-name> <pipeline>",
 	Action:    pipelineDecline,
 	Flags:     common.GlobalFlags,
 }
 
 func pipelineDecline(c *cli.Context) (err error) {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	repoIDOrFullName := c.Args().First()
+	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
+
 	number, err := strconv.Atoi(c.Args().Get(1))
 	if err != nil {
 		return err
 	}
 
-	client, err := internal.NewClient(c)
+	_, err = client.PipelineDecline(repoID, number)
 	if err != nil {
 		return err
 	}
 
-	_, err = client.PipelineDecline(owner, name, number)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Declining pipeline %s/%s#%d\n", owner, name, number)
+	fmt.Printf("Declining pipeline %s#%d\n", repoIDOrFullName, number)
 	return nil
 }

cli/pipeline/info.go

@@ -28,7 +28,7 @@ import (
 var pipelineInfoCmd = &cli.Command{
 	Name:      "info",
 	Usage:     "show pipeline details",
-	ArgsUsage: "<repo/name> [pipeline]",
+	ArgsUsage: "<repo-id|repo-full-name> [pipeline]",
 	Action:    pipelineInfo,
 	Flags: append(common.GlobalFlags,
 		common.FormatFlag(tmplPipelineInfo),
@@ -36,22 +36,21 @@ var pipelineInfoCmd = &cli.Command{
 }
 
 func pipelineInfo(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	repoIDOrFullName := c.Args().First()
+	client, err := internal.NewClient(c)
+	if err != nil {
+		return err
+	}
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
 	pipelineArg := c.Args().Get(1)
 
-	client, err := internal.NewClient(c)
-	if err != nil {
-		return err
-	}
-
 	var number int
 	if pipelineArg == "last" || len(pipelineArg) == 0 {
 		// Fetch the pipeline number from the last pipeline
-		pipeline, err := client.PipelineLast(owner, name, "")
+		pipeline, err := client.PipelineLast(repoID, "")
 		if err != nil {
 			return err
 		}
@@ -63,7 +62,7 @@ func pipelineInfo(c *cli.Context) error {
 		}
 	}
 
-	pipeline, err := client.Pipeline(owner, name, number)
+	pipeline, err := client.Pipeline(repoID, number)
 	if err != nil {
 		return err
 	}

cli/pipeline/kill.go

@@ -27,33 +27,33 @@ import (
 var pipelineKillCmd = &cli.Command{
 	Name:      "kill",
 	Usage:     "force kill a pipeline",
-	ArgsUsage: "<repo/name> <pipeline>",
+	ArgsUsage: "<repo-id|repo-full-name> <pipeline>",
 	Action:    pipelineKill,
 	Hidden:    true,
 	Flags:     common.GlobalFlags,
 }
 
 func pipelineKill(c *cli.Context) (err error) {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
-	if err != nil {
-		return err
-	}
 	number, err := strconv.Atoi(c.Args().Get(1))
 	if err != nil {
 		return err
 	}
 
+	repoIDOrFullName := c.Args().First()
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-
-	err = client.PipelineKill(owner, name, number)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
 
-	fmt.Printf("Force killing pipeline %s/%s#%d\n", owner, name, number)
+	err = client.PipelineKill(repoID, number)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Force killing pipeline %s#%d\n", repoIDOrFullName, number)
 	return nil
 }

cli/pipeline/last.go

@@ -27,7 +27,7 @@ import (
 var pipelineLastCmd = &cli.Command{
 	Name:      "last",
 	Usage:     "show latest pipeline details",
-	ArgsUsage: "<repo/name>",
+	ArgsUsage: "<repo-id|repo-full-name>",
 	Action:    pipelineLast,
 	Flags: append(common.GlobalFlags,
 		common.FormatFlag(tmplPipelineInfo),
@@ -40,18 +40,17 @@ var pipelineLastCmd = &cli.Command{
 }
 
 func pipelineLast(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
-	if err != nil {
-		return err
-	}
-
+	repoIDOrFullName := c.Args().First()
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
 
-	pipeline, err := client.PipelineLast(owner, name, c.String("branch"))
+	pipeline, err := client.PipelineLast(repoID, c.String("branch"))
 	if err != nil {
 		return err
 	}

cli/pipeline/list.go

@@ -27,7 +27,7 @@ import (
 var pipelineListCmd = &cli.Command{
 	Name:      "ls",
 	Usage:     "show pipeline history",
-	ArgsUsage: "<repo/name>",
+	ArgsUsage: "<repo-id|repo-full-name>",
 	Action:    pipelineList,
 	Flags: append(common.GlobalFlags,
 		common.FormatFlag(tmplPipelineList),
@@ -52,18 +52,17 @@ var pipelineListCmd = &cli.Command{
 }
 
 func pipelineList(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
-	if err != nil {
-		return err
-	}
-
+	repoIDOrFullName := c.Args().First()
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
 
-	pipelines, err := client.PipelineList(owner, name)
+	pipelines, err := client.PipelineList(repoID)
 	if err != nil {
 		return err
 	}
@@ -101,7 +100,7 @@ func pipelineList(c *cli.Context) error {
 }
 
 // template for pipeline list information
-var tmplPipelineList = "\x1b[33mBuild #{{ .Number }} \x1b[0m" + `
+var tmplPipelineList = "\x1b[33mPipeline #{{ .Number }} \x1b[0m" + `
 Status: {{ .Status }}
 Event: {{ .Event }}
 Commit: {{ .Commit }}

cli/pipeline/logs.go

@@ -27,14 +27,18 @@ import (
 var pipelineLogsCmd = &cli.Command{
 	Name:      "logs",
 	Usage:     "show pipeline logs",
-	ArgsUsage: "<repo/name> [pipeline] [stepID]",
+	ArgsUsage: "<repo-id|repo-full-name> [pipeline] [stepID]",
 	Action:    pipelineLogs,
 	Flags:     common.GlobalFlags,
 }
 
 func pipelineLogs(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	repoIDOrFullName := c.Args().First()
+	client, err := internal.NewClient(c)
+	if err != nil {
+		return err
+	}
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -49,12 +53,7 @@ func pipelineLogs(c *cli.Context) error {
 		return err
 	}
 
-	client, err := internal.NewClient(c)
-	if err != nil {
-		return err
-	}
-
-	logs, err := client.StepLogEntries(owner, name, number, step)
+	logs, err := client.StepLogEntries(repoID, number, step)
 	if err != nil {
 		return err
 	}

cli/pipeline/ps.go

@@ -28,7 +28,7 @@ import (
 var pipelinePsCmd = &cli.Command{
 	Name:      "ps",
 	Usage:     "show pipeline steps",
-	ArgsUsage: "<repo/name> [pipeline]",
+	ArgsUsage: "<repo-id|repo-full-name> [pipeline]",
 	Action:    pipelinePs,
 	Flags: append(common.GlobalFlags,
 		common.FormatFlag(tmplPipelinePs),
@@ -36,14 +36,12 @@ var pipelinePsCmd = &cli.Command{
 }
 
 func pipelinePs(c *cli.Context) error {
-	repo := c.Args().First()
-
-	owner, name, err := internal.ParseRepo(repo)
+	repoIDOrFullName := c.Args().First()
+	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-
-	client, err := internal.NewClient(c)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -53,7 +51,7 @@ func pipelinePs(c *cli.Context) error {
 
 	if pipelineArg == "last" || len(pipelineArg) == 0 {
 		// Fetch the pipeline number from the last pipeline
-		pipeline, err := client.PipelineLast(owner, name, "")
+		pipeline, err := client.PipelineLast(repoID, "")
 		if err != nil {
 			return err
 		}
@@ -66,7 +64,7 @@ func pipelinePs(c *cli.Context) error {
 		}
 	}
 
-	pipeline, err := client.Pipeline(owner, name, number)
+	pipeline, err := client.Pipeline(repoID, number)
 	if err != nil {
 		return err
 	}

cli/pipeline/start.go

@@ -28,7 +28,7 @@ import (
 var pipelineStartCmd = &cli.Command{
 	Name:      "start",
 	Usage:     "start a pipeline",
-	ArgsUsage: "<repo/name> [pipeline]",
+	ArgsUsage: "<repo-id|repo-full-name> [pipeline]",
 	Action:    pipelineStart,
 	Flags: append(common.GlobalFlags,
 		&cli.StringSliceFlag{
@@ -40,13 +40,12 @@ var pipelineStartCmd = &cli.Command{
 }
 
 func pipelineStart(c *cli.Context) (err error) {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	repoIDOrFullName := c.Args().First()
+	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-
-	client, err := internal.NewClient(c)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -55,7 +54,7 @@ func pipelineStart(c *cli.Context) (err error) {
 	var number int
 	if pipelineArg == "last" {
 		// Fetch the pipeline number from the last pipeline
-		pipeline, err := client.PipelineLast(owner, name, "")
+		pipeline, err := client.PipelineLast(repoID, "")
 		if err != nil {
 			return err
 		}
@@ -72,11 +71,11 @@ func pipelineStart(c *cli.Context) (err error) {
 
 	params := internal.ParseKeyPair(c.StringSlice("param"))
 
-	pipeline, err := client.PipelineStart(owner, name, number, params)
+	pipeline, err := client.PipelineStart(repoID, number, params)
 	if err != nil {
 		return err
 	}
 
-	fmt.Printf("Starting pipeline %s/%s#%d\n", owner, name, pipeline.Number)
+	fmt.Printf("Starting pipeline %s#%d\n", repoIDOrFullName, pipeline.Number)
 	return nil
 }

cli/pipeline/stop.go

@@ -27,14 +27,18 @@ import (
 var pipelineStopCmd = &cli.Command{
 	Name:      "stop",
 	Usage:     "stop a pipeline",
-	ArgsUsage: "<repo/name> [pipeline]",
+	ArgsUsage: "<repo-id|repo-full-name> [pipeline]",
 	Flags:     common.GlobalFlags,
 	Action:    pipelineStop,
 }
 
 func pipelineStop(c *cli.Context) (err error) {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	repoIDOrFullName := c.Args().First()
+	client, err := internal.NewClient(c)
+	if err != nil {
+		return err
+	}
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -43,16 +47,11 @@ func pipelineStop(c *cli.Context) (err error) {
 		return err
 	}
 
-	client, err := internal.NewClient(c)
+	err = client.PipelineStop(repoID, number)
 	if err != nil {
 		return err
 	}
 
-	err = client.PipelineStop(owner, name, number)
-	if err != nil {
-		return err
-	}
-
-	fmt.Printf("Stopping pipeline %s/%s#%d\n", owner, name, number)
+	fmt.Printf("Stopping pipeline %s#%d\n", repoIDOrFullName, number)
 	return nil
 }

cli/registry/registry_add.go

@@ -14,7 +14,7 @@ import (
 var registryCreateCmd = &cli.Command{
 	Name:      "add",
 	Usage:     "adds a registry",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    registryCreate,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -36,19 +36,19 @@ var registryCreateCmd = &cli.Command{
 
 func registryCreate(c *cli.Context) error {
 	var (
-		hostname = c.String("hostname")
-		username = c.String("username")
-		password = c.String("password")
-		reponame = c.String("repository")
+		hostname         = c.String("hostname")
+		username         = c.String("username")
+		password         = c.String("password")
+		repoIDOrFullName = c.String("repository")
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
-	owner, name, err := internal.ParseRepo(reponame)
+	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	client, err := internal.NewClient(c)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -65,7 +65,7 @@ func registryCreate(c *cli.Context) error {
 		}
 		registry.Password = string(out)
 	}
-	_, err = client.RegistryCreate(owner, name, registry)
+	_, err = client.RegistryCreate(repoID, registry)
 	if err != nil {
 		return err
 	}

cli/registry/registry_info.go

@@ -13,7 +13,7 @@ import (
 var registryInfoCmd = &cli.Command{
 	Name:      "info",
 	Usage:     "display registry info",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    registryInfo,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -28,22 +28,22 @@ var registryInfoCmd = &cli.Command{
 
 func registryInfo(c *cli.Context) error {
 	var (
-		hostname = c.String("hostname")
-		reponame = c.String("repository")
-		format   = c.String("format") + "\n"
+		hostname         = c.String("hostname")
+		repoIDOrFullName = c.String("repository")
+		format           = c.String("format") + "\n"
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
-	}
-	owner, name, err := internal.ParseRepo(reponame)
-	if err != nil {
-		return err
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	registry, err := client.Registry(owner, name, hostname)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
+	registry, err := client.Registry(repoID, hostname)
 	if err != nil {
 		return err
 	}

cli/registry/registry_list.go

@@ -27,7 +27,7 @@ import (
 var registryListCmd = &cli.Command{
 	Name:      "ls",
 	Usage:     "list registries",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    registryList,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -37,21 +37,21 @@ var registryListCmd = &cli.Command{
 
 func registryList(c *cli.Context) error {
 	var (
-		format   = c.String("format") + "\n"
-		reponame = c.String("repository")
+		format           = c.String("format") + "\n"
+		repoIDOrFullName = c.String("repository")
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
-	}
-	owner, name, err := internal.ParseRepo(reponame)
-	if err != nil {
-		return err
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	list, err := client.RegistryList(owner, name)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
+	list, err := client.RegistryList(repoID)
 	if err != nil {
 		return err
 	}

cli/registry/registry_rm.go

@@ -10,7 +10,7 @@ import (
 var registryDeleteCmd = &cli.Command{
 	Name:      "rm",
 	Usage:     "remove a registry",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    registryDelete,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -24,19 +24,19 @@ var registryDeleteCmd = &cli.Command{
 
 func registryDelete(c *cli.Context) error {
 	var (
-		hostname = c.String("hostname")
-		reponame = c.String("repository")
+		hostname         = c.String("hostname")
+		repoIDOrFullName = c.String("repository")
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
-	}
-	owner, name, err := internal.ParseRepo(reponame)
-	if err != nil {
-		return err
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	return client.RegistryDelete(owner, name, hostname)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
+	return client.RegistryDelete(repoID, hostname)
 }

cli/registry/registry_set.go

@@ -14,7 +14,7 @@ import (
 var registryUpdateCmd = &cli.Command{
 	Name:      "update",
 	Usage:     "update a registry",
-	ArgsUsage: "[repo/name]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    registryUpdate,
 	Flags: append(common.GlobalFlags,
 		common.RepoFlag,
@@ -36,19 +36,19 @@ var registryUpdateCmd = &cli.Command{
 
 func registryUpdate(c *cli.Context) error {
 	var (
-		hostname = c.String("hostname")
-		username = c.String("username")
-		password = c.String("password")
-		reponame = c.String("repository")
+		hostname         = c.String("hostname")
+		username         = c.String("username")
+		password         = c.String("password")
+		repoIDOrFullName = c.String("repository")
 	)
-	if reponame == "" {
-		reponame = c.Args().First()
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
 	}
-	owner, name, err := internal.ParseRepo(reponame)
+	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	client, err := internal.NewClient(c)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -65,9 +65,6 @@ func registryUpdate(c *cli.Context) error {
 		}
 		registry.Password = string(out)
 	}
-	_, err = client.RegistryUpdate(owner, name, registry)
-	if err != nil {
-		return err
-	}
-	return nil
+	_, err = client.RegistryUpdate(repoID, registry)
+	return err
 }

cli/repo/repo_add.go

@@ -2,6 +2,7 @@ package repo
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/urfave/cli/v2"
 
@@ -12,16 +13,16 @@ import (
 var repoAddCmd = &cli.Command{
 	Name:      "add",
 	Usage:     "add a repository",
-	ArgsUsage: "<repo/name>",
+	ArgsUsage: "<forge-remote-id>",
 	Action:    repoAdd,
 	Flags:     common.GlobalFlags,
 }
 
 func repoAdd(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	_forgeRemoteID := c.Args().First()
+	forgeRemoteID, err := strconv.Atoi(_forgeRemoteID)
 	if err != nil {
-		return err
+		return fmt.Errorf("invalid forge remote id: %s", _forgeRemoteID)
 	}
 
 	client, err := internal.NewClient(c)
@@ -29,9 +30,11 @@ func repoAdd(c *cli.Context) error {
 		return err
 	}
 
-	if _, err := client.RepoPost(owner, name); err != nil {
+	repo, err := client.RepoPost(int64(forgeRemoteID))
+	if err != nil {
 		return err
 	}
-	fmt.Printf("Successfully activated repository %s/%s\n", owner, name)
+
+	fmt.Printf("Successfully activated repository with forge remote %s\n", repo.FullName)
 	return nil
 }

cli/repo/repo_chown.go

@@ -12,26 +12,27 @@ import (
 var repoChownCmd = &cli.Command{
 	Name:      "chown",
 	Usage:     "assume ownership of a repository",
-	ArgsUsage: "<repo/name>",
+	ArgsUsage: "<repo-id|repo-full-name>",
 	Action:    repoChown,
 	Flags:     common.GlobalFlags,
 }
 
 func repoChown(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
-	if err != nil {
-		return err
-	}
-
+	repoIDOrFullName := c.Args().First()
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-
-	if _, err := client.RepoChown(owner, name); err != nil {
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
 		return err
 	}
-	fmt.Printf("Successfully assumed ownership of repository %s/%s\n", owner, name)
+
+	repo, err := client.RepoChown(repoID)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Successfully assumed ownership of repository %s\n", repo.FullName)
 	return nil
 }

cli/repo/repo_info.go

@@ -13,7 +13,7 @@ import (
 var repoInfoCmd = &cli.Command{
 	Name:      "info",
 	Usage:     "show repository details",
-	ArgsUsage: "<repo/name>",
+	ArgsUsage: "<repo-id|repo-full-name>",
 	Action:    repoInfo,
 	Flags: append(common.GlobalFlags,
 		common.FormatFlag(tmplRepoInfo),
@@ -21,18 +21,17 @@ var repoInfoCmd = &cli.Command{
 }
 
 func repoInfo(c *cli.Context) error {
-	arg := c.Args().First()
-	owner, name, err := internal.ParseRepo(arg)
-	if err != nil {
-		return err
-	}
-
+	repoIDOrFullName := c.Args().First()
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
 
-	repo, err := client.Repo(owner, name)
+	repo, err := client.Repo(repoID)
 	if err != nil {
 		return err
 	}
@@ -47,11 +46,12 @@ func repoInfo(c *cli.Context) error {
 // template for repo information
 var tmplRepoInfo = `Owner: {{ .Owner }}
 Repo: {{ .Name }}
-Type: {{ .Kind }}
-Config: {{ .Config }}
+Link: {{ .Link }}
+Config path: {{ .Config }}
 Visibility: {{ .Visibility }}
 Private: {{ .IsSCMPrivate }}
 Trusted: {{ .IsTrusted }}
 Gated: {{ .IsGated }}
-Forge: {{ .Clone }}
+Clone url: {{ .Clone }}
+Allow pull-requests: {{ .AllowPullRequests }}
 `

cli/repo/repo_list.go

@@ -53,4 +53,4 @@ func repoList(c *cli.Context) error {
 }
 
 // template for repository list items
-var tmplRepoList = `{{ .FullName }}`
+var tmplRepoList = "\x1b[33m{{ .FullName }}\x1b[0m (id: {{ .ID }})"

cli/repo/repo_repair.go

@@ -1,6 +1,8 @@
 package repo
 
 import (
+	"fmt"
+
 	"github.com/urfave/cli/v2"
 
 	"github.com/woodpecker-ci/woodpecker/cli/common"
@@ -10,20 +12,26 @@ import (
 var repoRepairCmd = &cli.Command{
 	Name:      "repair",
 	Usage:     "repair repository webhooks",
-	ArgsUsage: "<repo/name>",
+	ArgsUsage: "<repo-id|repo-full-name>",
 	Action:    repoRepair,
 	Flags:     common.GlobalFlags,
 }
 
 func repoRepair(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
-	if err != nil {
-		return err
-	}
+	repoIDOrFullName := c.Args().First()
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-	return client.RepoRepair(owner, name)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
+		return err
+	}
+
+	if err := client.RepoRepair(repoID); err != nil {
+		return err
+	}
+
+	fmt.Printf("Successfully removed repository %s\n", repoIDOrFullName)
+	return nil
 }

cli/repo/repo_rm.go

@@ -12,26 +12,25 @@ import (
 var repoRemoveCmd = &cli.Command{
 	Name:      "rm",
 	Usage:     "remove a repository",
-	ArgsUsage: "<repo/name>",
+	ArgsUsage: "<repo-id|repo-full-name>",
 	Action:    repoRemove,
 	Flags:     common.GlobalFlags,
 }
 
 func repoRemove(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
-	if err != nil {
-		return err
-	}
-
+	repoIDOrFullName := c.Args().First()
 	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-
-	if err := client.RepoDel(owner, name); err != nil {
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
+	if err != nil {
 		return err
 	}
-	fmt.Printf("Successfully removed repository %s/%s\n", owner, name)
+
+	if err := client.RepoDel(repoID); err != nil {
+		return err
+	}
+	fmt.Printf("Successfully removed repository %s\n", repoIDOrFullName)
 	return nil
 }

cli/repo/repo_sync.go

@@ -20,6 +20,7 @@ var repoSyncCmd = &cli.Command{
 	),
 }
 
+// TODO: remove this and add an option to the list cmd as we do not store the remote repo list anymore
 func repoSync(c *cli.Context) error {
 	client, err := internal.NewClient(c)
 	if err != nil {

cli/repo/repo_update.go

@@ -28,7 +28,7 @@ import (
 var repoUpdateCmd = &cli.Command{
 	Name:      "update",
 	Usage:     "update a repository",
-	ArgsUsage: "<repo/name>",
+	ArgsUsage: "<repo-id|repo-full-name>",
 	Action:    repoUpdate,
 	Flags: append(common.GlobalFlags,
 		&cli.BoolFlag{
@@ -63,13 +63,12 @@ var repoUpdateCmd = &cli.Command{
 }
 
 func repoUpdate(c *cli.Context) error {
-	repo := c.Args().First()
-	owner, name, err := internal.ParseRepo(repo)
+	repoIDOrFullName := c.Args().First()
+	client, err := internal.NewClient(c)
 	if err != nil {
 		return err
 	}
-
-	client, err := internal.NewClient(c)
+	repoID, err := internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
 		return err
 	}
@@ -111,9 +110,11 @@ func repoUpdate(c *cli.Context) error {
 		patch.PipelineCounter = &pipelineCounter
 	}
 
-	if _, err := client.RepoPatch(owner, name, patch); err != nil {
+	repo, err := client.RepoPatch(repoID, patch)
+	if err != nil {
 		return err
 	}
-	fmt.Printf("Successfully updated repository %s/%s\n", owner, name)
+
+	fmt.Printf("Successfully updated repository %s\n", repo.FullName)
 	return nil
 }

cli/secret/secret.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/woodpecker-ci/woodpecker/cli/common"
 	"github.com/woodpecker-ci/woodpecker/cli/internal"
+	"github.com/woodpecker-ci/woodpecker/woodpecker-go/woodpecker"
 )
 
 // Command exports the secret command.
@@ -23,24 +24,29 @@ var Command = &cli.Command{
 	},
 }
 
-func parseTargetArgs(c *cli.Context) (global bool, owner, name string, err error) {
+func parseTargetArgs(client woodpecker.Client, c *cli.Context) (global bool, owner string, repoID int64, err error) {
 	if c.Bool("global") {
-		return true, "", "", nil
+		return true, "", -1, nil
 	}
+
+	repoIDOrFullName := c.String("repository")
+	if repoIDOrFullName == "" {
+		repoIDOrFullName = c.Args().First()
+	}
+
 	orgName := c.String("organization")
-	repoName := c.String("repository")
-	if orgName == "" && repoName == "" {
-		repoName = c.Args().First()
+	if orgName != "" && repoIDOrFullName == "" {
+		return false, orgName, -1, err
 	}
-	if orgName == "" && !strings.Contains(repoName, "/") {
-		orgName = repoName
+
+	if orgName != "" && !strings.Contains(repoIDOrFullName, "/") {
+		repoIDOrFullName = orgName + "/" + repoIDOrFullName
 	}
-	if orgName != "" {
-		return false, orgName, "", err
-	}
-	owner, name, err = internal.ParseRepo(repoName)
+
+	repoID, err = internal.ParseRepo(client, repoIDOrFullName)
 	if err != nil {
-		return false, "", "", err
+		return false, "", -1, err
 	}
-	return false, owner, name, nil
+
+	return false, "", repoID, nil
 }

cli/secret/secret_add.go

@@ -14,7 +14,7 @@ import (
 var secretCreateCmd = &cli.Command{
 	Name:      "add",
 	Usage:     "adds a secret",
-	ArgsUsage: "[org/repo|org]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    secretCreate,
 	Flags: append(common.GlobalFlags,
 		&cli.BoolFlag{
@@ -74,7 +74,7 @@ func secretCreate(c *cli.Context) error {
 		secret.Value = string(out)
 	}
 
-	global, owner, repo, err := parseTargetArgs(c)
+	global, owner, repoID, err := parseTargetArgs(client, c)
 	if err != nil {
 		return err
 	}
@@ -83,11 +83,11 @@ func secretCreate(c *cli.Context) error {
 		_, err = client.GlobalSecretCreate(secret)
 		return err
 	}
-	if repo == "" {
+	if owner != "" {
 		_, err = client.OrgSecretCreate(owner, secret)
 		return err
 	}
-	_, err = client.SecretCreate(owner, repo, secret)
+	_, err = client.SecretCreate(repoID, secret)
 	return err
 }
 

cli/secret/secret_info.go

@@ -14,7 +14,7 @@ import (
 var secretInfoCmd = &cli.Command{
 	Name:      "info",
 	Usage:     "display secret info",
-	ArgsUsage: "[org/repo|org]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    secretInfo,
 	Flags: append(common.GlobalFlags,
 		&cli.BoolFlag{
@@ -44,7 +44,7 @@ func secretInfo(c *cli.Context) error {
 		return err
 	}
 
-	global, owner, repo, err := parseTargetArgs(c)
+	global, owner, repoID, err := parseTargetArgs(client, c)
 	if err != nil {
 		return err
 	}
@@ -55,13 +55,13 @@ func secretInfo(c *cli.Context) error {
 		if err != nil {
 			return err
 		}
-	} else if repo == "" {
+	} else if owner != "" {
 		secret, err = client.OrgSecret(owner, secretName)
 		if err != nil {
 			return err
 		}
 	} else {
-		secret, err = client.Secret(owner, repo, secretName)
+		secret, err = client.Secret(repoID, secretName)
 		if err != nil {
 			return err
 		}

cli/secret/secret_list.go

@@ -15,7 +15,7 @@ import (
 var secretListCmd = &cli.Command{
 	Name:      "ls",
 	Usage:     "list secrets",
-	ArgsUsage: "[org/name|org]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    secretList,
 	Flags: append(common.GlobalFlags,
 		&cli.BoolFlag{
@@ -39,7 +39,7 @@ func secretList(c *cli.Context) error {
 		return err
 	}
 
-	global, owner, repo, err := parseTargetArgs(c)
+	global, owner, repoID, err := parseTargetArgs(client, c)
 	if err != nil {
 		return err
 	}
@@ -50,13 +50,13 @@ func secretList(c *cli.Context) error {
 		if err != nil {
 			return err
 		}
-	} else if repo == "" {
+	} else if owner != "" {
 		list, err = client.OrgSecretList(owner)
 		if err != nil {
 			return err
 		}
 	} else {
-		list, err = client.SecretList(owner, repo)
+		list, err = client.SecretList(repoID)
 		if err != nil {
 			return err
 		}

cli/secret/secret_rm.go

@@ -10,7 +10,7 @@ import (
 var secretDeleteCmd = &cli.Command{
 	Name:      "rm",
 	Usage:     "remove a secret",
-	ArgsUsage: "[org/repo|org]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    secretDelete,
 	Flags: append(common.GlobalFlags,
 		&cli.BoolFlag{
@@ -37,7 +37,7 @@ func secretDelete(c *cli.Context) error {
 		return err
 	}
 
-	global, owner, repo, err := parseTargetArgs(c)
+	global, owner, repoID, err := parseTargetArgs(client, c)
 	if err != nil {
 		return err
 	}
@@ -45,8 +45,8 @@ func secretDelete(c *cli.Context) error {
 	if global {
 		return client.GlobalSecretDelete(secretName)
 	}
-	if repo == "" {
+	if owner != "" {
 		return client.OrgSecretDelete(owner, secretName)
 	}
-	return client.SecretDelete(owner, repo, secretName)
+	return client.SecretDelete(repoID, secretName)
 }

cli/secret/secret_set.go

@@ -14,7 +14,7 @@ import (
 var secretUpdateCmd = &cli.Command{
 	Name:      "update",
 	Usage:     "update a secret",
-	ArgsUsage: "[org/repo|org]",
+	ArgsUsage: "[repo-id|repo-full-name]",
 	Action:    secretUpdate,
 	Flags: append(common.GlobalFlags,
 		&cli.BoolFlag{
@@ -71,7 +71,7 @@ func secretUpdate(c *cli.Context) error {
 		secret.Value = string(out)
 	}
 
-	global, owner, repo, err := parseTargetArgs(c)
+	global, owner, repoID, err := parseTargetArgs(client, c)
 	if err != nil {
 		return err
 	}
@@ -80,10 +80,10 @@ func secretUpdate(c *cli.Context) error {
 		_, err = client.GlobalSecretUpdate(secret)
 		return err
 	}
-	if repo == "" {
+	if owner != "" {
 		_, err = client.OrgSecretUpdate(owner, secret)
 		return err
 	}
-	_, err = client.SecretUpdate(owner, repo, secret)
+	_, err = client.SecretUpdate(repoID, secret)
 	return err
 }