到期终止调错了 API：/terminate 是立即终止，不是到期终止

我把「到期注销」实现成 POST /{service}/terminate + confirmTermination。
用户照着做之后，OVH 当场把服务器暂停了，并邮件通知「5 天内不付款就彻底清除
硬盘数据，此操作无法撤销」——不是等到期日。一台在跑的机器因此停了。

## 错在哪

OVH 的生命周期动作枚举 services.expanded.Lifecycle.ActionEnum 把两件事分得很清楚：

  terminate                    立即终止
  terminateAtExpirationDate    到期终止

/{service}/terminate 端点只对应前者，它没有「到期」这个选项可选。
到期终止只能通过 PUT /services/{serviceId} 的 terminationPolicy 字段设置：

  empty                        不终止 / 撤销已提交的终止
  terminateAtExpirationDate    到期日终止
  terminateAtEngagementDate    合同期结束时终止

三个区都有这个端点和这三个取值。services.update.Service 的三个字段全部
canBeNull:true，所以只发 terminationPolicy 一个是合法的。

我之前查的是 OVH 通用计费文档那句「terminate 在当期订阅结束时生效」，
就当成确定结论告诉了用户「不会立即停机」。但同一批搜索结果里其实写着
OVH 的注销分「Cancel service now」和「Cancel service」两种，我没有去查
API 的 /terminate 对应哪一种就下了结论。

## 改了什么

- 新增 PUT /api/{server,vps}-control/:name/termination-policy，走正确的端点
- 续费对话框的「到期终止」改用它；从「到期终止」切回自动/手动续费时会先发
  policy=empty 撤销，否则续费模式改了、终止标记还挂着，到期照样销毁
- 前端不再有任何地方调用 /terminate
- 独服 TerminateService 和 VPS 的 useTerminateVps 都加了警告注释说明它们是
  立即终止；VPS 维护页那个独立入口本来就写明「确认后立即销毁」，是诚实的，保持原样

对话框现在写的是「到期日之前照常使用，到期后才销毁」，并告诉用户随时可以
切回自动/手动续费来撤销。

Author: gokele

server/internal/handlers/server_control_misc.go

@@ -600,6 +600,14 @@ var terminationFutureUses = map[string]bool{
 	"SUBSCRIBE_SIMILAR_SERVICE_WITH_COMPETITOR":       true,
 }
 
+// TerminateService ⚠️ 立即终止。
+//
+// 实测(2026-08-25):这条链路走完之后 OVH **当场把服务器暂停**,并邮件通知
+// 「5 天内不付款就彻底清除硬盘数据,此操作无法撤销」—— 不是等到期日。
+//
+// 想要「到期才终止」请用 UpdateTerminationPolicy(PUT /services/{serviceId} 的
+// terminationPolicy = terminateAtExpirationDate)。OVH 的生命周期动作枚举里
+// terminate 和 terminateAtExpirationDate 是两个不同的动作,这个端点只对应前者。
 func TerminateService(state *app.State) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		svc := c.Param("service_name")

server/internal/handlers/termination_policy.go

