fix(ui): show subscription status on domains list

Reviewed-on: http://gitea.lan:3000/robbond/pleskSaas/pulls/9

app/api/plesk/domains/[id]/action/route.ts

@@ -0,0 +1,147 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+
+import { assertAgencyAdmin, getRouteAgencyContextOrThrow } from "@/lib/agency";
+import { assertRateLimit } from "@/lib/api/rate-limit";
+import { assertSameOrigin } from "@/lib/api/security";
+import {
+  suspendPleskSubscription,
+  unsuspendPleskSubscription,
+} from "@/lib/plesk/client";
+import { createSupabaseRouteClient } from "@/lib/supabase/route";
+
+const actionSchema = z.object({
+  action: z.enum(["suspend", "unsuspend"]),
+});
+
+export async function POST(
+  req: Request,
+  { params }: { params: { id: string } },
+) {
+  const supabase = createSupabaseRouteClient() as any;
+  let context: Awaited<ReturnType<typeof getRouteAgencyContextOrThrow>> | null =
+    null;
+  let domain: { id: string; subscription_id: string | null } | null = null;
+  let subscription: { id: string; plesk_subscription_id: string } | null = null;
+  let requestedAction: "suspend" | "unsuspend" | null = null;
+
+  try {
+    assertSameOrigin(req);
+
+    context = await getRouteAgencyContextOrThrow();
+    assertAgencyAdmin(context);
+    assertRateLimit(`plesk-domain-action:${context.userId}`, 10, 60_000);
+
+    const { action } = actionSchema.parse(await req.json());
+    requestedAction = action;
+
+    const { data: domainRow, error: domainError } = await supabase
+      .from("plesk_domains")
+      .select("id, agency_id, plesk_instance_id, subscription_id")
+      .eq("id", params.id)
+      .eq("agency_id", context.agencyId)
+      .single();
+
+    if (domainError || !domainRow) {
+      throw new Error("Domain not found");
+    }
+
+    domain = {
+      id: String(domainRow.id),
+      subscription_id: domainRow.subscription_id
+        ? String(domainRow.subscription_id)
+        : null,
+    };
+
+    if (!domain.subscription_id) {
+      throw new Error("Domain is not linked to a subscription");
+    }
+
+    const { data: subscriptionRow, error: subscriptionError } = await supabase
+      .from("plesk_subscriptions")
+      .select("id, plesk_subscription_id, plesk_instance_id")
+      .eq("id", domain.subscription_id)
+      .eq("agency_id", context.agencyId)
+      .single();
+
+    if (subscriptionError || !subscriptionRow) {
+      throw new Error("Subscription not found");
+    }
+
+    subscription = {
+      id: String(subscriptionRow.id),
+      plesk_subscription_id: String(subscriptionRow.plesk_subscription_id),
+    };
+
+    const { data: instance, error: instanceError } = await supabase
+      .from("plesk_instances")
+      .select("id, base_url, auth_type, encrypted_secret")
+      .eq("id", subscriptionRow.plesk_instance_id)
+      .eq("agency_id", context.agencyId)
+      .single();
+
+    if (instanceError || !instance) {
+      throw new Error("Plesk instance not found");
+    }
+
+    const connection = {
+      baseUrl: instance.base_url,
+      authType: instance.auth_type,
+      encryptedSecret: instance.encrypted_secret,
+    } as const;
+
+    if (action === "suspend") {
+      await suspendPleskSubscription(
+        connection,
+        subscription.plesk_subscription_id,
+      );
+    } else {
+      await unsuspendPleskSubscription(
+        connection,
+        subscription.plesk_subscription_id,
+      );
+    }
+
+    await supabase.from("actions_log").insert({
+      agency_id: context.agencyId,
+      actor_user_id: context.userId,
+      target_type: "plesk_domain",
+      target_id: domain.id,
+      action: `domain_${action}`,
+      status: "success",
+      metadata: {
+        domain_id: domain.id,
+        subscription_id: subscription.id,
+        plesk_subscription_id: subscription.plesk_subscription_id,
+      },
+    });
+
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    if (context && domain) {
+      const message =
+        error instanceof Error ? error.message : "Domain action failed";
+      await supabase.from("actions_log").insert({
+        agency_id: context.agencyId,
+        actor_user_id: context.userId,
+        target_type: "plesk_domain",
+        target_id: domain.id,
+        action: requestedAction ? `domain_${requestedAction}` : "domain_action",
+        status: "failed",
+        error_message: message,
+        metadata: {
+          domain_id: domain.id,
+          subscription_id: subscription?.id ?? domain.subscription_id,
+          plesk_subscription_id: subscription?.plesk_subscription_id ?? null,
+        },
+      });
+    }
+
+    return NextResponse.json(
+      {
+        error: error instanceof Error ? error.message : "Domain action failed",
+      },
+      { status: 400 },
+    );
+  }
+}

