feat(publish): add tenant publish management with desktop deep-link

Expose tenant-authenticated publish task list and retry endpoints so the
admin web can show desktop publish state without an Electron bridge, and
register a `shengxintui://` deep-link so the page can hand off to the
desktop client workbench.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

server/internal/tenant/app/desktop_task_service.go

@@ -141,6 +141,12 @@ type DesktopPublishTaskList struct {
 	HistoryTotal int               `json:"history_total"`
 }
 
+type publishTaskListOwner struct {
+	TenantID    int64
+	WorkspaceID int64
+	UserID      int64
+}
+
 func (s *DesktopTaskService) Lease(ctx context.Context, client *repository.DesktopClient, req LeaseDesktopTaskRequest, routeTaskID *uuid.UUID) (*LeaseDesktopTaskResponse, error) {
 	if client == nil {
 		return nil, response.ErrUnauthorized(40108, "desktop_client_missing", "desktop client context is required")
@@ -858,6 +864,26 @@ func (s *DesktopTaskService) ListPublishTasks(ctx context.Context, client *repos
 	if client == nil {
 		return nil, response.ErrUnauthorized(40108, "desktop_client_missing", "desktop client context is required")
 	}
+	return s.listPublishTasksForOwner(ctx, publishTaskListOwner{
+		TenantID:    client.TenantID,
+		WorkspaceID: client.WorkspaceID,
+		UserID:      client.UserID,
+	}, req)
+}
+
+func (s *DesktopTaskService) ListTenantPublishTasks(ctx context.Context, actor auth.Actor, req ListPublishTasksRequest) (*DesktopPublishTaskList, error) {
+	workspaceID := auth.CurrentWorkspaceID(ctx)
+	if actor.TenantID == 0 || actor.UserID == 0 || workspaceID == 0 {
+		return nil, response.ErrUnauthorized(40132, "workspace_scope_missing", "workspace context is required")
+	}
+	return s.listPublishTasksForOwner(ctx, publishTaskListOwner{
+		TenantID:    actor.TenantID,
+		WorkspaceID: workspaceID,
+		UserID:      actor.UserID,
+	}, req)
+}
+
+func (s *DesktopTaskService) listPublishTasksForOwner(ctx context.Context, owner publishTaskListOwner, req ListPublishTasksRequest) (*DesktopPublishTaskList, error) {
 	if s.pool == nil {
 		return nil, response.ErrServiceUnavailable(50342, "desktop_publish_job_store_unavailable", "desktop publish job store is unavailable")
 	}
@@ -877,7 +903,7 @@ func (s *DesktopTaskService) ListPublishTasks(ctx context.Context, client *repos
 
 	pendingItems, err := s.listPublishTasksByStatuses(
 		ctx,
-		client,
+		owner,
 		pendingStatuses,
 		title,
 		0,
@@ -888,7 +914,7 @@ func (s *DesktopTaskService) ListPublishTasks(ctx context.Context, client *repos
 		return nil, err
 	}
 
-	historyTotal, err := s.countPublishTasksByStatuses(ctx, client, historyStatuses, title)
+	historyTotal, err := s.countPublishTasksByStatuses(ctx, owner, historyStatuses, title)
 	if err != nil {
 		return nil, err
 	}
@@ -914,7 +940,7 @@ func (s *DesktopTaskService) ListPublishTasks(ctx context.Context, client *repos
 	if remaining > 0 && historyOffset < historyTotal {
 		historyItems, listErr := s.listPublishTasksByStatuses(
 			ctx,
-			client,
+			owner,
 			historyStatuses,
 			title,
 			remaining,
@@ -939,7 +965,7 @@ func (s *DesktopTaskService) ListPublishTasks(ctx context.Context, client *repos
 
 func (s *DesktopTaskService) listPublishTasksByStatuses(
 	ctx context.Context,
-	client *repository.DesktopClient,
+	owner publishTaskListOwner,
 	statuses []string,
 	title string,
 	limit int,
@@ -974,22 +1000,24 @@ func (s *DesktopTaskService) listPublishTasksByStatuses(
 		JOIN desktop_publish_jobs AS j
 		  ON j.desktop_id = t.job_id
 		 AND j.workspace_id = t.workspace_id
-		WHERE t.workspace_id = $1
-		  AND j.created_by_user_id = $2
+		WHERE t.tenant_id = $1
+		  AND t.workspace_id = $2
+		  AND j.tenant_id = $1
+		  AND j.created_by_user_id = $3
 		  AND t.kind = 'publish'
-		  AND t.status = ANY($3)
+		  AND t.status = ANY($4)
 		  AND (
-		    $4 = ''
-		    OR COALESCE(t.payload->>'title', j.title, '') ILIKE '%' || $4 || '%'
+		    $5 = ''
+		    OR COALESCE(t.payload->>'title', j.title, '') ILIKE '%' || $5 || '%'
 		  )
 	`
-	args := []any{client.WorkspaceID, client.UserID, statuses, title}
+	args := []any{owner.TenantID, owner.WorkspaceID, owner.UserID, statuses, title}
 
 	if strings.TrimSpace(orderBy) != "" {
 		query += "\nORDER BY " + orderBy
 	}
 	if limit > 0 {
-		query += "\nLIMIT $5 OFFSET $6"
+		query += "\nLIMIT $6 OFFSET $7"
 		args = append(args, limit, offset)
 	}
 
@@ -1004,7 +1032,7 @@ func (s *DesktopTaskService) listPublishTasksByStatuses(
 
 func (s *DesktopTaskService) countPublishTasksByStatuses(
 	ctx context.Context,
-	client *repository.DesktopClient,
+	owner publishTaskListOwner,
 	statuses []string,
 	title string,
 ) (int, error) {
@@ -1015,15 +1043,17 @@ func (s *DesktopTaskService) countPublishTasksByStatuses(
 		JOIN desktop_publish_jobs AS j
 		  ON j.desktop_id = t.job_id
 		 AND j.workspace_id = t.workspace_id
-		WHERE t.workspace_id = $1
-		  AND j.created_by_user_id = $2
+		WHERE t.tenant_id = $1
+		  AND t.workspace_id = $2
+		  AND j.tenant_id = $1
+		  AND j.created_by_user_id = $3
 		  AND t.kind = 'publish'
-		  AND t.status = ANY($3)
+		  AND t.status = ANY($4)
 		  AND (
-		    $4 = ''
-		    OR COALESCE(t.payload->>'title', j.title, '') ILIKE '%' || $4 || '%'
+		    $5 = ''
+		    OR COALESCE(t.payload->>'title', j.title, '') ILIKE '%' || $5 || '%'
 		  )
-	`, client.WorkspaceID, client.UserID, statuses, title).Scan(&count)
+	`, owner.TenantID, owner.WorkspaceID, owner.UserID, statuses, title).Scan(&count)
 	if err != nil {
 		return 0, response.ErrInternal(50109, "desktop_publish_tasks_query_failed", "failed to list desktop publish tasks")
 	}

server/internal/tenant/app/publish_job_service.go

@@ -414,6 +414,64 @@ func (s *PublishJobService) RetryByDesktopTask(
 	})
 }
 
+func (s *PublishJobService) RetryTenantDesktopTask(
+	ctx context.Context,
+	actor auth.Actor,
+	taskID uuid.UUID,
+) (*CreatePublishJobResponse, error) {
+	workspaceID := auth.CurrentWorkspaceID(ctx)
+	if actor.TenantID == 0 || actor.UserID == 0 || workspaceID == 0 {
+		return nil, response.ErrUnauthorized(40132, "workspace_scope_missing", "workspace context is required")
+	}
+	if s.pool == nil {
+		return nil, response.ErrServiceUnavailable(50342, "desktop_publish_job_store_unavailable", "desktop publish job store is unavailable")
+	}
+
+	taskRepo := repository.NewDesktopTaskRepository(s.pool)
+	task, err := taskRepo.GetByDesktopID(ctx, taskID, workspaceID)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, response.ErrNotFound(40482, "desktop_task_not_found", "desktop task not found")
+		}
+		return nil, response.ErrInternal(50095, "desktop_task_lookup_failed", "failed to inspect desktop task state")
+	}
+	if task.Kind != "publish" {
+		return nil, response.ErrBadRequest(40095, "desktop_task_not_publish", "only publish tasks can be retried")
+	}
+	if err := s.authorizePublishTaskForActor(ctx, actor, workspaceID, task); err != nil {
+		return nil, err
+	}
+	if task.Status == "queued" || task.Status == "in_progress" {
+		return nil, response.ErrConflict(40994, "desktop_task_retry_conflict", "desktop task is still pending or running")
+	}
+
+	payload := unmarshalJSONObject(task.Payload)
+	articleID, err := s.resolveRetryArticleID(ctx, actor.TenantID, payload)
+	if err != nil {
+		return nil, err
+	}
+
+	title := strings.TrimSpace(stringPointerValue(extractStringPointer(payload, "title")))
+	if title == "" {
+		title = "文章发布"
+	}
+
+	return s.Create(ctx, auth.Actor{
+		TenantID:           actor.TenantID,
+		UserID:             actor.UserID,
+		PrimaryWorkspaceID: workspaceID,
+		Role:               actor.Role,
+	}, CreatePublishJobRequest{
+		Title: title,
+		ContentRef: map[string]any{
+			"article_id": articleID,
+		},
+		Accounts: []CreatePublishJobAccountRequest{
+			{AccountID: task.TargetAccountID.String()},
+		},
+	})
+}
+
 func (s *PublishJobService) authorizePublishTaskForClientUser(
 	ctx context.Context,
 	client *repository.DesktopClient,
@@ -442,6 +500,36 @@ func (s *PublishJobService) authorizePublishTaskForClientUser(
 	return nil
 }
 
+func (s *PublishJobService) authorizePublishTaskForActor(
+	ctx context.Context,
+	actor auth.Actor,
+	workspaceID int64,
+	task *repository.DesktopTask,
+) error {
+	if task == nil || actor.TenantID == 0 || actor.UserID == 0 || workspaceID == 0 {
+		return response.ErrUnauthorized(40132, "workspace_scope_missing", "workspace context is required")
+	}
+
+	var ownsTask bool
+	err := s.pool.QueryRow(ctx, `
+		SELECT EXISTS (
+			SELECT 1
+			FROM desktop_publish_jobs
+			WHERE tenant_id = $1
+			  AND desktop_id = $2
+			  AND workspace_id = $3
+			  AND created_by_user_id = $4
+		)
+	`, actor.TenantID, task.JobID, workspaceID, actor.UserID).Scan(&ownsTask)
+	if err != nil {
+		return response.ErrInternal(50115, "desktop_publish_job_lookup_failed", "failed to validate desktop publish task ownership")
+	}
+	if !ownsTask {
+		return response.ErrForbidden(40384, "desktop_publish_task_not_owned", "desktop publish task belongs to another user")
+	}
+	return nil
+}
+
 func (s *PublishJobService) resolveRetryArticleID(ctx context.Context, tenantID int64, payload map[string]any) (int64, error) {
 	if articleID, ok := resolveRetryArticleIDFromPayload(payload); ok {
 		return articleID, nil

server/internal/tenant/transport/desktop_task_handler.go

@@ -65,34 +65,10 @@ func (h *DesktopTaskHandler) Lease(c *gin.Context) {
 }
 
 func (h *DesktopTaskHandler) ListPublish(c *gin.Context) {
-	req := app.ListPublishTasksRequest{
-		Page:     1,
-		PageSize: 10,
-		Title:    strings.TrimSpace(c.Query("title")),
+	req, ok := parseListPublishTasksRequest(c)
+	if !ok {
+		return
 	}
-
-	if rawPage := c.Query("page"); rawPage != "" {
-		parsed, err := strconv.Atoi(rawPage)
-		if err != nil || parsed <= 0 {
-			response.Error(c, response.ErrBadRequest(40001, "invalid_params", "page must be a positive integer"))
-			return
-		}
-		req.Page = parsed
-	}
-
-	rawPageSize := c.Query("page_size")
-	if rawPageSize == "" {
-		rawPageSize = c.Query("limit")
-	}
-	if rawPageSize != "" {
-		parsed, err := strconv.Atoi(rawPageSize)
-		if err != nil || parsed <= 0 {
-			response.Error(c, response.ErrBadRequest(40001, "invalid_params", "page_size must be a positive integer"))
-			return
-		}
-		req.PageSize = parsed
-	}
-
 	data, err := h.svc.ListPublishTasks(c.Request.Context(), MustDesktopClient(c.Request.Context()), req)
 	if err != nil {
 		response.Error(c, err)
@@ -101,6 +77,19 @@ func (h *DesktopTaskHandler) ListPublish(c *gin.Context) {
 	response.Success(c, data)
 }
 
+func (h *DesktopTaskHandler) TenantListPublish(c *gin.Context) {
+	req, ok := parseListPublishTasksRequest(c)
+	if !ok {
+		return
+	}
+	data, err := h.svc.ListTenantPublishTasks(c.Request.Context(), auth.MustActor(c.Request.Context()), req)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, data)
+}
+
 func (h *DesktopTaskHandler) Extend(c *gin.Context) {
 	desktopID, err := uuid.Parse(c.Param("id"))
 	if err != nil {
@@ -158,6 +147,21 @@ func (h *DesktopTaskHandler) RetryPublish(c *gin.Context) {
 	response.Success(c, data)
 }
 
+func (h *DesktopTaskHandler) TenantRetryPublish(c *gin.Context) {
+	desktopID, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		response.Error(c, response.ErrBadRequest(40084, "invalid_desktop_task_id", "task id must be a uuid"))
+		return
+	}
+
+	data, err := h.publishSvc.RetryTenantDesktopTask(c.Request.Context(), auth.MustActor(c.Request.Context()), desktopID)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, data)
+}
+
 func (h *DesktopTaskHandler) Cancel(c *gin.Context) {
 	desktopID, err := uuid.Parse(c.Param("id"))
 	if err != nil {
@@ -179,6 +183,38 @@ func (h *DesktopTaskHandler) Cancel(c *gin.Context) {
 	response.Success(c, data)
 }
 
+func parseListPublishTasksRequest(c *gin.Context) (app.ListPublishTasksRequest, bool) {
+	req := app.ListPublishTasksRequest{
+		Page:     1,
+		PageSize: 10,
+		Title:    strings.TrimSpace(c.Query("title")),
+	}
+
+	if rawPage := c.Query("page"); rawPage != "" {
+		parsed, err := strconv.Atoi(rawPage)
+		if err != nil || parsed <= 0 {
+			response.Error(c, response.ErrBadRequest(40001, "invalid_params", "page must be a positive integer"))
+			return req, false
+		}
+		req.Page = parsed
+	}
+
+	rawPageSize := c.Query("page_size")
+	if rawPageSize == "" {
+		rawPageSize = c.Query("limit")
+	}
+	if rawPageSize != "" {
+		parsed, err := strconv.Atoi(rawPageSize)
+		if err != nil || parsed <= 0 {
+			response.Error(c, response.ErrBadRequest(40001, "invalid_params", "page_size must be a positive integer"))
+			return req, false
+		}
+		req.PageSize = parsed
+	}
+
+	return req, true
+}
+
 func (h *DesktopTaskHandler) TenantCancel(c *gin.Context) {
 	desktopID, err := uuid.Parse(c.Param("id"))
 	if err != nil {

server/internal/tenant/transport/router.go

@@ -74,6 +74,8 @@ func RegisterRoutes(app *bootstrap.App) {
 	tenantProtected.POST("/accounts/:id/request-delete", desktopAccountHandler.RequestDelete)
 	tenantProtected.POST("/tasks/:id/reconcile", desktopTaskHandler.Reconcile)
 	tenantProtected.POST("/tasks/:id/cancel", desktopTaskHandler.TenantCancel)
+	tenantProtected.GET("/publish-tasks", desktopTaskHandler.TenantListPublish)
+	tenantProtected.POST("/publish-tasks/:id/retry", desktopTaskHandler.TenantRetryPublish)
 	tenantProtected.POST("/publish-jobs", publishJobHandler.Create)
 
 	complianceHandler := NewComplianceHandler(app)

server/internal/tenant/transport/router_test.go

@@ -30,6 +30,8 @@ func TestProtectedRoutes_RequireAuth(t *testing.T) {
 		{http.MethodPost, "/api/tenant/accounts/:id/request-delete"},
 		{http.MethodPost, "/api/tenant/tasks/:id/reconcile"},
 		{http.MethodPost, "/api/tenant/tasks/:id/cancel"},
+		{http.MethodGet, "/api/tenant/publish-tasks"},
+		{http.MethodPost, "/api/tenant/publish-tasks/:id/retry"},
 		{http.MethodPost, "/api/tenant/publish-jobs"},
 		{http.MethodGet, "/api/tenant/media/platforms"},
 		{http.MethodGet, "/api/tenant/workspace/overview"},
@@ -77,10 +79,12 @@ func TestDesktopClientRoutes_ClientTokenAuth(t *testing.T) {
 	}{
 		{http.MethodGet, "/api/desktop/dispatch"},
 		{http.MethodGet, "/api/desktop/accounts"},
+		{http.MethodGet, "/api/desktop/publish-tasks"},
 		{http.MethodGet, "/api/desktop/content/assets/:token"},
 		{http.MethodPost, "/api/desktop/clients/offline"},
 		{http.MethodPost, "/api/desktop/tasks/lease"},
 		{http.MethodPost, "/api/desktop/tasks/:id/result"},
+		{http.MethodPost, "/api/desktop/publish-tasks/:id/retry"},
 		{http.MethodPost, "/api/desktop/monitoring/tasks/lease"},
 		{http.MethodPost, "/api/desktop/monitoring/tasks/resume"},
 		{http.MethodPost, "/api/desktop/monitoring/tasks/:id/result"},