@@ -0,0 +1,105 @@
+package handlers
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	ovhsdk "github.com/ovh/go-ovh/ovh"
+
+	"github.com/ovh-buy/server/internal/app"
+)
+
+// 到期终止策略。
+//
+// 血的教训:这件事**不能**用 POST /{service}/terminate。
+// OVH 的生命周期动作枚举 services.expanded.Lifecycle.ActionEnum 把两件事分得很清楚:
+//
+//	terminate                    立即终止 —— 提交后 OVH 当场把服务器暂停,
+//	                             并邮件通知"5 天内不付款就彻底清除硬盘数据"
+//	terminateAtExpirationDate    到期终止 —— 用到当期结束,到期日才销毁
+//
+// /{service}/terminate 端点对应的是前者,它没有"到期"这个选项可选。
+// 到期终止只能通过 PUT /services/{serviceId} 的 terminationPolicy 字段设置。
+// 我一开始用错了端点,把用户一台在跑的服务器直接弄停了。
+//
+// terminationPolicy 的三个取值(三区一致):
+//
+//	empty                        不终止(也就是撤销已提交的到期终止)
+//	terminateAtExpirationDate    到期日终止
+//	terminateAtEngagementDate    合同期结束时终止(仅对有合同期的服务有意义)
+const (
+	TerminationNone         = "empty"
+	TerminationAtExpiration = "terminateAtExpirationDate"
+	TerminationAtEngagement = "terminateAtEngagementDate"
+)
+
+var terminationPolicies = map[string]bool{
+	TerminationNone:         true,
+	TerminationAtExpiration: true,
+	TerminationAtEngagement: true,
+}
+
+// setTerminationPolicy PUT /services/{serviceId}
+//
+// services.update.Service 的三个字段(displayName / renew / terminationPolicy)全部
+// canBeNull:true,所以只发要改的那一个是合法的 —— 不需要像 RenewType 那样补全。
+func setTerminationPolicy(client *ovhsdk.Client, serviceID int64, policy string) error {
+	return client.Put(fmt.Sprintf("/services/%d", serviceID),
+		map[string]interface{}{"terminationPolicy": policy}, nil)
+}
+
+// UpdateTerminationPolicy PUT /api/server-control/:service_name/termination-policy
+func UpdateTerminationPolicy(state *app.State) gin.HandlerFunc {
+	return terminationPolicyHandler(state, serviceIDForDedicated, "server_control", "服务器")
+}
+
+// UpdateVpsTerminationPolicy PUT /api/vps-control/:service_name/termination-policy
+func UpdateVpsTerminationPolicy(state *app.State) gin.HandlerFunc {
+	return terminationPolicyHandler(state, serviceIDForVps, "vps_control", "VPS")
+}
+
+func terminationPolicyHandler(
+	state *app.State,
+	resolveID func(*ovhsdk.Client, string) (int64, error),
+	logSource, label string,
+) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		svc := c.Param("service_name")
+		client, err := ovhClientFor(state, c)
+		if err != nil {
+			noOVHResp(c)
+			return
+		}
+		var body struct {
+			Policy string `json:"policy"`
+		}
+		_ = c.ShouldBindJSON(&body)
+		if !terminationPolicies[body.Policy] {
+			c.JSON(http.StatusBadRequest, gin.H{"success": false,
+				"error": "policy 必须是 empty / terminateAtExpirationDate / terminateAtEngagementDate 之一"})
+			return
+		}
+
+		serviceID, err := resolveID(client, svc)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"success": false,
+				"error": "取 serviceId 失败: " + err.Error()})
+			return
+		}
+		if err := setTerminationPolicy(client, serviceID, body.Policy); err != nil {
+			state.Logger.Error(label+" "+svc+" 设置终止策略失败: "+err.Error(), logSource)
+			c.JSON(http.StatusInternalServerError, gin.H{"success": false, "error": err.Error()})
+			return
+		}
+
+		msg := "已设为到期终止:到期日之前照常使用,到期后销毁"
+		if body.Policy == TerminationNone {
+			msg = "已取消终止,服务恢复正常续费"
+		} else if body.Policy == TerminationAtEngagement {
+			msg = "已设为合同期结束时终止"
+		}
+		state.Logger.Warn(fmt.Sprintf("%s %s 终止策略改为 %s", label, svc, body.Policy), logSource)
+		c.JSON(http.StatusOK, gin.H{"success": true, "message": msg, "policy": body.Policy})
+	}
+}

server/main.go

