fix(wiki): purge through the plugin page actions and count reset deletions (#101)

Closes #99. Closes #100.

## #99 — purge used the core topic API

`deploy-wiki --stale-policy purge` deleted pages with `DELETE /api/v3/topics/{tid}`. On a NodeBB running `nodebb-plugin-westgate-wiki` that is refused for topics in wiki categories — revision history is plugin-owned — so every purge failed with HTTP 400 and the deploy exited 1.

Purge now goes through the plugin's own page actions:

1. `PUT /api/v3/plugins/westgate-wiki/page/tombstone`
2. `DELETE /api/v3/plugins/westgate-wiki/page/hard-purge`

in that order, because a page must be tombstoned before it can be purged. A page that is already gone answers 404 on the tombstone and is treated as a completed purge, as before.

**Archive was audited and needs no change.** It rewrites the page through `updatePost`, which is an ordinary post edit the plugin allows; only delete, restore, and purge are reserved to the page actions.

**The wiki home topic.** A namespace reset enumerates every topic in the category, including the home page, which the plugin excludes from tombstone, restore, and purge alike. Those are now skipped instead of aborting the reset. NodeBB answers 403 for that and for a token without purge privileges alike, and the response body cannot tell the two apart — what can is scope. A category where nothing at all could be deleted is a privilege problem, so the run still fails there rather than writing a manifest that claims a fresh start over pages that are all still present.

**The fakes.** Every fake NodeBB in `wiki_deploy_test.go` now goes through one constructor that refuses native topic mutation exactly the way the plugin does. The old fakes answered the core API, which is how a purge path that has never worked in production stayed green in CI.

## #100 — `stale: 0` above `purged: 1213`

The reset purge never went through stale computation, so the preview reported zero deletions on a run that would delete every topic in the managed categories.

Reset deletions are now counted in `stale`, which is the number callers word their destructive-policy warning around, and the summary gains a line naming the reset and how many of its targets the manifest has no record of writing:

```
stale:       1213
purged:      1213
namespace reset: 1213 (unrecognized: 13)
  unrecognized pages were not written by this deployer; recreating them is not possible
```

The unrecognized subset is the number worth surfacing, since those are the deletions a re-seed cannot undo. The `--reset-managed-namespaces` help text now says plainly that the flag deletes every page in the managed categories, not only the ones this deployer wrote.

`DeployResult` is exported so the console reads named fields instead of eleven positional ints.

## Verification

`go vet ./...` and `go test ./...` pass. New tests cover the plugin purge order, the already-missing page, the skipped undeletable topic, the per-category privilege failure, and the reset counts.Reviewed-on: #101

Co-authored-by: vickydotbat <vickydotbat@tutamail.com>

internal/topdata/wiki_deploy.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"html"
 	"io"
+	"maps"
 	"net/http"
 	"net/url"
 	"os"
@@ -52,7 +53,7 @@ type DeployWikiOptions struct {
 	TitlePrefixMinLength   int
 }
 
-type deployResult struct {
+type DeployResult struct {
 	LocalPages int
 	Created    int
 	Updated    int
@@ -63,6 +64,19 @@ type deployResult struct {
 	Drifted    int
 	Renamed    int
 	Manifest   string
+	// ResetPurged counts the deletions queued by --reset-managed-namespaces.
+	// They are also included in Stale and Purged, because callers warn about
+	// destructive policies in terms of the stale count: sow-topdata's
+	// deploy-wiki wrapper prints "of the pages counted as 'stale' below, they
+	// will be DELETED from NodeBB" directly above this block.
+	ResetPurged int
+	// ResetUnrecognized counts the subset of ResetPurged that the deploy
+	// manifest has no record of writing. Those deletions are the ones a
+	// re-seed cannot undo.
+	ResetUnrecognized int
+	// ResetSkipped counts reset targets NodeBB refused to delete, such as the
+	// wiki home topic, which the plugin excludes from tombstone and purge.
+	ResetSkipped int
 }
 
 type wikiDeployPage struct {
@@ -100,6 +114,12 @@ type wikiDeployPlan struct {
 	Content    string
 	RemoteHash string
 	Title      string
+	// Reset marks a purge queued by --reset-managed-namespaces rather than by
+	// stale computation over the manifest.
+	Reset bool
+	// Unrecognized marks a reset purge whose topic the manifest has no record
+	// of writing.
+	Unrecognized bool
 }
 
 type wikiNamespacesDocument struct {
@@ -116,7 +136,7 @@ type wikiNamespaceDeclaration struct {
 	EditPolicy    string   `json:"edit_policy" yaml:"edit_policy"`
 }
 
-func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress func(string)) (deployResult, error) {
+func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress func(string)) (DeployResult, error) {
 	if progress == nil {
 		progress = func(string) {}
 	}
@@ -132,19 +152,19 @@ func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress
 		}
 	}
 	if _, err := os.Stat(opts.SourceDir); err != nil {
-		return deployResult{}, fmt.Errorf("wiki source directory not found: %w", err)
+		return DeployResult{}, fmt.Errorf("wiki source directory not found: %w", err)
 	}
 	if opts.Endpoint == "" {
-		return deployResult{}, errors.New("NODEBB_API_ENDPOINT is required")
+		return DeployResult{}, errors.New("NODEBB_API_ENDPOINT is required")
 	}
 	if opts.Token == "" {
-		return deployResult{}, errors.New("NODEBB_API_TOKEN is required")
+		return DeployResult{}, errors.New("NODEBB_API_TOKEN is required")
 	}
 	if opts.Username != "" || opts.Password != "" || opts.NotesDelimiter != "" {
-		return deployResult{}, errors.New("DokuWiki deployment options are no longer supported; use NodeBB endpoint, token, and category mappings")
+		return DeployResult{}, errors.New("DokuWiki deployment options are no longer supported; use NodeBB endpoint, token, and category mappings")
 	}
 	if opts.StalePolicy != "" && opts.StalePolicy != "report" && opts.StalePolicy != "archive" && opts.StalePolicy != "purge" {
-		return deployResult{}, fmt.Errorf("wiki stale policy %q is not supported", opts.StalePolicy)
+		return DeployResult{}, fmt.Errorf("wiki stale policy %q is not supported", opts.StalePolicy)
 	}
 	if opts.TitlePrefixMinLength <= 0 {
 		opts.TitlePrefixMinLength = p.EffectiveConfig().TopData.Wiki.TitlePrefixMinLength
@@ -154,7 +174,7 @@ func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress
 	if len(namespaces) == 0 {
 		declarations, err := loadWikiNamespaceDeclarations(p)
 		if err != nil {
-			return deployResult{}, err
+			return DeployResult{}, err
 		}
 		for _, declaration := range declarations {
 			namespaces = append(namespaces, declaration.ID)
@@ -164,7 +184,7 @@ func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress
 		}
 		envCategories, err := categoryIDsFromNamespaceEnv(declarations)
 		if err != nil {
-			return deployResult{}, err
+			return DeployResult{}, err
 		}
 		if len(envCategories) > 0 {
 			merged := envCategories
@@ -183,7 +203,7 @@ func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress
 	progress(fmt.Sprintf("Collecting local wiki pages from %s", opts.SourceDir))
 	pages, err := collectLocalPages(opts.SourceDir, opts.PageIndexPath, namespaces)
 	if err != nil {
-		return deployResult{}, err
+		return DeployResult{}, err
 	}
 	progress(fmt.Sprintf("Loaded %d local wiki page(s)", len(pages)))
 	manifest := loadDeployManifest(manifestPath)
@@ -193,7 +213,7 @@ func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress
 	progress(fmt.Sprintf("Planning NodeBB wiki deploy for %d local page(s)", len(pages)))
 	plans, result, nextManifest, err := planNodeBBDeploy(pages, manifest, opts, client, progress)
 	if err != nil {
-		return deployResult{}, err
+		return DeployResult{}, err
 	}
 	result.LocalPages = len(pages)
 	result.Manifest = manifestPath
@@ -212,6 +232,8 @@ func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress
 	}
 	orderedPlans := orderNodeBBDeployPlans(plans)
 	progress(fmt.Sprintf("Executing NodeBB wiki actions: total %d, create %d, update %d, rename %d, archive %d, purge %d", len(orderedPlans), result.Created, result.Updated, result.Renamed, result.Archived, result.Purged))
+	resetPurgedByCID := map[int]int{}
+	resetSkippedByCID := map[int]int{}
 	for i, plan := range orderedPlans {
 		if shouldReportNodeBBDeployActionProgress(i, len(orderedPlans)) {
 			progress(fmt.Sprintf("Executing NodeBB wiki action %d/%d: %s %s", i+1, len(orderedPlans), plan.Action, plan.Page.PageID))
@@ -242,19 +264,52 @@ func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress
 				return result, fmt.Errorf("deploy wiki page %q: update NodeBB post %d: %w", plan.Page.PageID, plan.Entry.PID, err)
 			}
 		case "archive":
+			// Archiving rewrites the page rather than removing it, so it goes
+			// through the ordinary post edit the wiki plugin allows; only
+			// delete, restore, and purge are reserved to the page actions.
 			if err := client.updatePost(plan.Entry.TID, plan.Entry.PID, plan.Content, summary); err != nil {
 				return result, fmt.Errorf("deploy wiki page %q: archive NodeBB post %d: %w", plan.Page.PageID, plan.Entry.PID, err)
 			}
 		case "purge":
-			if err := client.purgeTopic(plan.Entry.TID); err != nil {
+			if err := client.purgeWikiPage(plan.Entry.TID); err != nil {
+				// A namespace reset sweeps every topic in the category, so it
+				// can reach pages NodeBB will not delete at all — the wiki home
+				// topic above all. Skip those rather than abandoning the reset.
+				if plan.Reset && isNodeBBWikiPageUndeletable(err) {
+					result.ResetSkipped++
+					result.ResetPurged--
+					result.Purged--
+					result.Stale--
+					if plan.Unrecognized {
+						result.ResetUnrecognized--
+					}
+					resetSkippedByCID[plan.Entry.CID]++
+					progress(fmt.Sprintf("NodeBB refused to delete wiki topic %d during managed namespace reset; skipping it", plan.Entry.TID))
+					continue
+				}
 				return result, fmt.Errorf("deploy wiki page %q: purge NodeBB topic %d: %w", plan.Page.PageID, plan.Entry.TID, err)
 			}
+			if plan.Reset {
+				resetPurgedByCID[plan.Entry.CID]++
+			}
 		case "rename":
 			if err := client.renameWikiPage(plan.Entry.TID, plan.Entry.CID, plan.Title); err != nil {
 				return result, fmt.Errorf("deploy wiki page %q: rename NodeBB topic %d to %q: %w", plan.Page.PageID, plan.Entry.TID, plan.Title, err)
 			}
 		}
 	}
+	// NodeBB answers 403 both for the pages it will never delete — the wiki
+	// home topic — and for a token without purge privileges, and the two are
+	// not distinguishable from the response. What tells them apart is scope: a
+	// category where nothing at all could be deleted is a privilege problem,
+	// not a home page. Reporting that as a completed reset would leave the
+	// manifest claiming a fresh start over pages that are all still there, so
+	// the next deploy would recreate every one of them as a duplicate.
+	for _, cid := range slices.Sorted(maps.Keys(resetSkippedByCID)) {
+		if resetPurgedByCID[cid] == 0 {
+			return result, fmt.Errorf("NodeBB refused every managed namespace reset deletion in category %d (%d topic(s)); check that the deploy token has wiki purge privileges there", cid, resetSkippedByCID[cid])
+		}
+	}
 	if err := saveDeployManifest(manifestPath, nextManifest); err != nil {
 		return result, err
 	}
@@ -486,7 +541,7 @@ func isDir(path string) bool {
 	return err == nil && info.IsDir()
 }
 
-func planNodeBBDeploy(pages map[string]wikiDeployPage, manifest wikiDeployManifest, opts DeployWikiOptions, client *nodeBBClient, progress func(string)) ([]wikiDeployPlan, deployResult, wikiDeployManifest, error) {
+func planNodeBBDeploy(pages map[string]wikiDeployPage, manifest wikiDeployManifest, opts DeployWikiOptions, client *nodeBBClient, progress func(string)) ([]wikiDeployPlan, DeployResult, wikiDeployManifest, error) {
 	if progress == nil {
 		progress = func(string) {}
 	}
@@ -494,17 +549,23 @@ func planNodeBBDeploy(pages map[string]wikiDeployPage, manifest wikiDeployManife
 	next := wikiDeployManifest{Version: "nodebb-v1", Pages: map[string]wikiDeployManifestPage{}}
 	remotePagesByCID := map[int][]nodeBBWikiPage{}
 	var plans []wikiDeployPlan
-	var result deployResult
+	var result DeployResult
 	if opts.ResetManagedNamespaces {
 		if !opts.AllowCreates && len(pageIDs) > 0 {
 			return nil, result, next, errors.New("wiki managed namespace reset requires --create so current generated pages can be recreated")
 		}
-		resetPlans, purged, err := planManagedNamespaceReset(opts, client, progress)
+		resetPlans, purged, unrecognized, err := planManagedNamespaceReset(opts, manifest, client, progress)
 		if err != nil {
 			return nil, result, next, err
 		}
 		plans = append(plans, resetPlans...)
 		result.Purged += purged
+		// A namespace reset deletes remote pages the same way stale purge does,
+		// so it is counted as stale: that is the number callers word their
+		// destructive-policy warning around.
+		result.Stale += purged
+		result.ResetPurged = purged
+		result.ResetUnrecognized = unrecognized
 		manifest = wikiDeployManifest{Version: "nodebb-v1", Pages: map[string]wikiDeployManifestPage{}}
 		for _, cid := range opts.CategoryIDs {
 			if cid != 0 {
@@ -682,7 +743,11 @@ func planNodeBBDeploy(pages map[string]wikiDeployPage, manifest wikiDeployManife
 	return plans, result, next, nil
 }
 
-func planManagedNamespaceReset(opts DeployWikiOptions, client *nodeBBClient, progress func(string)) ([]wikiDeployPlan, int, error) {
+// planManagedNamespaceReset queues a purge for every topic in each managed
+// category, not only the ones the manifest says we wrote. The second return is
+// the plan count; the third is how many of those topics the manifest has no
+// record of, which is the subset a re-seed cannot put back.
+func planManagedNamespaceReset(opts DeployWikiOptions, manifest wikiDeployManifest, client *nodeBBClient, progress func(string)) ([]wikiDeployPlan, int, int, error) {
 	namespaces := slices.Clone(opts.Namespaces)
 	if len(namespaces) == 0 {
 		for namespace := range opts.CategoryIDs {
@@ -691,7 +756,15 @@ func planManagedNamespaceReset(opts DeployWikiOptions, client *nodeBBClient, pro
 	}
 	slices.Sort(namespaces)
 
+	manifestTIDs := map[int]struct{}{}
+	for _, entry := range manifest.Pages {
+		if entry.TID != 0 {
+			manifestTIDs[entry.TID] = struct{}{}
+		}
+	}
+
 	seenTIDs := map[int]struct{}{}
+	unrecognized := 0
 	var plans []wikiDeployPlan
 	for _, namespace := range namespaces {
 		cid := opts.CategoryIDs[namespace]
@@ -701,7 +774,7 @@ func planManagedNamespaceReset(opts DeployWikiOptions, client *nodeBBClient, pro
 		progress(fmt.Sprintf("Listing NodeBB wiki namespace category %d for managed reset", cid))
 		remotePages, err := client.listNamespacePages(cid)
 		if err != nil {
-			return nil, 0, err
+			return nil, 0, 0, err
 		}
 		slices.SortFunc(remotePages, func(a, b nodeBBWikiPage) int {
 			return a.TID - b.TID
@@ -714,19 +787,25 @@ func planManagedNamespaceReset(opts DeployWikiOptions, client *nodeBBClient, pro
 				continue
 			}
 			seenTIDs[remotePage.TID] = struct{}{}
+			_, known := manifestTIDs[remotePage.TID]
+			if !known {
+				unrecognized++
+			}
 			title := strings.TrimSpace(remotePage.Title)
 			if title == "" {
 				title = strings.TrimSpace(remotePage.TitleLeaf)
 			}
 			pageID := fmt.Sprintf("%s:reset-topic-%d", namespace, remotePage.TID)
 			plans = append(plans, wikiDeployPlan{
-				Page:   wikiDeployPage{PageID: pageID, Title: title, Namespace: namespace},
-				Entry:  wikiDeployManifestPage{TID: remotePage.TID, CID: cid, Namespace: namespace, Title: title},
-				Action: "purge",
+				Page:         wikiDeployPage{PageID: pageID, Title: title, Namespace: namespace},
+				Entry:        wikiDeployManifestPage{TID: remotePage.TID, CID: cid, Namespace: namespace, Title: title},
+				Action:       "purge",
+				Reset:        true,
+				Unrecognized: !known,
 			})
 		}
 	}
-	return plans, len(plans), nil
+	return plans, len(plans), unrecognized, nil
 }
 
 func findMappedRemoteTopic(entry wikiDeployManifestPage, client *nodeBBClient) (nodeBBPost, bool, error) {
@@ -1611,16 +1690,36 @@ func (c *nodeBBClient) renameWikiPage(tid, cid int, title string) error {
 	return c.request("PUT", "/api/v3/plugins/westgate-wiki/page/move", body, nil)
 }
 
-func (c *nodeBBClient) purgeTopic(tid int) error {
+// purgeWikiPage deletes a wiki topic through the wiki plugin's own page
+// actions. The core DELETE /api/v3/topics/{tid} route is refused for topics in
+// wiki categories, because revision history is plugin-owned, so a purge has to
+// tombstone the page first and then hard-purge it.
+func (c *nodeBBClient) purgeWikiPage(tid int) error {
 	if tid == 0 {
-		return fmt.Errorf("NodeBB topic purge requires topic id")
+		return fmt.Errorf("NodeBB wiki page purge requires topic id")
 	}
-	err := c.request(http.MethodDelete, fmt.Sprintf("/api/v3/topics/%d", tid), nil, nil)
+	body := map[string]any{"tid": tid}
+	if err := c.request(http.MethodPut, "/api/v3/plugins/westgate-wiki/page/tombstone", body, nil); err != nil {
+		if isNodeBBMissingResource(err) {
+			return nil
+		}
+		return err
+	}
+	if err := c.request(http.MethodDelete, "/api/v3/plugins/westgate-wiki/page/hard-purge", body, nil); err != nil {
+		if isNodeBBMissingResource(err) {
+			return nil
+		}
+		return err
+	}
+	return nil
+}
+
+// isNodeBBWikiPageUndeletable reports whether NodeBB refused to delete the page
+// outright rather than failing transiently. The wiki home topic answers this
+// way: the plugin excludes it from tombstone, restore, and purge alike.
+func isNodeBBWikiPageUndeletable(err error) bool {
 	var httpErr nodeBBHTTPError
-	if errors.As(err, &httpErr) && (httpErr.Status == http.StatusNotFound || httpErr.Status == http.StatusGone) {
-		return nil
-	}
-	return err
+	return errors.As(err, &httpErr) && httpErr.Status == http.StatusForbidden
 }
 
 func (c *nodeBBClient) acquireEditLock(tid int) (nodeBBEditLock, error) {