app/dashboard/page.tsx

@@ -3,7 +3,6 @@ import { DashboardControls } from "@/components/dashboard/dashboard-controls";
 import { getServerAgencyContextOrRedirect } from "@/lib/agency";
 import type { Database } from "@/lib/types";
 import { createSupabaseServerClient } from "@/lib/supabase/server";
-import type { PostgrestError } from "@supabase/supabase-js";
 
 type AgencySummary = Pick<
   Database["public"]["Tables"]["agencies"]["Row"],
@@ -51,7 +50,7 @@ export default async function DashboardPage() {
     supabase
       .from("plesk_domains")
       .select(
-        "id, plesk_instance_id, domain_name, status, hosting_type, source_created_at, aliases_count, updated_at",
+        "id, plesk_instance_id, subscription_id, status, domain_name, hosting_type, source_created_at, aliases_count, updated_at, subscription:plesk_subscriptions(status)",
       )
       .eq("agency_id", context.agencyId)
       .order("updated_at", { ascending: false })
@@ -101,12 +100,16 @@ export default async function DashboardPage() {
       data: Array<{
         id: string;
         plesk_instance_id: string;
+        subscription_id: string | null;
         domain_name: string;
         status: string | null;
         hosting_type: string | null;
         source_created_at: string | null;
         aliases_count: number | null;
         updated_at: string;
+        subscription: {
+          status: string | null;
+        } | null;
       }> | null;
     },
     { data: BillingSummary | null },
@@ -167,7 +170,16 @@ export default async function DashboardPage() {
       <DashboardControls
         instances={instances ?? []}
         subscriptions={subscriptions ?? []}
-        domains={domains ?? []}
+        domains={(domains ?? []).map((domain) => {
+          const joinedStatus = Array.isArray(domain.subscription)
+            ? domain.subscription[0]?.status
+            : domain.subscription?.status;
+
+          return {
+            ...domain,
+            status: joinedStatus ?? "unknown",
+          };
+        })}
         autoSyncByInstance={Object.fromEntries(autoSyncByInstance.entries())}
       />
     </main>

components/dashboard/dashboard-controls.tsx

@@ -31,6 +31,7 @@ type Subscription = {
 type Domain = {
   id: string;
   plesk_instance_id: string;
+  subscription_id: string | null;
   domain_name: string;
   status: string | null;
   hosting_type: string | null;
@@ -52,23 +53,45 @@ type Props = {
 function getDomainStatusBadge(status: string | null) {
   const normalized = (status ?? "unknown").toLowerCase();
 
-  if (
-    normalized.includes("active") ||
-    normalized.includes("ok") ||
-    normalized.includes("enabled")
-  ) {
-    return "bg-emerald-100 text-emerald-700";
-  }
-
-  if (normalized.includes("suspended") || normalized.includes("disabled")) {
+  if (normalized.includes("suspend") || normalized.includes("disabled")) {
     return "bg-rose-100 text-rose-700";
   }
 
-  if (normalized.includes("inactive")) return "bg-amber-100 text-amber-700";
+  if (normalized.includes("expired")) {
+    return "bg-amber-100 text-amber-700";
+  }
+
+  if (normalized.includes("active") || normalized.includes("enabled")) {
+    return "bg-emerald-100 text-emerald-700";
+  }
+
+  if (normalized.includes("ok")) {
+    return "bg-emerald-100 text-emerald-700";
+  }
 
   return "bg-slate-100 text-slate-600";
 }
 
+function isDomainSuspended(status: string | null) {
+  const normalized = (status ?? "unknown").toLowerCase();
+  return normalized.includes("suspend") || normalized.includes("disabled");
+}
+
+function isDomainActive(status: string | null) {
+  const normalized = (status ?? "unknown").toLowerCase();
+  return (
+    normalized.includes("active") ||
+    normalized.includes("ok") ||
+    normalized.includes("enabled")
+  );
+}
+
+function getDomainHref(domainName: string) {
+  const normalized = domainName.trim();
+  if (/^https?:\/\//i.test(normalized)) return normalized;
+  return `https://${normalized}`;
+}
+
 export function DashboardControls({
   instances,
   subscriptions,
@@ -215,6 +238,25 @@ export function DashboardControls({
     }
   }
 
+  async function onDomainAction(
+    domainId: string,
+    action: "suspend" | "unsuspend",
+  ) {
+    setLoading(true);
+    setMessage(null);
+    try {
+      await runRequest(`/api/plesk/domains/${domainId}/action`, { action });
+      setMessage("Domain action completed.");
+      window.location.reload();
+    } catch (error) {
+      setMessage(
+        error instanceof Error ? error.message : "Domain action failed",
+      );
+    } finally {
+      setLoading(false);
+    }
+  }
+
   async function onCheckout() {
     setLoading(true);
     try {
@@ -501,7 +543,7 @@ export function DashboardControls({
           {message ? <p className="text-sm text-slate-600">{message}</p> : null}
         </div>
 
-        <div className="space-y-3 rounded-xl border border-slate-200 bg-white p-4">
+        <div className="space-y-3 rounded-xl border border-slate-200 bg-white p-4 lg:col-span-2">
           <div className="flex flex-wrap items-end gap-2">
             <div className="flex-1 min-w-[220px]">
               <label className="text-sm font-medium">Search domains</label>
@@ -538,25 +580,38 @@ export function DashboardControls({
               <thead>
                 <tr className="border-b border-slate-200 text-xs uppercase text-slate-500">
                   <th className="px-2 py-2">Domain</th>
-                  <th className="px-2 py-2">Status</th>
+                  <th className="px-2 py-2">Subscription Status</th>
                   <th className="px-2 py-2">Hosting</th>
                   <th className="px-2 py-2">Created</th>
                   <th className="px-2 py-2">Aliases</th>
                   <th className="px-2 py-2">Last seen</th>
+                  <th className="px-2 py-2">Actions</th>
                 </tr>
               </thead>
               <tbody>
                 {filteredDomains.length === 0 ? (
                   <tr>
-                    <td className="px-2 py-3 text-slate-500" colSpan={6}>
+                    <td className="px-2 py-3 text-slate-500" colSpan={7}>
                       No domains found.
                     </td>
                   </tr>
                 ) : (
                   filteredDomains.map((domain) => (
                     <tr key={domain.id} className="border-b border-slate-100">
-                      <td className="font-medium text-slate-900">
+                      <td className="px-2 py-2 font-medium text-slate-900">
+                        <a
+                          href={getDomainHref(domain.domain_name)}
+                          target="_blank"
+                          rel="noopener noreferrer"
+                          className="underline decoration-slate-300 underline-offset-2 hover:text-brand-700"
+                        >
                           {domain.domain_name}
+                        </a>
+                        {domain.subscription_id ? (
+                          <p className="text-xs font-normal text-slate-500">
+                            Subscription: {domain.subscription_id}
+                          </p>
+                        ) : null}
                       </td>
                       <td className="px-2 py-2">
                         <span
@@ -575,6 +630,28 @@ export function DashboardControls({
                       <td className="px-2 py-2">
                         {formatDateTime(domain.updated_at)}
                       </td>
+                      <td className="px-2 py-2">
+                        <div className="flex gap-2">
+                          <button
+                            onClick={() => onDomainAction(domain.id, "suspend")}
+                            disabled={
+                              loading || isDomainSuspended(domain.status)
+                            }
+                            className="rounded border border-rose-300 px-2 py-1 text-xs text-rose-700 disabled:cursor-not-allowed disabled:opacity-60"
+                          >
+                            Suspend
+                          </button>
+                          <button
+                            onClick={() =>
+                              onDomainAction(domain.id, "unsuspend")
+                            }
+                            disabled={loading || isDomainActive(domain.status)}
+                            className="rounded border border-emerald-300 px-2 py-1 text-xs text-emerald-700 disabled:cursor-not-allowed disabled:opacity-60"
+                          >
+                            Unsuspend
+                          </button>
+                        </div>
+                      </td>
                     </tr>
                   ))
                 )}

docs/ai-project-context.md

@@ -0,0 +1,230 @@
+# Project: Plesk Agency Portal
+
+This project is a multi-tenant SaaS platform that allows agencies to manage multiple Plesk servers from a single dashboard.
+
+The application synchronizes subscriptions and domains from Plesk instances and allows administrators to manage hosting accounts.
+
+---
+
+# Technology Stack
+
+Frontend
+
+- Next.js (App Router)
+- React
+- TypeScript
+
+Backend
+
+- Next.js API routes
+- Node runtime
+
+Database
+
+- Supabase Postgres
+
+Authentication
+
+- Supabase Auth (magic link)
+
+External Integrations
+
+- Plesk REST API
+- Plesk CLI
+- Stripe (future billing integration)
+
+Development Tools
+
+- Git
+- Docker (for some services)
+- Jenkins (future CI/CD)
+
+---
+
+# Core Database Tables
+
+agencies
+
+agency_members
+
+plesk_instances
+
+plesk_subscriptions
+
+plesk_domains
+
+actions_log
+
+billing_accounts
+
+---
+
+# Multi-Tenant Model
+
+Each user belongs to an agency.
+
+Agency relationships:
+
+user  
+→ agency_members  
+→ agencies  
+→ plesk_instances  
+→ plesk_subscriptions  
+→ plesk_domains
+
+Row Level Security in Supabase ensures users can only access rows belonging to their agency.
+
+Never bypass or remove RLS policies.
+
+---
+
+# Plesk Integration
+
+The system integrates with Plesk using both:
+
+Plesk REST API  
+Plesk CLI
+
+Common CLI commands used:
+
+subscription --info  
+subscription --suspend  
+subscription --unsuspend
+
+CLI output must always be parsed defensively because formatting can vary between Plesk versions.
+
+---
+
+# Sync System
+
+The platform supports manual synchronization of Plesk instances.
+
+During sync the system:
+
+1. Connects to a Plesk instance
+2. Retrieves subscriptions and domains
+3. Updates records in Supabase
+4. Updates the dashboard
+
+Future development will include background sync workers.
+
+---
+
+# Dashboard Features
+
+Current features include:
+
+Connecting Plesk instances  
+Testing connections  
+Manual sync  
+Listing domains and subscriptions  
+Suspending subscriptions  
+Unsuspending subscriptions
+
+---
+
+# Logging
+
+Operational actions are written to:
+
+actions_log
+
+Examples include:
+
+instance_connected  
+sync_started  
+sync_completed  
+subscription_suspended  
+subscription_unsuspended
+
+Logging should never block primary workflows.
+
+---
+
+# Development Rules
+
+When implementing features:
+
+Search the repository before modifying code.
+
+Extend existing architecture rather than rewriting systems.
+
+Avoid introducing breaking database schema changes.
+
+Prefer small modular functions.
+
+Keep API routes thin.
+
+Place integration logic inside lib folders.
+
+---
+
+# Git Workflow
+
+Default branch:
+
+master
+
+All work must be done on feature branches.
+
+Example:
+
+git checkout master  
+git pull  
+git checkout -b feature/<feature-name>
+
+Never commit directly to master.
+
+---
+
+# Error Handling
+
+External integrations must always fail gracefully.
+
+If a single subscription fails during sync, the rest of the sync must continue.
+
+All failures should be logged.
+
+---
+
+# UI Safety
+
+Dashboard components must:
+
+Handle null values safely  
+Avoid crashing if API responses change  
+Use status badges instead of raw text for statuses
+
+---
+
+# Future Roadmap
+
+Upcoming development milestones include:
+
+CL4 – Subscription status ingestion via CLI
+
+CL5 – Action logging and retry queue
+
+CL6 – Automatic sync worker
+
+CL7 – Stripe billing enforcement
+
+CL8 – Instance health monitoring
+
+CL9 – Observability and audit improvements
+
+---
+
+# AI Agent Instructions
+
+Before modifying code:
+
+Search the repository for related implementations.
+
+Avoid rewriting working systems.
+
+Implement minimal safe modifications.
+
+Always verify that existing features continue working.
+
+If unsure about a change, prefer logging rather than failing.

docs/system-architecture.md

@@ -0,0 +1,179 @@
+# System Architecture
+
+This document describes the architecture of the Plesk Agency Portal SaaS platform.
+
+The platform allows agencies to connect multiple Plesk servers and manage hosting subscriptions from a single dashboard.
+
+---
+
+# High Level Components
+
+The system consists of the following components:
+
+Frontend Dashboard  
+Backend API  
+Supabase Database  
+Plesk Servers  
+Future Worker Services  
+Future Billing Integration
+
+At a high level, users interact with the Frontend Dashboard, which sends authenticated requests to the Backend API (Next.js API routes). The backend reads and writes persistent state in Supabase, and executes remote operations against connected Plesk servers via API/CLI integrations. Future worker services will run asynchronous sync and retry workflows, while future billing integration will enforce plan limits and subscription state.
+
+---
+
+# Frontend
+
+The frontend is a Next.js application using the App Router.
+
+Responsibilities include:
+
+User authentication  
+Dashboard interface  
+Displaying domains and subscriptions  
+Triggering sync operations  
+Sending management actions (suspend / unsuspend)
+
+The frontend communicates with backend API routes.
+
+---
+
+# Backend
+
+The backend uses Next.js API routes.
+
+Responsibilities include:
+
+Handling authenticated requests  
+Connecting to Supabase  
+Executing Plesk API and CLI commands  
+Processing sync operations  
+Writing operational logs
+
+Business logic should be implemented in reusable modules inside the lib directory.
+
+---
+
+# Database
+
+Supabase Postgres is used for persistent storage.
+
+Key tables include:
+
+agencies  
+agency_members  
+plesk_instances  
+plesk_subscriptions  
+plesk_domains  
+actions_log  
+billing_accounts
+
+Relationship overview:
+
+- `agencies` is the tenant root.
+- `agency_members` associates users to agencies and roles.
+- `plesk_instances` stores connected remote Plesk endpoints per agency.
+- `plesk_subscriptions` stores subscription-level records linked to instances.
+- `plesk_domains` stores domain-level records linked to subscriptions/instances.
+- `actions_log` stores operational/audit events.
+- `billing_accounts` stores plan/subscription billing state per agency.
+
+The multi-tenant model is enforced using Supabase Row Level Security policies so users can only read/write rows that belong to their agency.
+
+---
+
+# Plesk Integration
+
+The platform communicates with remote Plesk servers.
+
+Integration methods:
+
+Plesk REST API  
+Plesk CLI commands
+
+Typical operations include:
+
+Listing subscriptions  
+Retrieving domain data  
+Suspending subscriptions  
+Unsuspending subscriptions
+
+CLI parsing must be defensive due to formatting differences between Plesk versions.
+
+---
+
+# Sync System
+
+The system supports synchronization of Plesk servers.
+
+Manual sync is triggered from the dashboard.
+
+During sync:
+
+The backend connects to a Plesk instance  
+Subscription and domain data are retrieved  
+Records are updated in Supabase  
+The dashboard displays updated data
+
+Future development will add automated background sync workers.
+
+---
+
+# Logging System
+
+Operational actions are recorded in the actions_log table.
+
+Examples:
+
+instance_connected  
+sync_started  
+sync_completed  
+subscription_suspended  
+subscription_unsuspended
+
+Logging supports debugging and auditability.
+
+---
+
+# Future Worker Architecture
+
+Future versions of the system will include background workers for:
+
+Automatic instance synchronization  
+Retry queues  
+Monitoring tasks
+
+Workers may run as:
+
+Cron jobs  
+Queue processors  
+Dedicated worker services
+
+---
+
+# Billing Architecture (Future)
+
+Stripe will be integrated for SaaS billing.
+
+Billing responsibilities will include:
+
+Agency subscription plans  
+Usage limits  
+Payment handling
+
+Billing enforcement will eventually control:
+
+Number of connected Plesk instances  
+Number of managed domains
+
+---
+
+# Development Philosophy
+
+The system prioritizes:
+
+Stability  
+Security  
+Multi-tenant isolation  
+Safe integrations with external systems
+
+Developers should extend existing systems rather than rewriting them.

lib/plesk/client.ts

@@ -9,12 +9,15 @@ export type PleskConnection = {
 };
 
 export type PleskSubscription = {
+  plesk_subscription_id?: string;
   id?: string | number;
   guid?: string;
   subscription_id?: string | number;
   external_id?: string;
   name?: string;
   status?: string;
+  status_raw?: string | null;
+  status_sync_error?: string | null;
   owner_login?: string;
   owner?: { login?: string };
   plan_name?: string;
@@ -137,51 +140,95 @@ export async function testPleskConnection(connection: PleskConnection) {
 }
 
 export async function listPleskSubscriptions(connection: PleskConnection) {
-  try {
-    const all: PleskSubscription[] = [];
+  const listResult = await pleskCliCall(connection, "subscription", ["--list"]);
 
-    for (let page = 1; page <= 20; page += 1) {
-      const payload = await pleskRequest<PleskSubscription[]>(
-        connection,
-        `/api/v2/subscriptions?page=${page}&per_page=100`,
-      );
-      const rows = Array.isArray(payload) ? payload : [];
-      all.push(...rows);
-      if (rows.length < 100) break;
-    }
-
-    return all;
-  } catch {
-    const cli = await pleskRequest<PleskCliResult>(
-      connection,
-      "/api/v2/cli/subscription/call",
-      {
-        method: "POST",
-        body: JSON.stringify({ params: ["--list"] }),
-      },
-    );
-
-    const stdout = cli?.stdout ?? "";
-    if (!stdout.trim()) {
-      return [];
-    }
-
-    return stdout
+  const subscriptionNames = (listResult.stdout ?? "")
     .split(/\r?\n/)
     .map((line) => line.trim())
-      .filter(Boolean)
-      .map((line) => {
-        const columns = line.split(/\s+/);
-        const externalId = columns[0] ?? line;
-        return {
-          id: externalId,
-          subscription_id: externalId,
-          external_id: externalId,
-          name: columns.slice(1).join(" ") || externalId,
-          status: null,
-        };
+    .filter(Boolean);
+
+  const subscriptions: PleskSubscription[] = [];
+
+  for (const subscriptionName of subscriptionNames.slice(0, 500)) {
+    let status: "active" | "suspended" | "disabled" | "expired" | "unknown" =
+      "unknown";
+    let statusRaw: string | null = null;
+    let statusSyncError: string | null = null;
+
+    try {
+      const infoResult = await pleskCliCall(connection, "subscription", [
+        "--info",
+        subscriptionName,
+      ]);
+      const parsed = parseSubscriptionStatusDetailsFromInfo(
+        infoResult.stdout ?? "",
+      );
+      status = parsed.status;
+      statusRaw = parsed.statusRaw;
+    } catch (error) {
+      status = "unknown";
+      statusSyncError =
+        error instanceof Error
+          ? error.message.slice(0, 1000)
+          : "status_sync_failed";
+    }
+
+    subscriptions.push({
+      plesk_subscription_id: subscriptionName,
+      subscription_id: subscriptionName,
+      name: subscriptionName,
+      status,
+      status_raw: statusRaw,
+      status_sync_error: statusSyncError,
     });
   }
+
+  return subscriptions;
+}
+
+export function parseSubscriptionStatusDetailsFromInfo(stdout: string): {
+  status: "active" | "suspended" | "disabled" | "expired" | "unknown";
+  statusRaw: string | null;
+} {
+  const line = stdout
+    .split(/\r?\n/)
+    .map((entry) => entry.trim())
+    .find((entry) => /^domain\s+status\s*:/i.test(entry));
+
+  if (!line) {
+    return { status: "unknown", statusRaw: null };
+  }
+
+  const value = line.replace(/^domain\s+status\s*:/i, "").trim();
+  const normalized = value.toLowerCase();
+
+  if (normalized.includes("expired")) {
+    return { status: "expired", statusRaw: value };
+  }
+
+  if (normalized.includes("disabled")) {
+    return { status: "disabled", statusRaw: value };
+  }
+
+  if (normalized.includes("suspend")) {
+    return { status: "suspended", statusRaw: value };
+  }
+
+  if (
+    normalized.includes("ok") ||
+    normalized.includes("active") ||
+    normalized.includes("enabled")
+  ) {
+    return { status: "active", statusRaw: value };
+  }
+
+  return { status: "unknown", statusRaw: value };
+}
+
+export function parseSubscriptionStatusFromInfo(
+  stdout: string,
+): "active" | "suspended" | "disabled" | "expired" | "unknown" {
+  return parseSubscriptionStatusDetailsFromInfo(stdout).status;
 }
 
 export async function pleskCliCall(

lib/plesk/sync.ts

@@ -32,6 +32,31 @@ export async function syncPleskInstance(
 ): Promise<SyncResult> {
   const startedAtIso = new Date().toISOString();
 
+  const logStatusSyncEvent = async (
+    eventAction:
+      | "subscription_status_sync_started"
+      | "subscription_status_sync_completed"
+      | "subscription_status_sync_failed",
+    metadata?: Record<string, unknown>,
+    status: "success" | "failed" = "success",
+    errorMessage?: string | null,
+  ) => {
+    try {
+      await supabase.from("actions_log").insert({
+        agency_id: instance.agency_id,
+        actor_user_id: actorUserId ?? null,
+        target_type: "plesk_instance",
+        target_id: instance.id,
+        action: eventAction,
+        status,
+        error_message: errorMessage ?? null,
+        metadata: metadata ?? {},
+      });
+    } catch {
+      // Logging should never block sync flow.
+    }
+  };
+
   await supabase
     .from("plesk_instances")
     .update({
@@ -67,6 +92,10 @@ export async function syncPleskInstance(
   }
 
   try {
+    await logStatusSyncEvent("subscription_status_sync_started", {
+      started_at: startedAtIso,
+    });
+
     const [subscriptionsRaw, domainsRaw] = await Promise.all([
       listPleskSubscriptions({
         baseUrl: instance.base_url,
@@ -82,14 +111,21 @@ export async function syncPleskInstance(
 
     const subscriptionsForUpsert = subscriptionsRaw
       .map((item: any) => {
-        const sourceId = item?.id ?? item?.guid ?? item?.subscription_id;
+        const sourceId =
+          item?.plesk_subscription_id ??
+          item?.name ??
+          item?.id ??
+          item?.guid ??
+          item?.subscription_id;
         if (!sourceId) return null;
         return {
           agency_id: instance.agency_id,
           plesk_instance_id: instance.id,
           plesk_subscription_id: String(sourceId),
-          name: item?.name ? String(item.name) : null,
-          status: item?.status ? String(item.status) : null,
+          name: item?.name ? String(item.name) : String(sourceId),
+          status: item?.status ? String(item.status) : "unknown",
+          status_raw: item?.status_raw ? String(item.status_raw) : null,
+          last_status_sync_at: startedAtIso,
           owner_login: item?.owner_login
             ? String(item.owner_login)
             : item?.owner?.login
@@ -104,6 +140,10 @@ export async function syncPleskInstance(
       })
       .filter(Boolean) as Array<Record<string, unknown>>;
 
+    const subscriptionStatusSyncFailures = subscriptionsRaw.filter(
+      (item: any) => Boolean(item?.status_sync_error),
+    );
+
     if (subscriptionsForUpsert.length > 0) {
       const { error } = await supabase
         .from("plesk_subscriptions")
@@ -216,6 +256,40 @@ export async function syncPleskInstance(
       },
     });
 
+    await logStatusSyncEvent("subscription_status_sync_completed", {
+      synced_subscriptions: subscriptionsRaw.length,
+      failed_subscriptions: subscriptionStatusSyncFailures.length,
+      failed_subscription_ids: subscriptionStatusSyncFailures
+        .slice(0, 50)
+        .map((item: any) =>
+          String(
+            item?.plesk_subscription_id ?? item?.subscription_id ?? "unknown",
+          ),
+        ),
+      completed_at: new Date().toISOString(),
+    });
+
+    if (subscriptionStatusSyncFailures.length > 0) {
+      await logStatusSyncEvent(
+        "subscription_status_sync_failed",
+        {
+          failed_subscriptions: subscriptionStatusSyncFailures.length,
+          sample_errors: subscriptionStatusSyncFailures
+            .slice(0, 20)
+            .map((item: any) => ({
+              subscription: String(
+                item?.plesk_subscription_id ??
+                  item?.subscription_id ??
+                  "unknown",
+              ),
+              error: String(item?.status_sync_error ?? "status_sync_failed"),
+            })),
+        },
+        "failed",
+        `${subscriptionStatusSyncFailures.length} subscription status sync failures`,
+      );
+    }
+
     return {
       instanceId: instance.id,
       agencyId: instance.agency_id,
@@ -227,6 +301,15 @@ export async function syncPleskInstance(
     const message =
       error instanceof Error ? error.message.slice(0, 1000) : "Sync failed";
 
+    await logStatusSyncEvent(
+      "subscription_status_sync_failed",
+      {
+        failed_at: new Date().toISOString(),
+      },
+      "failed",
+      message,
+    );
+
     await supabase
       .from("plesk_instances")
       .update({

supabase/migrations/CL37_domain_status_backfill_from_subscription.sql

@@ -1,6 +1,10 @@
 -- One-time backfill: align existing domain status with linked subscription status
 update public.plesk_domains d
-set status = s.status
+set status = coalesce(s.status, 'unknown')
 from public.plesk_subscriptions s
 where d.subscription_id = s.id
   and d.agency_id = s.agency_id;
+
+update public.plesk_subscriptions
+set status = 'unknown'
+where status is null;

supabase/migrations/CL4_subscription_status_fields.sql

@@ -0,0 +1,8 @@
+alter table public.plesk_subscriptions
+add column if not exists status text default 'unknown',
+add column if not exists status_raw text,
+add column if not exists last_status_sync_at timestamptz;
+
+update public.plesk_subscriptions
+set status = 'unknown'
+where status is null;