@@ -367,6 +367,9 @@ func main() {
 			sc.GET("/:service_name/ongoing", handlers.GetOngoingTasks(state))
 			sc.GET("/:service_name/license/windows/compliant", handlers.GetCompliantWindowsVersions(state))
 			sc.GET("/:service_name/license/windows-sql/compliant", handlers.GetCompliantWindowsSqlVersions(state))
+			// 到期终止走 terminationPolicy,不是 /terminate ——
+			// 后者是立即终止,提交即暂停服务器
+			sc.PUT("/:service_name/termination-policy", handlers.UpdateTerminationPolicy(state))
 			sc.POST("/:service_name/terminate", handlers.TerminateService(state))
 			sc.POST("/:service_name/confirm-termination", handlers.ConfirmTermination(state))
 			sc.GET("/:service_name/spla", handlers.GetSPLAList(state))
@@ -414,6 +417,7 @@ func main() {
 
 			// 杂项
 			vc.POST("/:service_name/change-contact", handlers.ChangeVpsContact(state))
+			vc.PUT("/:service_name/termination-policy", handlers.UpdateVpsTerminationPolicy(state))
 			vc.POST("/:service_name/terminate", handlers.TerminateVps(state))
 			vc.POST("/:service_name/confirm-termination", handlers.ConfirmVpsTermination(state))
 			vc.GET("/:service_name/secondary-dns", handlers.GetVpsSecondaryDns(state))

web/src/components/server-control/RenewalDialog.tsx

@@ -7,19 +7,17 @@ import { Button } from "@/components/ui/button";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
 import {
   useUpdateRenewal,
-  useTerminateService,
-  useConfirmTermination,
+  useUpdateTerminationPolicy,
   type ServiceInfo,
 } from "@/hooks/use-server-control";
-import { Input } from "@/components/ui/input";
 import { toast } from "sonner";
 
 type RenewMode = "auto" | "manual" | "delete";
 
 const MODE_OPTIONS: Array<{ value: RenewMode; label: string; desc: string }> = [
   { value: "auto", label: "自动续费", desc: "到期前 OVH 自动扣款续费" },
   { value: "manual", label: "手动续费", desc: "到期前需手动付款,不付则服务终止" },
-  { value: "delete", label: "到期注销", desc: "取消续费,到期后销毁(需邮件确认)" },
+  { value: "delete", label: "到期终止", desc: "到期日之前照常使用,到期后才销毁" },
 ];
 
 /** 用 VPS / dedicated 各自的 update hook 都行,Dialog 只关心 mutation 接口形状 */
@@ -31,9 +29,8 @@ export type RenewalMutation = {
 /** 终止流程的两步。VPS 和独服的端点不同(/vps-control 与 /server-control),
  *  所以必须由调用方注入 —— 写死一边会让另一边打到错误的端点上。 */
 export type TerminationMutations = {
-  terminate: { mutateAsync: () => Promise<any>; isPending: boolean };
-  confirm: {
-    mutateAsync: (vars: { token: string }) => Promise<any>;
+  policy: {
+    mutateAsync: (vars: { policy: string }) => Promise<any>;
     isPending: boolean;
   };
 };
@@ -67,25 +64,20 @@ export function RenewalDialog({
   const defaultUpdate = useUpdateRenewal(serviceName);
   const update = mutation ?? defaultUpdate;
 
-  // 到期注销走的是 OVH 的服务终止流程,不是 serviceInfos 里的 renew 标志位。
-  // 那条路会被 OVH 回 400 "Arguments conflicting",而且它自己的 issue 里记着
-  // 这组标志位行为不可预测。终止有专用端点,也是 OVH 控制台走的那条。
-  // 代价是必须邮件确认 —— 这是 OVH 的规定,绕不开,所以对话框要有第二步。
-  const defaultTerminate = useTerminateService(serviceName);
-  const defaultConfirm = useConfirmTermination(serviceName);
-  const terminate = termination?.terminate ?? defaultTerminate;
-  const confirmTerm = termination?.confirm ?? defaultConfirm;
-  // 已经发起终止、正在等用户填邮件里的 token
-  const [awaitingToken, setAwaitingToken] = useState(false);
-  const [token, setToken] = useState("");
+  // 到期终止走 PUT /services/{serviceId} 的 terminationPolicy。
+  //
+  // **不要**用 POST /terminate —— 那是「立即终止」,提交后 OVH 当场把服务器暂停,
+  // 并邮件通知「5 天内不付款就彻底清除硬盘数据」。这个坑真实踩过一次。
+  // OVH 的生命周期动作枚举里 terminate 与 terminateAtExpirationDate 是两个不同的动作,
+  // /terminate 端点只对应前者,没有「到期」这个选项可选。
+  const defaultPolicy = useUpdateTerminationPolicy(serviceName);
+  const policyMut = termination?.policy ?? defaultPolicy;
 
   // 弹窗每次打开同步当前状态
   useEffect(() => {
     if (open) {
       setMode(currentMode);
       setPeriod(info.renewalPeriod || 1);
-      setAwaitingToken(false);
-      setToken("");
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [open]);
@@ -100,38 +92,29 @@ export function RenewalDialog({
   const handleSubmit = async () => {
     if (mode === "delete") {
       try {
-        const res = await terminate.mutateAsync();
-        setAwaitingToken(true);
-        toast.info(res?.message || "终止请求已提交,确认码已发到管理员邮箱", { duration: 8000 });
+        const res = await policyMut.mutateAsync({ policy: "terminateAtExpirationDate" });
+        toast.success(res?.message || "已设为到期终止", { duration: 6000 });
+        onOpenChange(false);
       } catch (e: any) {
-        toast.error(errText(e, "发起终止失败"), { duration: 6000 });
+        toast.error(errText(e, "设置失败"), { duration: 8000 });
       }
       return;
     }
+    // 从「到期终止」切回自动/手动续费时，先把终止策略撤掉，
+    // 否则续费模式改了、终止标记还挂着，到期照样销毁。
     try {
+      if (currentMode === "delete") {
+        await policyMut.mutateAsync({ policy: "empty" });
+      }
       await update.mutateAsync({ mode, period });
-      toast.success("续费策略已更新");
+      toast.success(currentMode === "delete" ? "已取消终止并更新续费策略" : "续费策略已更新");
       onOpenChange(false);
     } catch (e: any) {
       toast.error(errText(e, "更新失败"), { duration: 6000 });
     }
   };
 
-  const handleConfirmTerm = async () => {
-    if (!token.trim()) {
-      toast.error("请填写邮件里的确认码");
-      return;
-    }
-    try {
-      await confirmTerm.mutateAsync({ token: token.trim() });
-      toast.success("已确认终止。到期日之前服务器照常运行,到期后才销毁");
-      onOpenChange(false);
-    } catch (e: any) {
-      toast.error(errText(e, "确认失败"), { duration: 8000 });
-    }
-  };
-
-  const busy = update.isPending || terminate.isPending || confirmTerm.isPending;
+  const busy = update.isPending || policyMut.isPending;
 
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
@@ -213,45 +196,17 @@ export function RenewalDialog({
               </div>
             )}
 
-            {mode === "delete" && !awaitingToken && (
+            {mode === "delete" && (
               <div className="border border-destructive/40 bg-destructive/5 rounded-xl p-2.5 flex gap-2">
                 <AlertCircle className="w-3.5 h-3.5 text-destructive flex-shrink-0 mt-0.5" />
                 <div className="text-[11px] text-muted-foreground space-y-1">
                   <p>
-                    服务器将在到期日 (
+                    到期日 (
                     {info.expiration ? new Date(info.expiration).toLocaleDateString("zh-CN") : "—"}
-                    ) 销毁,数据无法恢复。
+                    ) 之前<b>照常使用</b>，到期后才销毁，数据无法恢复。
                   </p>
-                  <p>
-                    OVH 要求邮件确认:点下面的按钮后会往账户管理员邮箱发一封确认邮件,
-                    把里面的确认码填回来才真正生效。
-                  </p>
-                  <p>
-                    到期之前服务器<b>照常运行</b>,不会立即停机 —— OVH 的终止是
-                    「当期订阅结束时才生效」。立即释放资源是另一个接口,本控制台不调用。
-                  </p>
-                  <p>
-                    <b>反悔要去 OVH 控制台</b>(API 没有取消终止的端点):
-                    My offers and services → 该服务右侧 <code>...</code> →
-                    Stop cancellation of service。撤销是立即生效的。
-                  </p>
-                </div>
-              </div>
-            )}
-
-            {mode === "delete" && awaitingToken && (
-              <div className="space-y-2 pt-1">
-                <div className="border border-amber-500/40 bg-amber-500/10 rounded-xl p-2.5 text-[11px] text-muted-foreground">
-                  确认邮件已发到账户管理员邮箱。把邮件里的确认码填在下面 ——
-                  <b>没填之前终止不会生效</b>,服务器仍会照常续费。
+                  <p>改主意了随时回到这里选「自动续费」或「手动续费」即可撤销。</p>
                 </div>
-                <label className="text-[12px] font-semibold block">邮件里的确认码</label>
-                <Input
-                  value={token}
-                  onChange={(e) => setToken(e.target.value)}
-                  placeholder="粘贴邮件中的 token"
-                  autoFocus
-                />
               </div>
             )}
           </div>
@@ -261,23 +216,17 @@ export function RenewalDialog({
           <Button variant="outline" onClick={() => onOpenChange(false)}>
             取消
           </Button>
-          {!info.renewalForced &&
-            (awaitingToken ? (
-              <Button onClick={handleConfirmTerm} disabled={busy} variant="destructive">
-                {confirmTerm.isPending ? "确认中…" : "确认终止"}
-              </Button>
-            ) : (
-              <Button
-                onClick={handleSubmit}
-                disabled={
-                  busy ||
-                  (mode !== "delete" && mode === currentMode && period === info.renewalPeriod)
-                }
-                variant={mode === "delete" ? "destructive" : "default"}
-              >
-                {busy ? "提交中…" : mode === "delete" ? "申请终止" : "保存"}
-              </Button>
-            ))}
+          {!info.renewalForced && (
+            <Button
+              onClick={handleSubmit}
+              disabled={
+                busy || (mode !== "delete" && mode === currentMode && period === info.renewalPeriod)
+              }
+              variant={mode === "delete" ? "destructive" : "default"}
+            >
+              {busy ? "提交中…" : "保存"}
+            </Button>
+          )}
         </DialogFooter>
       </DialogContent>
     </Dialog>

web/src/hooks/use-server-control.ts

@@ -126,34 +126,32 @@ export function useUpdateRenewal(serviceName: string) {
   });
 }
 
-/* ──────────── 服务终止(到期注销) ──────────── */
+/* ──────────── 到期终止策略 ──────────── */
 
 /**
- * 请求终止服务。OVH 会把确认 token 发到账户管理员邮箱，拿到后再调 confirm。
+ * 设置终止策略。
  *
- * 为什么「到期注销」不走 serviceInfos 的 renew 字段：那条路 OVH 会回
- * 400 "Arguments conflicting"，而且 OVH 自己的 issue 里记录着这组标志位
- * 行为不可预测（同一份 payload 发两次会在自动/手动之间来回跳）。
- * 终止是有专用端点的（POST /terminate + POST /confirmTermination），
- * 也是 OVH 控制台「Terminate my service」走的那条 —— 效果就是
- * 「取消续费，服务保留到当期结束后销毁」，正是这里要的语义。
+ * **不要**用 POST /terminate —— 那是「立即终止」，提交后 OVH 当场把服务器暂停，
+ * 并邮件通知「5 天内不付款就彻底清除硬盘数据」。这个坑真实踩过一次。
+ *
+ * OVH 的生命周期动作枚举把两件事分得很清楚：
+ *   terminate                  立即终止
+ *   terminateAtExpirationDate  到期终止（用到当期结束）
+ * 到期终止只能通过 PUT /services/{serviceId} 的 terminationPolicy 设置。
+ *
+ * policy 取值：
+ *   empty                      不终止 / 撤销已提交的到期终止
+ *   terminateAtExpirationDate  到期日终止
+ *   terminateAtEngagementDate  合同期结束时终止
  */
-export function useTerminateService(serviceName: string) {
+export function useUpdateTerminationPolicy(serviceName: string) {
+  const qc = useQueryClient();
   return useMutation({
-    mutationFn: async () =>
-      (await api.post(`/server-control/${serviceName}/terminate`)).data as {
+    mutationFn: async (vars: { policy: string }) =>
+      (await api.put(`/server-control/${serviceName}/termination-policy`, vars)).data as {
         success: boolean;
         message: string;
       },
-  });
-}
-
-/** 用邮件里的 token 确认终止 */
-export function useConfirmTermination(serviceName: string) {
-  const qc = useQueryClient();
-  return useMutation({
-    mutationFn: async (vars: { token: string; reason?: string; commentary?: string }) =>
-      (await api.post(`/server-control/${serviceName}/confirm-termination`, vars)).data,
     onSuccess: () => {
       qc.invalidateQueries({ queryKey: qk.serverControl.serviceInfo(serviceName) });
     },