@pmate/cli 0.24.25 → 0.24.26

package/dist/index.d.ts

@@ -1000,6 +1000,16 @@ type ServiceCommandArgs = {
     onlyKeys?: string[];
     baseUrl?: string;
     json: boolean;
+} | {
+    type: Command.Service;
+    action: "env-update-scope";
+    appId: string;
+    fromScope: string;
+    toScope: string;
+    overwrite: boolean;
+    onlyKeys?: string[];
+    baseUrl?: string;
+    json: boolean;
 };
 type VercelProjectsCommandArgs = {
     type: Command.Vercel;

package/dist/index.js

@@ -10050,6 +10050,19 @@ var AliyunService = class {
     );
     ui.success(`Created FC custom domain: ${input.domainName}`);
   }
+  static async deleteFcCustomDomain(domainName, region) {
+    const client = await this.createFcClient(region);
+    try {
+      await client.deleteCustomDomain(domainName);
+      ui.success(`Deleted FC custom domain: ${domainName}`);
+    } catch (error) {
+      if (this.isNotFoundError(error)) {
+        ui.warn(`FC custom domain not found: ${domainName}`);
+        return;
+      }
+      throw error;
+    }
+  }
   /** Add a DNS record via Aliyun DNS. */
   static async addRecord(input) {
     const userConfig = loadPmateConfig();
@@ -18110,6 +18123,7 @@ function readNamespaceFromPayload(payload) {
 var import_node_fs20 = require("fs");
 var import_promises6 = require("fs/promises");
 var import_node_path24 = __toESM(require("path"));
+var import_node_child_process11 = require("child_process");
 var import_promises7 = require("readline/promises");
 
 // src/services/ServiceRuntimeRunner.ts
@@ -19443,10 +19457,15 @@ var ServiceRuntimeRunner = class {
       return [];
     }
     const appId = `${service.namespace}:${service.name}`;
-    const items = await registry.listEnvItems(appId, {
+    const scopedItems = await registry.listEnvItems(appId, {
       scope: stage,
       includeSecretMeta: true
     });
+    const allItems = await registry.listEnvItems(appId, {
+      scope: "all",
+      includeSecretMeta: true
+    });
+    const items = [...allItems, ...scopedItems];
     const requiredEnv = Array.from(
       new Set(
         items.map((item) => item.key ?? item.name).filter((key) => typeof key === "string" && key.trim().length > 0).map((key) => key.trim())
@@ -19693,6 +19712,8 @@ var ServiceCommandHandler = class {
         return;
       }
       case "delete": {
+        const service = await registry.getService(args.namespace, args.name);
+        await this.deleteServiceResources(service);
         const record = await this.request(
           baseUrl,
           "DELETE",
@@ -19863,6 +19884,23 @@ var ServiceCommandHandler = class {
         this.renderJson(payload, args.json);
         return;
       }
+      case "env-update-scope": {
+        const payload = await this.request(
+          baseUrl,
+          "POST",
+          `${this.buildEnvBasePath(args.appId)}/update-scope`,
+          {
+            fromScope: args.fromScope,
+            toScope: args.toScope,
+            ...args.overwrite ? { overwrite: true } : {},
+            ...args.onlyKeys?.length ? { onlyKeys: args.onlyKeys } : {}
+          }
+        );
+        ui.success(`Updated env scope for ${args.appId}: ${args.fromScope} -> ${args.toScope}`);
+        await this.syncFcRequiredEnvFromServiceEnv(registry, args.appId, args.toScope);
+        this.renderJson(payload, args.json);
+        return;
+      }
     }
   }
   resolveBaseUrl(baseUrl) {
@@ -20014,10 +20052,7 @@ var ServiceCommandHandler = class {
     if (!("type" in service) || service.type !== "fc" || !service.fc) {
       return;
     }
-    const items = await registry.listEnvItems(appId, {
-      scope,
-      includeSecretMeta: true
-    });
+    const items = await this.listEffectiveEnvItems(registry, appId, scope);
     const requiredEnv = Array.from(
       new Set(
         items.map((item) => item.key ?? item.name).filter((key) => typeof key === "string" && key.trim().length > 0).map((key) => key.trim())
@@ -20039,6 +20074,20 @@ var ServiceCommandHandler = class {
     const normalizedRight = [...right].sort();
     return normalizedLeft.every((value, index) => value === normalizedRight[index]);
   }
+  async listEffectiveEnvItems(registry, appId, scope) {
+    const scopedItems = await registry.listEnvItems(appId, {
+      scope,
+      includeSecretMeta: true
+    });
+    if (scope === "all") {
+      return scopedItems;
+    }
+    const allItems = await registry.listEnvItems(appId, {
+      scope: "all",
+      includeSecretMeta: true
+    });
+    return [...allItems, ...scopedItems];
+  }
   renderList(items, asJson) {
     if (asJson) {
       ui.plain(JSON.stringify(items, null, 2));
@@ -20052,6 +20101,206 @@ var ServiceCommandHandler = class {
       ui.info(formatNamespacedDisplayId(item.namespace, item.name), item);
     }
   }
+  async deleteServiceResources(service) {
+    switch (this.getServiceType(service)) {
+      case "vite":
+      case "static":
+        await this.deleteStaticResources(service);
+        return;
+      case "node":
+      case "rust":
+      case "python":
+        await this.deleteServerResources(service);
+        return;
+      case "fc":
+        await this.deleteFcResources(service);
+        return;
+      case "ios":
+      case "android":
+        ui.warn(`Service type "${this.getServiceType(service)}" has no runtime resources to delete`);
+        return;
+      default:
+        throw new Error(`Unsupported service type for delete: ${this.getServiceType(service)}`);
+    }
+  }
+  async deleteStaticResources(service) {
+    const site = this.getStaticSiteConfig(service);
+    const bucketName = site.bucket?.trim();
+    const domainName = site.domain?.trim();
+    if (!bucketName) {
+      throw new Error(`Missing site.bucket for ${service.id}`);
+    }
+    if (!domainName) {
+      throw new Error(`Missing site.domain for ${service.id}`);
+    }
+    const subdomain = site.subdomain?.trim();
+    const rr = subdomain || "@";
+    const cdnDomain = subdomain ? `${subdomain}.${domainName}` : domainName;
+    const cname = await AliyunService.getCdnCname(cdnDomain);
+    if (cname) {
+      this.logDeletedRecords(
+        `Removed CNAME record for ${cdnDomain}`,
+        await AliyunService.deleteDomainRecords({
+          domainName,
+          rr,
+          type: "CNAME",
+          value: cname
+        })
+      );
+    } else {
+      ui.warn(`No CDN CNAME found for ${cdnDomain}; deleting matching CNAME records by host.`);
+      this.logDeletedRecords(
+        `Removed CNAME record for ${cdnDomain}`,
+        await AliyunService.deleteDomainRecords({
+          domainName,
+          rr,
+          type: "CNAME"
+        })
+      );
+    }
+    if (!subdomain) {
+      this.logDeletedRecords(
+        `Removed CNAME record for www.${domainName}`,
+        await AliyunService.deleteDomainRecords({
+          domainName,
+          rr: "www",
+          type: "CNAME",
+          value: domainName
+        })
+      );
+    }
+    await AliyunService.deleteCdnDomain(cdnDomain);
+    await AliyunService.deleteBucketAndContents(bucketName);
+  }
+  async deleteServerResources(service) {
+    const network = this.getNetworkConfig(service);
+    const subdomain = network.subdomain?.trim();
+    if (!subdomain) {
+      ui.warn(`No subdomain configured for ${service.id}; nothing to tear down on DNS/nginx.`);
+      return;
+    }
+    const server = network.server?.trim();
+    if (!server) {
+      throw new Error(`Missing network.server for ${service.id}`);
+    }
+    await this.removeRemoteConfig(server, `/etc/nginx/sites-enabled/${subdomain}.conf`);
+    ui.success(`Removed nginx config for ${subdomain} from ${server}`);
+    await this.reloadNginx(server);
+    ui.success(`Reloaded nginx on ${server}`);
+    const domainName = network.domain?.trim() || "pmate.chat";
+    const serverAddress = await resolveServerAddress(server);
+    this.logDeletedRecords(
+      `Removed A record for ${subdomain}.${domainName}`,
+      await AliyunService.deleteDomainRecords({
+        domainName,
+        rr: subdomain,
+        type: "A",
+        value: serverAddress
+      })
+    );
+  }
+  async deleteFcResources(service) {
+    const fc = this.getFcConfig(service);
+    const domainName = fc.domain?.trim();
+    if (!domainName) {
+      ui.warn(`No fc.domain configured for ${service.id}; nothing to tear down on DNS/FC custom domain.`);
+      return;
+    }
+    const region = fc.region?.trim();
+    if (!region) {
+      throw new Error(`Missing fc.region for ${service.id}`);
+    }
+    const subdomain = fc.subdomain?.trim();
+    const rr = subdomain || "@";
+    const host = subdomain ? `${subdomain}.${domainName}` : domainName;
+    await AliyunService.deleteFcCustomDomain(host, region);
+    const accountId = await AliyunService.getAccountId();
+    this.logDeletedRecords(
+      `Removed CNAME record for ${host}`,
+      await AliyunService.deleteDomainRecords({
+        domainName,
+        rr,
+        type: "CNAME",
+        value: `${accountId}.${region}.fc.aliyuncs.com`
+      })
+    );
+  }
+  getServiceType(service) {
+    return "runtimeType" in service ? service.runtimeType : service.type;
+  }
+  getStaticSiteConfig(service) {
+    if ("runtimeType" in service) {
+      return {
+        bucket: service.deploy?.bucket,
+        domain: service.deploy?.domain,
+        subdomain: service.deploy?.subdomain
+      };
+    }
+    return service.site ?? {};
+  }
+  getNetworkConfig(service) {
+    if ("runtimeType" in service) {
+      return {
+        server: service.deploy?.server,
+        domain: service.deploy?.domain,
+        subdomain: service.deploy?.subdomain
+      };
+    }
+    return service.network ?? {};
+  }
+  getFcConfig(service) {
+    if ("runtimeType" in service) {
+      return {
+        region: void 0,
+        domain: service.deploy?.domain,
+        subdomain: service.deploy?.subdomain
+      };
+    }
+    return service.fc ?? {};
+  }
+  logDeletedRecords(message, deletedCount) {
+    if (deletedCount > 0) {
+      ui.success(message, { deletedCount });
+      return;
+    }
+    ui.warn(`${message} skipped`, { deletedCount });
+  }
+  removeRemoteConfig(server, remotePath) {
+    return new Promise((resolve, reject) => {
+      const target = `pmate@${server}`;
+      const child = (0, import_node_child_process11.spawn)("ssh", [target, "sudo", "rm", "-f", remotePath], {
+        stdio: ["ignore", "inherit", "inherit"]
+      });
+      child.on("error", (error) => {
+        reject(error);
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+          return;
+        }
+        reject(new Error(`ssh to ${server} exited with code ${code}`));
+      });
+    });
+  }
+  reloadNginx(server) {
+    return new Promise((resolve, reject) => {
+      const target = `pmate@${server}`;
+      const child = (0, import_node_child_process11.spawn)("ssh", [target, "sudo", "nginx", "-s", "reload"], {
+        stdio: ["ignore", "inherit", "inherit"]
+      });
+      child.on("error", (error) => {
+        reject(error);
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+          return;
+        }
+        reject(new Error(`nginx reload on ${server} exited with code ${code}`));
+      });
+    });
+  }
   renderJson(value, asJson) {
     if (!asJson) {
       return;
@@ -20061,9 +20310,9 @@ var ServiceCommandHandler = class {
 };
 
 // src/commands/VercelCommandHandler.ts
-var import_node_child_process11 = require("child_process");
+var import_node_child_process12 = require("child_process");
 var import_node_util2 = require("util");
-var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process11.execFile);
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process12.execFile);
 function parseDeploymentTimestamp(deployment) {
   const candidates = [deployment.createdAt, deployment.readyAt, deployment.ready];
   for (const value of candidates) {
@@ -22594,7 +22843,7 @@ function parseServiceEnvArgs(appId, tokens) {
   const rest = [...tokens];
   const action = rest.shift();
   if (!action) {
-    throw new Error("Usage: service <ns:app> env list|get|set|unset|resolve|pull|copy-from");
+    throw new Error("Usage: service <ns:app> env list|get|set|unset|resolve|pull|copy-from|update-scope");
   }
   let baseUrl;
   let json = false;
@@ -22824,6 +23073,53 @@ function parseServiceEnvArgs(appId, tokens) {
     }
     return { type: "service" /* Service */, action: "env-copy-from", targetAppId: appId, sourceAppId, scope, includeSecret, overwrite, onlyKeys, baseUrl, json };
   }
+  if (action === "update-scope") {
+    let fromScope;
+    let toScope;
+    let overwrite = false;
+    let onlyKeys;
+    while (rest.length > 0) {
+      const token = rest.shift();
+      switch (token) {
+        case "--from":
+        case "--from-scope":
+          fromScope = requireValue6(rest, token);
+          break;
+        case "--to":
+        case "--to-scope":
+          toScope = requireValue6(rest, token);
+          break;
+        case "--overwrite":
+          overwrite = true;
+          break;
+        case "--only":
+          onlyKeys = requireValue6(rest, token).split(",").map((item) => item.trim()).filter(Boolean);
+          break;
+        case "--base-url":
+          baseUrl = requireValue6(rest, token);
+          break;
+        case "--json":
+          json = true;
+          break;
+        default:
+          throw new Error(`Unknown service env update-scope option: ${token}`);
+      }
+    }
+    if (!fromScope || !toScope) {
+      throw new Error("Usage: service <ns:app> env update-scope --from <scope> --to <scope> [--overwrite] [--only <key,key>] [--base-url <url>] [--json]");
+    }
+    return {
+      type: "service" /* Service */,
+      action: "env-update-scope",
+      appId,
+      fromScope,
+      toScope,
+      overwrite,
+      onlyKeys,
+      baseUrl,
+      json
+    };
+  }
   throw new Error(`Unknown service env action: ${action}`);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/cli",
-  "version": "0.24.25",
+  "version": "0.24.26",
   "description": "CLI utilities for the pMate project",
   "license": "MIT",
   "bin": {