@alauda-fe/workload-util-shared 0.0.7 → 0.0.9

package/esm2022/lib/directives/index.mjs

@@ -1,3 +1,2 @@
-export * from './oam-resource-disabled-container.directive';
 export * from './sync-control.directive';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL29hbS1yZXNvdXJjZS1kaXNhYmxlZC1jb250YWluZXIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc3luYy1jb250cm9sLmRpcmVjdGl2ZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zeW5jLWNvbnRyb2wuZGlyZWN0aXZlJztcbiJdfQ==

package/esm2022/lib/pipes/index.mjs

@@ -1,4 +1,3 @@
-export * from './is-oam-resource.pipe';
 export * from './range.pipe';
 export * from './short-num.pipe';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvcGlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pcy1vYW0tcmVzb3VyY2UucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3JhbmdlLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zaG9ydC1udW0ucGlwZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvcGlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcmFuZ2UucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3Nob3J0LW51bS5waXBlJztcbiJdfQ==

package/esm2022/lib/services/pod-util.service.mjs

@@ -1,4 +1,4 @@
-import { DialogService } from '@alauda/ui';
+import { DialogService, NotificationService } from '@alauda/ui';
 import { K8sApiService, TRUE, TranslateService, catchPromise, } from '@alauda-fe/common';
 import { Injectable } from '@angular/core';
 import { concatMapTo } from 'rxjs';
@@ -10,11 +10,12 @@ import * as i2 from "@alauda-fe/common";
 import * as i3 from "./terminal.service";
 export const DEBUG_CONTAINER_SUFFIX = '-debug';
 export class PodUtilService {
-    constructor(dialog, translate, k8sApi, terminal) {
+    constructor(dialog, translate, k8sApi, terminal, notification) {
         this.dialog = dialog;
         this.translate = translate;
         this.k8sApi = k8sApi;
         this.terminal = terminal;
+        this.notification = notification;
     }
     deletePod(pod, cluster) {
         return catchPromise(this.dialog.confirm({
@@ -60,11 +61,33 @@ export class PodUtilService {
             isDebug: TRUE,
         });
     }
-    static { this.ɵfac = function PodUtilService_Factory(t) { return new (t || PodUtilService)(i0.ɵɵinject(i1.DialogService), i0.ɵɵinject(i2.TranslateService), i0.ɵɵinject(i2.K8sApiService), i0.ɵɵinject(i3.TerminalService)); }; }
+    /**
+     * Debug (Copy Mode)：先开终端窗口，副本在窗口内创建
+     * 先发异步请求再开窗口会被浏览器当作非用户手势拦截，因此顺序不能调换
+     */
+    handleDebugCopyInfo(pod, container, baseParams, data) {
+        if (!data) {
+            return;
+        }
+        const opened = this.terminal.openTerminal({
+            pods: pod.metadata.name,
+            container: container.name,
+            namespace: pod.metadata.namespace,
+            cluster: baseParams.cluster,
+            startupCommand: data.command,
+        }, 'terminal/copy-check');
+        if (!opened) {
+            this.notification.error({
+                title: this.translate.get('debug_copy_popup_blocked'),
+                content: this.translate.get('debug_copy_popup_blocked_hint'),
+            });
+        }
+    }
+    static { this.ɵfac = function PodUtilService_Factory(t) { return new (t || PodUtilService)(i0.ɵɵinject(i1.DialogService), i0.ɵɵinject(i2.TranslateService), i0.ɵɵinject(i2.K8sApiService), i0.ɵɵinject(i3.TerminalService), i0.ɵɵinject(i1.NotificationService)); }; }
     static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PodUtilService, factory: PodUtilService.ɵfac, providedIn: 'root' }); }
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PodUtilService, [{
         type: Injectable,
         args: [{ providedIn: 'root' }]
-    }], () => [{ type: i1.DialogService }, { type: i2.TranslateService }, { type: i2.K8sApiService }, { type: i3.TerminalService }], null); })();
-//# sourceMappingURL=data:application/json;base64,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
+    }], () => [{ type: i1.DialogService }, { type: i2.TranslateService }, { type: i2.K8sApiService }, { type: i3.TerminalService }, { type: i1.NotificationService }], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pod-util.service.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/services/pod-util.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DialogService, NotificationService } from '@alauda/ui';\nimport {\n  K8sApiService,\n  TRUE,\n  TranslateService,\n  catchPromise,\n  Container,\n  Pod,\n  Workspace,\n} from '@alauda-fe/common';\nimport { Injectable } from '@angular/core';\nimport { concatMapTo } from 'rxjs';\n\nimport { DebugCopyInfo, ExecInfo, RESOURCE_TYPES } from '../typings';\n\nimport { TerminalService } from './terminal.service';\n\nexport const DEBUG_CONTAINER_SUFFIX = '-debug';\n\n@Injectable({ providedIn: 'root' })\nexport class PodUtilService {\n  constructor(\n    private readonly dialog: DialogService,\n    private readonly translate: TranslateService,\n    private readonly k8sApi: K8sApiService,\n    private readonly terminal: TerminalService,\n    private readonly notification: NotificationService,\n  ) {}\n\n  deletePod(pod: Pod, cluster: string) {\n    return catchPromise(\n      this.dialog.confirm({\n        title: this.translate.get('pod_delete_confirm', {\n          name: pod.metadata.name,\n        }),\n        content: this.translate.get('pod_delete_confirm_hint'),\n        confirmText: this.translate.get('delete'),\n        cancelText: this.translate.get('cancel'),\n      }),\n    ).pipe(\n      concatMapTo(\n        this.k8sApi.deleteResource<Pod>({\n          type: RESOURCE_TYPES.POD,\n          cluster,\n          resource: pod,\n        }),\n      ),\n    );\n  }\n\n  handleExecInfo(\n    pod: Pod,\n    container: Container,\n    baseParams: Workspace,\n    data: ExecInfo,\n  ) {\n    if (!data) {\n      return;\n    }\n    const podName = pod.metadata.name;\n    this.terminal.openTerminal({\n      pods: podName,\n      selectedPod: podName,\n      container: container.name,\n      namespace: pod.metadata.namespace,\n      cluster: baseParams.cluster,\n      user: data.user,\n      command: data.command,\n    });\n  }\n\n  handleDebugInfo(pod: Pod, container: Container, baseParams: Workspace) {\n    const podName = pod.metadata.name;\n    const containerName = [container.name, DEBUG_CONTAINER_SUFFIX].join('');\n    this.terminal.openTerminal({\n      pods: podName,\n      selectedPod: podName,\n      container: containerName,\n      namespace: pod.metadata.namespace,\n      cluster: baseParams.cluster,\n      // 本期 debug 用户固定，后续支持自定义\n      user: 'root',\n      command: '/bin/sh',\n      isDebug: TRUE,\n    });\n  }\n\n  /**\n   * Debug (Copy Mode)：先开终端窗口，副本在窗口内创建\n   * 先发异步请求再开窗口会被浏览器当作非用户手势拦截，因此顺序不能调换\n   */\n  handleDebugCopyInfo(\n    pod: Pod,\n    container: Container,\n    baseParams: Workspace,\n    data: DebugCopyInfo,\n  ) {\n    if (!data) {\n      return;\n    }\n\n    const opened = this.terminal.openTerminal(\n      {\n        pods: pod.metadata.name,\n        container: container.name,\n        namespace: pod.metadata.namespace,\n        cluster: baseParams.cluster,\n        startupCommand: data.command,\n      },\n      'terminal/copy-check',\n    );\n\n    if (!opened) {\n      this.notification.error({\n        title: this.translate.get('debug_copy_popup_blocked'),\n        content: this.translate.get('debug_copy_popup_blocked_hint'),\n      });\n    }\n  }\n}\n"]}

package/esm2022/lib/services/terminal.service.mjs

@@ -2,6 +2,7 @@ import { K8sPermissionService, K8sResourceAction } from '@alauda-fe/common';
 import { APP_BASE_HREF } from '@angular/common';
 import { HttpParams } from '@angular/common/http';
 import { Inject, Injectable } from '@angular/core';
+import { combineLatest, map } from 'rxjs';
 import { RESOURCE_TYPES } from '../typings';
 import * as i0 from "@angular/core";
 import * as i1 from "@alauda-fe/common";
@@ -18,6 +19,28 @@ export class TerminalService {
             action: [K8sResourceAction.CREATE],
         });
     }
+    /**
+     * 复制模式需要在当前命名空间建副本、退出时删副本，并连进副本的终端；
+     * 三者缺一都走不通，所以入口按三个权限的交集控制。
+     */
+    getDebugCopyPermissions({ cluster, namespace, }) {
+        return combineLatest([
+            this.k8sPermission.isAllowed({
+                type: RESOURCE_TYPES.POD,
+                cluster,
+                namespace,
+                action: [K8sResourceAction.CREATE, K8sResourceAction.DELETE],
+            }),
+            this.k8sPermission.isAllowed({
+                type: RESOURCE_TYPES.PODS_EXEC,
+                cluster,
+                namespace,
+                action: [K8sResourceAction.CREATE],
+            }),
+        ]).pipe(map(([pod, exec]) => pod[K8sResourceAction.CREATE] &&
+            pod[K8sResourceAction.DELETE] &&
+            exec[K8sResourceAction.CREATE]));
+    }
     openTerminal(queryParams, module = 'terminal') {
         // Following is to center the new window.
         const { w, h } = module === 'vnc' ? { w: 1024, h: 800 } : { w: 800, h: 640 };
@@ -29,7 +52,8 @@ export class TerminalService {
             screen.height;
         const left = width / 2 - w / 2 + dualScreenLeft;
         const top = height / 2 - h / 2 + dualScreenTop;
-        window.open(`${this.appBaseHref}${module}?${new HttpParams({
+        // 返回窗口句柄，调用方据此判断弹窗是否被浏览器拦截
+        return window.open(`${this.appBaseHref}${module}?${new HttpParams({
             fromObject: queryParams,
         }).toString()}`, '_blank', `width=${w},height=${h},resizable=yes,left=${left},top=${top}`);
     }
@@ -43,4 +67,4 @@ export class TerminalService {
                 type: Inject,
                 args: [APP_BASE_HREF]
             }] }], null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/typings/helpers.mjs

@@ -11,4 +11,4 @@ export var UnifiedStatus;
     UnifiedStatus["IN_PROGRESS"] = "IN_PROGRESS";
     UnifiedStatus["INACTIVE"] = "INACTIVE";
 })(UnifiedStatus || (UnifiedStatus = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/debug-copy.mjs

@@ -0,0 +1,111 @@
+/** 副本上的来源标记：来源 Pod 名称 */
+export const DEBUG_COPY_SOURCE_POD_ANNOTATION = 'debug.cpaas.io/source-pod';
+/** 副本上的来源标记：来源容器名称 */
+export const DEBUG_COPY_SOURCE_CONTAINER_ANNOTATION = 'debug.cpaas.io/source-container';
+/** 副本名称后缀，真实名称由 apiserver 通过 generateName 生成 */
+export const DEBUG_COPY_NAME_SUFFIX = '-debug-';
+/** 副本中目标容器之外的容器统一以 shell 启动 */
+export const DEBUG_COPY_SHELL = '/bin/sh';
+/** 拉取镜像失败时副本同样拉不到该镜像，因此不提供入口 */
+const IMAGE_PULL_FAILED_REASONS = ['ErrImagePull', 'ImagePullBackOff'];
+function getContainerStatus(pod, containerName) {
+    return pod.status?.containerStatuses?.find(status => status.name === containerName);
+}
+/**
+ * 该 Pod 本身是不是 Debug (Copy Mode) 创建的副本
+ * 副本上不再提供复制入口，避免对副本再创建副本
+ */
+export function isDebugCopyPod(pod) {
+    return !!pod?.metadata?.annotations?.[DEBUG_COPY_SOURCE_POD_ANNOTATION];
+}
+/**
+ * 容器能否使用 Debug (Copy Mode)
+ * 容器未运行或未就绪时可用，与现有 Debug / EXEC 的可用条件互补；
+ * 因拉取镜像失败而等待中的容器除外，副本同样起不来
+ */
+export function canDebugCopyContainer(pod, container) {
+    if (!pod || !container || isDebugCopyPod(pod)) {
+        return false;
+    }
+    const status = getContainerStatus(pod, container.name);
+    if (!status) {
+        // 容器状态还没上报，说明容器尚未运行，可以复制
+        return true;
+    }
+    if (IMAGE_PULL_FAILED_REASONS.includes(status.state?.waiting?.reason)) {
+        return false;
+    }
+    return !status.state?.running || !status.ready;
+}
+/** Pod 中可以使用 Debug (Copy Mode) 的容器，二级菜单只列出这些容器 */
+export function getDebugCopyContainers(pod) {
+    return (pod?.spec?.containers || []).filter(container => canDebugCopyContainer(pod, container));
+}
+/** Pod 中是否还有容器可以使用 Debug (Copy Mode)，没有则整个菜单项隐藏 */
+export function hasDebugCopyContainer(pod) {
+    return getDebugCopyContainers(pod).length > 0;
+}
+/**
+ * 原启动命令与参数按空格拼接展示，与 Pod 详情页 Container 区块一致
+ * 镜像自带的 ENTRYPOINT / CMD 在 Kubernetes 接口中拿不到，未声明时返回空
+ */
+export function formatContainerCommand(command) {
+    return (command || []).join(' ');
+}
+/**
+ * 按原 Pod 配置构造调试副本
+ *
+ * 保留：镜像、数据卷、服务账号、密钥、环境变量、资源请求与限制、安全设置、初始化容器；
+ * 原 Pod 已分配节点时保留 nodeName，避免带 ReadWriteOnce 数据卷的副本跨节点挂载失败。
+ * 清除：名称等唯一标识、标签、注解、归属关系、状态、健康检查、生命周期钩子；
+ * 必须清空 ephemeralContainers —— 该字段只能通过子资源添加，创建时带上会被 apiserver 拒绝。
+ */
+export function buildDebugCopyPod(pod, containerName, startupCommand) {
+    const source = JSON.parse(JSON.stringify(pod));
+    const { namespace } = source.metadata;
+    const copy = {
+        apiVersion: source.apiVersion,
+        kind: source.kind,
+        metadata: {
+            generateName: `${pod.metadata.name}${DEBUG_COPY_NAME_SUFFIX}`,
+            namespace,
+            // 注解一律不继承，只写来源标记（对齐 OpenShift：oc debug 与 Web Console 都只保留
+            // 其工作负载分区专用的两个注解，ACP 无此机制）。
+            // 原 Pod 的注解里混有网络组件写回的地址分配结果（kube-ovn 的 ovn.kubernetes.io/ip_address、
+            // 附加网卡的 <nad>.<ns>.kubernetes.io/ip_address 等），副本带上会被判定 AddressConflict
+            // 起不来（ACP 实测）；按前缀挑着删既漏，又会误伤 k8s.v1.cni.cncf.io/networks 这类用户声明。
+            annotations: {
+                [DEBUG_COPY_SOURCE_POD_ANNOTATION]: pod.metadata.name,
+                [DEBUG_COPY_SOURCE_CONTAINER_ANNOTATION]: containerName,
+            },
+        },
+        spec: source.spec,
+    };
+    copy.spec.restartPolicy = 'Never';
+    // 容器以 shell 为主进程，不响应 SIGTERM；沿用原 Pod 的优雅终止期会让副本在删除后
+    // 仍以 Terminating 停留约 30 秒。副本是一次性的，无需优雅退出。
+    // 写 1 而不是 0：spec 中的 0 会被 apiserver 改为 1，直接写 1 语义更明确
+    copy.spec.terminationGracePeriodSeconds = 1;
+    delete copy.spec.ephemeralContainers;
+    copy.spec.containers = (copy.spec.containers || []).map(container => {
+        const next = {
+            ...container,
+            command: container.name === containerName
+                ? [DEBUG_COPY_SHELL, '-c', startupCommand]
+                : [DEBUG_COPY_SHELL],
+            // 以 shell 启动的容器需要保持运行，等待用户从终端接入
+            stdin: true,
+            tty: true,
+        };
+        delete next.args;
+        delete next.livenessProbe;
+        delete next.readinessProbe;
+        delete next.startupProbe;
+        // 副本不运行原业务进程，postStart 里等应用就绪的脚本或回调必然失败，
+        // 而 postStart 失败会让 kubelet 直接杀掉容器
+        delete next.lifecycle;
+        return next;
+    });
+    return copy;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"debug-copy.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/utils/debug-copy.ts"],"names":[],"mappings":"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","sourcesContent":["import { Container, ContainerStatus, Pod } from '@alauda-fe/common';\n\n/** 副本上的来源标记：来源 Pod 名称 */\nexport const DEBUG_COPY_SOURCE_POD_ANNOTATION = 'debug.cpaas.io/source-pod';\n\n/** 副本上的来源标记：来源容器名称 */\nexport const DEBUG_COPY_SOURCE_CONTAINER_ANNOTATION =\n  'debug.cpaas.io/source-container';\n\n/** 副本名称后缀，真实名称由 apiserver 通过 generateName 生成 */\nexport const DEBUG_COPY_NAME_SUFFIX = '-debug-';\n\n/** 副本中目标容器之外的容器统一以 shell 启动 */\nexport const DEBUG_COPY_SHELL = '/bin/sh';\n\n/** 拉取镜像失败时副本同样拉不到该镜像，因此不提供入口 */\nconst IMAGE_PULL_FAILED_REASONS = ['ErrImagePull', 'ImagePullBackOff'];\n\nfunction getContainerStatus(pod: Pod, containerName: string): ContainerStatus {\n  return pod.status?.containerStatuses?.find(\n    status => status.name === containerName,\n  );\n}\n\n/**\n * 该 Pod 本身是不是 Debug (Copy Mode) 创建的副本\n * 副本上不再提供复制入口，避免对副本再创建副本\n */\nexport function isDebugCopyPod(pod: Pod) {\n  return !!pod?.metadata?.annotations?.[DEBUG_COPY_SOURCE_POD_ANNOTATION];\n}\n\n/**\n * 容器能否使用 Debug (Copy Mode)\n * 容器未运行或未就绪时可用，与现有 Debug / EXEC 的可用条件互补；\n * 因拉取镜像失败而等待中的容器除外，副本同样起不来\n */\nexport function canDebugCopyContainer(pod: Pod, container: Container) {\n  if (!pod || !container || isDebugCopyPod(pod)) {\n    return false;\n  }\n  const status = getContainerStatus(pod, container.name);\n  if (!status) {\n    // 容器状态还没上报，说明容器尚未运行，可以复制\n    return true;\n  }\n  if (IMAGE_PULL_FAILED_REASONS.includes(status.state?.waiting?.reason)) {\n    return false;\n  }\n  return !status.state?.running || !status.ready;\n}\n\n/** Pod 中可以使用 Debug (Copy Mode) 的容器，二级菜单只列出这些容器 */\nexport function getDebugCopyContainers(pod: Pod) {\n  return (pod?.spec?.containers || []).filter(container =>\n    canDebugCopyContainer(pod, container),\n  );\n}\n\n/** Pod 中是否还有容器可以使用 Debug (Copy Mode)，没有则整个菜单项隐藏 */\nexport function hasDebugCopyContainer(pod: Pod) {\n  return getDebugCopyContainers(pod).length > 0;\n}\n\n/**\n * 原启动命令与参数按空格拼接展示，与 Pod 详情页 Container 区块一致\n * 镜像自带的 ENTRYPOINT / CMD 在 Kubernetes 接口中拿不到，未声明时返回空\n */\nexport function formatContainerCommand(command: string[]) {\n  return (command || []).join(' ');\n}\n\n/**\n * 按原 Pod 配置构造调试副本\n *\n * 保留：镜像、数据卷、服务账号、密钥、环境变量、资源请求与限制、安全设置、初始化容器；\n * 原 Pod 已分配节点时保留 nodeName，避免带 ReadWriteOnce 数据卷的副本跨节点挂载失败。\n * 清除：名称等唯一标识、标签、注解、归属关系、状态、健康检查、生命周期钩子；\n * 必须清空 ephemeralContainers —— 该字段只能通过子资源添加，创建时带上会被 apiserver 拒绝。\n */\nexport function buildDebugCopyPod(\n  pod: Pod,\n  containerName: string,\n  startupCommand: string,\n): Pod {\n  const source: Pod = JSON.parse(JSON.stringify(pod));\n  const { namespace } = source.metadata;\n\n  const copy: Pod = {\n    apiVersion: source.apiVersion,\n    kind: source.kind,\n    metadata: {\n      generateName: `${pod.metadata.name}${DEBUG_COPY_NAME_SUFFIX}`,\n      namespace,\n      // 注解一律不继承，只写来源标记（对齐 OpenShift：oc debug 与 Web Console 都只保留\n      // 其工作负载分区专用的两个注解，ACP 无此机制）。\n      // 原 Pod 的注解里混有网络组件写回的地址分配结果（kube-ovn 的 ovn.kubernetes.io/ip_address、\n      // 附加网卡的 <nad>.<ns>.kubernetes.io/ip_address 等），副本带上会被判定 AddressConflict\n      // 起不来（ACP 实测）；按前缀挑着删既漏，又会误伤 k8s.v1.cni.cncf.io/networks 这类用户声明。\n      annotations: {\n        [DEBUG_COPY_SOURCE_POD_ANNOTATION]: pod.metadata.name,\n        [DEBUG_COPY_SOURCE_CONTAINER_ANNOTATION]: containerName,\n      },\n    },\n    spec: source.spec,\n  };\n\n  copy.spec.restartPolicy = 'Never';\n  // 容器以 shell 为主进程，不响应 SIGTERM；沿用原 Pod 的优雅终止期会让副本在删除后\n  // 仍以 Terminating 停留约 30 秒。副本是一次性的，无需优雅退出。\n  // 写 1 而不是 0：spec 中的 0 会被 apiserver 改为 1，直接写 1 语义更明确\n  copy.spec.terminationGracePeriodSeconds = 1;\n  delete copy.spec.ephemeralContainers;\n\n  copy.spec.containers = (copy.spec.containers || []).map(container => {\n    const next: Container = {\n      ...container,\n      command:\n        container.name === containerName\n          ? [DEBUG_COPY_SHELL, '-c', startupCommand]\n          : [DEBUG_COPY_SHELL],\n      // 以 shell 启动的容器需要保持运行，等待用户从终端接入\n      stdin: true,\n      tty: true,\n    };\n    delete next.args;\n    delete next.livenessProbe;\n    delete next.readinessProbe;\n    delete next.startupProbe;\n    // 副本不运行原业务进程，postStart 里等应用就绪的脚本或回调必然失败，\n    // 而 postStart 失败会让 kubelet 直接杀掉容器\n    delete next.lifecycle;\n    return next;\n  });\n\n  return copy;\n}\n"]}

package/esm2022/lib/utils/index.mjs

@@ -1,6 +1,7 @@
 export * from './code-editor-config';
 export * from './constants';
 export * from './crd';
+export * from './debug-copy';
 export * from './format-number';
 export * from './helpers';
 export * from './k8s-util.service';
@@ -11,4 +12,4 @@ export * from './resources-config-util';
 export * from './status';
 export * from './validator';
 export * from './workspace';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb2RlLWVkaXRvci1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi9jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9jcmQnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtYXQtbnVtYmVyJztcbmV4cG9ydCAqIGZyb20gJy4vaGVscGVycyc7XG5leHBvcnQgKiBmcm9tICcuL2s4cy11dGlsLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9wYXR0ZXJucyc7XG5leHBvcnQgKiBmcm9tICcuL3BvZC11dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vcmVzb3VyY2Utc3RhdHVzJztcbmV4cG9ydCAqIGZyb20gJy4vcmVzb3VyY2VzLWNvbmZpZy11dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vc3RhdHVzJztcbmV4cG9ydCAqIGZyb20gJy4vdmFsaWRhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vd29ya3NwYWNlJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb2RlLWVkaXRvci1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi9jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9jcmQnO1xuZXhwb3J0ICogZnJvbSAnLi9kZWJ1Zy1jb3B5JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybWF0LW51bWJlcic7XG5leHBvcnQgKiBmcm9tICcuL2hlbHBlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9rOHMtdXRpbC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcGF0dGVybnMnO1xuZXhwb3J0ICogZnJvbSAnLi9wb2QtdXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc291cmNlLXN0YXR1cyc7XG5leHBvcnQgKiBmcm9tICcuL3Jlc291cmNlcy1jb25maWctdXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL3N0YXR1cyc7XG5leHBvcnQgKiBmcm9tICcuL3ZhbGlkYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL3dvcmtzcGFjZSc7XG4iXX0=

package/esm2022/lib/utils/patterns.mjs

@@ -113,13 +113,13 @@ export const PHONE_PATTERN = {
     tip: 'phone_format_limit',
 };
 export const PUBLIC_KEY_PATTERN = {
-    pattern: /^(-{5}BEGIN CERTIFICATE-{5}[\d\n+/=A-Za-z]*-{5}END CERTIFICATE-{5}\n*)+$/,
+    pattern: /^(-{5}BEGIN CERTIFICATE-{5}[\d\r\n+/=A-Za-z]*-{5}END CERTIFICATE-{5}\r?\n*)+$/,
     placeholder: `-----BEGIN CERTIFICATE-----
 MIIDLjCCAhYCCQDAOF9tLsaXWjANBgkqhkiG9w0BAQsFADBaM
 -----END CERTIFICATE-----`,
 };
 export const PRIVATE_KEY_PATTERN = {
-    pattern: /^(-{5}BEGIN (RSA |EC |DSA )?PRIVATE KEY-{5}[\d\n+/=A-Za-z]*-{5}END \2PRIVATE KEY-{5}\n*)+$/,
+    pattern: /^(-{5}BEGIN (RSA |EC |DSA )?PRIVATE KEY-{5}[\d\r\n+/=A-Za-z]*-{5}END \2PRIVATE KEY-{5}\r?\n*)+$/,
     placeholder: '',
 };
 export const STRONG_PASSWORD_PATTERN = {
@@ -139,4 +139,4 @@ export const PATCH_PATH_PATTERN = {
     pattern: /^\/.*/,
     tip: 'oam_patch_path_pattern',
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"patterns.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/utils/patterns.ts"],"names":[],"mappings":"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","sourcesContent":["export const K8S_RESOURCE_NAME_BASE = {\n  pattern: /^[\\da-z]([\\da-z-]*[\\da-z])?$/,\n  tip: 'regexp_tip_k8s_resource_name_base',\n};\n\nexport const LOOSE_K8S_RESOURCE_NAME_BASE = {\n  pattern: /^[\\da-z]([\\da-z-]*[\\da-z])?(\\.[\\da-z]([\\da-z-]*[\\da-z])?)*$/,\n  tip: 'regexp_tip_k8s_resource_name_loose',\n};\n\nexport const K8S_CONFIGMAP_KEY = {\n  pattern: /^[\\w-][\\w.-]*$/,\n  tip: 'regexp_tip_k8s_configmap_key',\n};\n\nexport const K8S_ENV_VARIABLE_NAME = {\n  pattern: /^[.A-Z_a-z-][\\w.-]*$/,\n  tip: 'regexp_tip_k8s_env_variable_name',\n};\n\nexport const GIT_URL_PATTERN = {\n  pattern:\n    /^((((ssh|git|https?:?):\\/\\/:?)(([^\\s@]+@|[^@]:?)[-\\w.]+(:\\d{2,}:?)?(\\/[-\\w.~/?[\\]!$&'()*+,;=:@%]*)?:?))|([^\\s@]+@[-\\w.]+:[-\\w.~/?[\\]!$&'()*+,;=:@%]*?:?))$/,\n  tip: 'git_url_validate',\n};\n\nexport const INT_PATTERN = {\n  pattern: /^-?\\d+$/,\n  tip: 'integer_pattern',\n};\n\nexport const POSITIVE_INT_PATTERN = {\n  pattern: /^[1-9]\\d*$/,\n  tip: 'positive_integer_pattern',\n};\n\nexport const POSITIVE_INT_32_PATTERN = {\n  pattern:\n    /^(\\d{1,9}|1\\d{9}|2(0\\d{8}|1([0-3]\\d{7}|4([0-6]\\d{6}|7([0-3]\\d{5}|4([0-7]\\d{4}|8([0-2]\\d{3}|3([0-5]\\d{2}|6([0-3]\\d|4[0-7])))))))))$/,\n  tip: 'positive_integer_pattern',\n};\n\nexport const POSITIVE_NUMBER_PATTERN = {\n  pattern: /^([1-9]\\d*\\.?|0\\.)\\d*$/,\n  tip: 'regexp_tip_positive_number_pattern',\n};\n\nexport const NATURAL_NUMBER_PATTERN = {\n  pattern: /^\\d+$/,\n  tip: 'natural_number_pattern',\n};\n\nexport const AUTO_SCALER_COOL_TIME_PATTERN = {\n  pattern: /^(\\d|[1-9]\\d|[1-9]\\d\\d|[12]\\d\\d\\d|3[0-5]\\d\\d|(3600))$/,\n  tip: 'natural_number_less_than_3600',\n  error: 'natural_number_less_than_3600_error',\n};\n\nexport const REGISTRY_PATH = {\n  pattern: /^[\\da-z]([\\d._a-z-]*[\\da-z])?$/,\n  tip: 'registry_path_rule',\n};\n\nexport const INGRESS_PATH_PATTERN = {\n  pattern: /^\\/.*/,\n  tip: 'ingress_path_pattern',\n};\n\nconst IP_PATTERN_BASE =\n  '^(?:(?:25[0-5]|2[0-4]\\\\d|[01]?\\\\d{1,2})\\\\.){3}(?:25[0-5]|2[0-4]\\\\d|[01]?\\\\d{1,2})$';\n\nexport const IP_ADDRESS_PATTERN = {\n  pattern: new RegExp(IP_PATTERN_BASE),\n  tip: 'regexp_tip_ip_address',\n};\n\nconst IP_V6_ADDRESS_BASE =\n  '^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]+|::(ffff(:0{1,4})?:)?((25[0-5]|(2[0-4]|1?[0-9])?[0-9]).){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1?[0-9])?[0-9]).){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9]))$';\n\nexport const IP_V6_ADDRESS_PATTERN = {\n  pattern: new RegExp(IP_V6_ADDRESS_BASE),\n};\n\nexport const IP_V4_OR_V6_PATTERN = {\n  pattern: new RegExp(`(${IP_PATTERN_BASE})|(${IP_V6_ADDRESS_BASE})`),\n};\n\nexport const IP_ADDRESS_PORT_PATTERN = {\n  pattern: new RegExp(`${IP_PATTERN_BASE.slice(0, -1)}(?::\\\\d+)?$`),\n  tip: 'regexp_tip_ip_address',\n};\n\nexport const TCP_ADDRESS_PATTERN = {\n  pattern:\n    /^(?:(?:[1-9]?\\d|1\\d{2}|2[0-4]\\d|25[0-5])\\.){3}(?:[1-9]?\\d|1\\d{2}|2[0-4]\\d|25[0-5]):\\d+$/,\n  tip: 'input_tcp_placeholder',\n};\n\nexport const CIDR_IP_PATTERN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}$/,\n};\n\nexport const CIDR_FULL_PATTEN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}(\\/(\\d|[12]\\d|3[0-2]))$/,\n  tip: 'regexp_cidr_pattern',\n};\n\nexport const CIDR_PATTERN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}(\\/(\\d|[12]\\d|3[0-2]))?$/,\n  tip: 'regexp_cidr_pattern',\n};\n\nexport const RESERVED_IP_PATTERN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}(\\.\\.((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3})?$/,\n};\n\nexport const RESERVED_IP_SEGMENT_PATTERN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}(\\.\\.((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3})$/,\n};\n\nexport const CUSTOM_ALARM_NAME_BASE = {\n  pattern: /^[\\da-z]([\\d.a-z]*[\\da-z])?$/,\n  tip: 'custom_alert_name_placeholder',\n};\n\nexport const ALARM_LABEL_KEY_NAME_PATTERN = {\n  pattern: /^[A-Z_a-z]\\w*$/,\n  tip: 'regexp_tip_alert_label_key_name',\n};\n\nexport const ALARM_THRESHOLD_PATTERN = {\n  pattern: /^(?!0\\d)\\d{0,17}(\\.\\d{1,4})?$/,\n  tip: 'regexp_tip_alert_threshold',\n};\n\nexport const ALARM_METRIC_PATTERN = {\n  pattern: /^[\\u0020-\\u007E]*$/,\n  tip: 'regexp_tip_alert_metric',\n};\n\nexport const EMAIL_PATTERN = {\n  pattern:\n    /^[\\w!#$%&'*+/=?^`{|}~-]+(?:\\.[\\w!#$%&'*+/=?^`{|}~-]+)*@(?:[\\dA-Za-z](?:[\\dA-Za-z-]*[\\dA-Za-z])?\\.)+[\\dA-Za-z](?:[\\dA-Za-z-]*[\\dA-Za-z])?$/,\n  tip: 'email_format_limit',\n};\n\nexport const PHONE_PATTERN = {\n  pattern: /^\\+?\\d{7,15}$/,\n  tip: 'phone_format_limit',\n};\n\nexport const PUBLIC_KEY_PATTERN = {\n  pattern:\n    /^(-{5}BEGIN CERTIFICATE-{5}[\\d\\n+/=A-Za-z]*-{5}END CERTIFICATE-{5}\\n*)+$/,\n  placeholder: `-----BEGIN CERTIFICATE-----\nMIIDLjCCAhYCCQDAOF9tLsaXWjANBgkqhkiG9w0BAQsFADBaM\n-----END CERTIFICATE-----`,\n};\n\nexport const PRIVATE_KEY_PATTERN = {\n  pattern:\n    /^(-{5}BEGIN (RSA |EC |DSA )?PRIVATE KEY-{5}[\\d\\n+/=A-Za-z]*-{5}END \\2PRIVATE KEY-{5}\\n*)+$/,\n  placeholder: '',\n};\n\nexport const STRONG_PASSWORD_PATTERN = {\n  pattern:\n    /^(?!\\/)(?=.*[A-Za-z])(?=.*\\d)(?=.*[!#$%&'()*+,./:;<=>?@[\\]^_`{|}~-]).{8,30}$/,\n  tip: 'regexp_tip_strong_password',\n};\n\nexport const POSITIVE_PERCENTAGE_PATTERN = {\n  pattern: /^([1-9]\\d?|100)$/,\n  tip: 'regexp_positive_percentage_tips',\n};\n\nexport const CUSTOM_INDICATOR_PATTERN = {\n  // cspell:disable-next-line\n  pattern: /^([+-]?[\\d.]+)([EGKMPTeikmnu]*[+-]?\\d*)$/,\n  tip: '',\n};\n\nexport const PATCH_PATH_PATTERN = {\n  pattern: /^\\/.*/,\n  tip: 'oam_patch_path_pattern',\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"patterns.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/utils/patterns.ts"],"names":[],"mappings":"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","sourcesContent":["export const K8S_RESOURCE_NAME_BASE = {\n  pattern: /^[\\da-z]([\\da-z-]*[\\da-z])?$/,\n  tip: 'regexp_tip_k8s_resource_name_base',\n};\n\nexport const LOOSE_K8S_RESOURCE_NAME_BASE = {\n  pattern: /^[\\da-z]([\\da-z-]*[\\da-z])?(\\.[\\da-z]([\\da-z-]*[\\da-z])?)*$/,\n  tip: 'regexp_tip_k8s_resource_name_loose',\n};\n\nexport const K8S_CONFIGMAP_KEY = {\n  pattern: /^[\\w-][\\w.-]*$/,\n  tip: 'regexp_tip_k8s_configmap_key',\n};\n\nexport const K8S_ENV_VARIABLE_NAME = {\n  pattern: /^[.A-Z_a-z-][\\w.-]*$/,\n  tip: 'regexp_tip_k8s_env_variable_name',\n};\n\nexport const GIT_URL_PATTERN = {\n  pattern:\n    /^((((ssh|git|https?:?):\\/\\/:?)(([^\\s@]+@|[^@]:?)[-\\w.]+(:\\d{2,}:?)?(\\/[-\\w.~/?[\\]!$&'()*+,;=:@%]*)?:?))|([^\\s@]+@[-\\w.]+:[-\\w.~/?[\\]!$&'()*+,;=:@%]*?:?))$/,\n  tip: 'git_url_validate',\n};\n\nexport const INT_PATTERN = {\n  pattern: /^-?\\d+$/,\n  tip: 'integer_pattern',\n};\n\nexport const POSITIVE_INT_PATTERN = {\n  pattern: /^[1-9]\\d*$/,\n  tip: 'positive_integer_pattern',\n};\n\nexport const POSITIVE_INT_32_PATTERN = {\n  pattern:\n    /^(\\d{1,9}|1\\d{9}|2(0\\d{8}|1([0-3]\\d{7}|4([0-6]\\d{6}|7([0-3]\\d{5}|4([0-7]\\d{4}|8([0-2]\\d{3}|3([0-5]\\d{2}|6([0-3]\\d|4[0-7])))))))))$/,\n  tip: 'positive_integer_pattern',\n};\n\nexport const POSITIVE_NUMBER_PATTERN = {\n  pattern: /^([1-9]\\d*\\.?|0\\.)\\d*$/,\n  tip: 'regexp_tip_positive_number_pattern',\n};\n\nexport const NATURAL_NUMBER_PATTERN = {\n  pattern: /^\\d+$/,\n  tip: 'natural_number_pattern',\n};\n\nexport const AUTO_SCALER_COOL_TIME_PATTERN = {\n  pattern: /^(\\d|[1-9]\\d|[1-9]\\d\\d|[12]\\d\\d\\d|3[0-5]\\d\\d|(3600))$/,\n  tip: 'natural_number_less_than_3600',\n  error: 'natural_number_less_than_3600_error',\n};\n\nexport const REGISTRY_PATH = {\n  pattern: /^[\\da-z]([\\d._a-z-]*[\\da-z])?$/,\n  tip: 'registry_path_rule',\n};\n\nexport const INGRESS_PATH_PATTERN = {\n  pattern: /^\\/.*/,\n  tip: 'ingress_path_pattern',\n};\n\nconst IP_PATTERN_BASE =\n  '^(?:(?:25[0-5]|2[0-4]\\\\d|[01]?\\\\d{1,2})\\\\.){3}(?:25[0-5]|2[0-4]\\\\d|[01]?\\\\d{1,2})$';\n\nexport const IP_ADDRESS_PATTERN = {\n  pattern: new RegExp(IP_PATTERN_BASE),\n  tip: 'regexp_tip_ip_address',\n};\n\nconst IP_V6_ADDRESS_BASE =\n  '^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]+|::(ffff(:0{1,4})?:)?((25[0-5]|(2[0-4]|1?[0-9])?[0-9]).){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1?[0-9])?[0-9]).){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9]))$';\n\nexport const IP_V6_ADDRESS_PATTERN = {\n  pattern: new RegExp(IP_V6_ADDRESS_BASE),\n};\n\nexport const IP_V4_OR_V6_PATTERN = {\n  pattern: new RegExp(`(${IP_PATTERN_BASE})|(${IP_V6_ADDRESS_BASE})`),\n};\n\nexport const IP_ADDRESS_PORT_PATTERN = {\n  pattern: new RegExp(`${IP_PATTERN_BASE.slice(0, -1)}(?::\\\\d+)?$`),\n  tip: 'regexp_tip_ip_address',\n};\n\nexport const TCP_ADDRESS_PATTERN = {\n  pattern:\n    /^(?:(?:[1-9]?\\d|1\\d{2}|2[0-4]\\d|25[0-5])\\.){3}(?:[1-9]?\\d|1\\d{2}|2[0-4]\\d|25[0-5]):\\d+$/,\n  tip: 'input_tcp_placeholder',\n};\n\nexport const CIDR_IP_PATTERN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}$/,\n};\n\nexport const CIDR_FULL_PATTEN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}(\\/(\\d|[12]\\d|3[0-2]))$/,\n  tip: 'regexp_cidr_pattern',\n};\n\nexport const CIDR_PATTERN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}(\\/(\\d|[12]\\d|3[0-2]))?$/,\n  tip: 'regexp_cidr_pattern',\n};\n\nexport const RESERVED_IP_PATTERN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}(\\.\\.((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3})?$/,\n};\n\nexport const RESERVED_IP_SEGMENT_PATTERN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3}(\\.\\.((2(5[0-5]|[0-4]\\d))|1\\d{2}|[1-9]\\d|\\d)(\\.(((2(5[0-5]|[0-4]\\d))|1\\d{1,2}|[1-9]\\d|\\d))){3})$/,\n};\n\nexport const CUSTOM_ALARM_NAME_BASE = {\n  pattern: /^[\\da-z]([\\d.a-z]*[\\da-z])?$/,\n  tip: 'custom_alert_name_placeholder',\n};\n\nexport const ALARM_LABEL_KEY_NAME_PATTERN = {\n  pattern: /^[A-Z_a-z]\\w*$/,\n  tip: 'regexp_tip_alert_label_key_name',\n};\n\nexport const ALARM_THRESHOLD_PATTERN = {\n  pattern: /^(?!0\\d)\\d{0,17}(\\.\\d{1,4})?$/,\n  tip: 'regexp_tip_alert_threshold',\n};\n\nexport const ALARM_METRIC_PATTERN = {\n  pattern: /^[\\u0020-\\u007E]*$/,\n  tip: 'regexp_tip_alert_metric',\n};\n\nexport const EMAIL_PATTERN = {\n  pattern:\n    /^[\\w!#$%&'*+/=?^`{|}~-]+(?:\\.[\\w!#$%&'*+/=?^`{|}~-]+)*@(?:[\\dA-Za-z](?:[\\dA-Za-z-]*[\\dA-Za-z])?\\.)+[\\dA-Za-z](?:[\\dA-Za-z-]*[\\dA-Za-z])?$/,\n  tip: 'email_format_limit',\n};\n\nexport const PHONE_PATTERN = {\n  pattern: /^\\+?\\d{7,15}$/,\n  tip: 'phone_format_limit',\n};\n\nexport const PUBLIC_KEY_PATTERN = {\n  pattern:\n    /^(-{5}BEGIN CERTIFICATE-{5}[\\d\\r\\n+/=A-Za-z]*-{5}END CERTIFICATE-{5}\\r?\\n*)+$/,\n  placeholder: `-----BEGIN CERTIFICATE-----\nMIIDLjCCAhYCCQDAOF9tLsaXWjANBgkqhkiG9w0BAQsFADBaM\n-----END CERTIFICATE-----`,\n};\n\nexport const PRIVATE_KEY_PATTERN = {\n  pattern:\n    /^(-{5}BEGIN (RSA |EC |DSA )?PRIVATE KEY-{5}[\\d\\r\\n+/=A-Za-z]*-{5}END \\2PRIVATE KEY-{5}\\r?\\n*)+$/,\n  placeholder: '',\n};\n\nexport const STRONG_PASSWORD_PATTERN = {\n  pattern:\n    /^(?!\\/)(?=.*[A-Za-z])(?=.*\\d)(?=.*[!#$%&'()*+,./:;<=>?@[\\]^_`{|}~-]).{8,30}$/,\n  tip: 'regexp_tip_strong_password',\n};\n\nexport const POSITIVE_PERCENTAGE_PATTERN = {\n  pattern: /^([1-9]\\d?|100)$/,\n  tip: 'regexp_positive_percentage_tips',\n};\n\nexport const CUSTOM_INDICATOR_PATTERN = {\n  // cspell:disable-next-line\n  pattern: /^([+-]?[\\d.]+)([EGKMPTeikmnu]*[+-]?\\d*)$/,\n  tip: '',\n};\n\nexport const PATCH_PATH_PATTERN = {\n  pattern: /^\\/.*/,\n  tip: 'oam_patch_path_pattern',\n};\n"]}

package/esm2022/lib/utils/status.mjs

@@ -33,7 +33,34 @@ function getPodContainerStatus(pod, reason) {
 }
 function getPodInitStatus(pod, reason) {
     let initializing = false;
-    const initContainerStatuses = get(pod, ['status', 'initContainerStatuses'], []);
+    const initStatuses = pod.status?.initContainerStatuses ?? [];
+    const initContainers = pod.spec?.initContainers ?? [];
+    const specSidecarNames = new Set(initContainers
+        .filter(c => c?.restartPolicy === 'Always')
+        .map(c => c?.name)
+        .filter((name) => !!name));
+    // Native sidecars are excluded from init progress only after they have
+    // successfully started. A restartPolicy: Always sidecar that is still waiting
+    // or failed must remain visible so ImagePullBackOff/CrashLoopBackOff/non-zero
+    // exits are surfaced. [AIT-71104]
+    // 仅当 Pod 已 Running（普通 init 必已全部跑完）时才用运行态兜底识别 sidecar，
+    // 避免把恰好在 running 的普通 init 容器误判为 sidecar。[AIT-71104]
+    const podRunning = get(pod, ['status', 'phase']) === 'Running';
+    const sidecarNames = [
+        ...initStatuses
+            .filter(s => !!s.name &&
+            specSidecarNames.has(s.name) &&
+            s?.started &&
+            get(s, ['state', 'running']))
+            .map(s => s?.name),
+        ...(podRunning
+            ? initStatuses
+                .filter(s => s?.started && get(s, ['state', 'running']))
+                .map(s => s?.name)
+            : []),
+    ].filter((name) => !!name);
+    // Exclude sidecar statuses from init status calculation
+    const initContainerStatuses = initStatuses.filter(s => !s.name || !sidecarNames.includes(s.name));
     for (let i = initContainerStatuses.length - 1; i >= 0; i--) {
         const status = initContainerStatuses[i];
         if (get(status, ['state', 'terminated', 'exitCode']) === 0) {
@@ -48,12 +75,13 @@ function getPodInitStatus(pod, reason) {
                     ? `Init:ExitCode:${terminated.exitCode}`
                     : `Init:Signal:${terminated.signal}`;
         }
-        else if ((waitingReason = get(status, ['state', 'waiting', reason])) &&
+        else if ((waitingReason = get(status, ['state', 'waiting', 'reason'])) &&
             waitingReason !== 'PodInitializing') {
             reason = `Initing:${waitingReason}`;
         }
         else {
-            reason = `Initing:${i}/${pod.spec.initContainers.length}`;
+            const initCount = initContainers.filter(container => !container.name || !sidecarNames.includes(container.name)).length;
+            reason = `Initing:${i}/${initCount}`;
         }
         initializing = true;
         break;
@@ -63,14 +91,22 @@ function getPodInitStatus(pod, reason) {
 // 将 getPodStatus 得到的多种状态映射到标签类型
 // reference: https://bitbucket.org/mathildetech/link/src/c81161f02f981904b716462a305e09414e5617d3/src/backend/resource/common/podinfo.go#lines-68
 export function getPodAggregatedStatus(status) {
-    if (status.split(':')[0] === 'Initing' ||
-        [
-            'Initing',
-            'Pending',
-            'PodInitializing',
-            'ContainerCreating',
-            'Terminating',
-        ].includes(status)) {
+    const [phase, initReason] = status.split(':');
+    if (phase === 'Initing') {
+        return !initReason ||
+            initReason === 'PodInitializing' ||
+            initReason === 'ContainerCreating' ||
+            /^\d+\/\d+$/.test(initReason)
+            ? PodStatusEnum.pending
+            : PodStatusEnum.error;
+    }
+    if ([
+        'Initing',
+        'Pending',
+        'PodInitializing',
+        'ContainerCreating',
+        'Terminating',
+    ].includes(status)) {
         return PodStatusEnum.pending;
     }
     if (status === 'Completed') {
@@ -81,4 +117,4 @@ export function getPodAggregatedStatus(status) {
     }
     return PodStatusEnum.error;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/utils/status.ts"],"names":[],"mappings":"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","sourcesContent":["import { ContainerStatus, Pod, PodStatusEnum } from '@alauda-fe/common';\nimport { get } from 'lodash-es';\n\n// reference: https://bitbucket.org/mathildetech/link/src/c81161f02f981904b716462a305e09414e5617d3/src/backend/resource/common/pod.go#lines-179\nexport function getPodStatus(pod: Pod): string {\n  let reason = pod.status.phase || pod.status.reason;\n  const { initializing, reason: initReason } = getPodInitStatus(pod, reason);\n  reason = initializing ? initReason : getPodContainerStatus(pod, reason);\n\n  if (pod.metadata.deletionTimestamp && pod.status.reason === 'NodeLost') {\n    reason = 'Unknown';\n  } else if (pod.metadata.deletionTimestamp) {\n    reason = 'Terminating';\n  }\n  return reason;\n}\n\nfunction getPodContainerStatus(pod: Pod, reason: string): string {\n  const containerStatuses: ContainerStatus[] = get(\n    pod,\n    ['status', 'containerStatuses'],\n    [],\n  );\n  for (let i = 0, len = containerStatuses.length; i < len; i++) {\n    const container = containerStatuses[i];\n    let waitingReason, terminatedReason;\n    if ((waitingReason = get(container, ['state', 'waiting', 'reason']))) {\n      return waitingReason;\n    }\n    if (\n      (terminatedReason = get(container, ['state', 'terminated', 'reason']))\n    ) {\n      return terminatedReason;\n    }\n    if (get(container, ['state', 'terminated'])) {\n      const { signal, exitCode } = container.state.terminated;\n      return signal === 0 ? `ExitCode:${exitCode}` : `Signal:${signal}`;\n    }\n  }\n  return reason;\n}\n\nfunction getPodInitStatus(pod: Pod, reason: string) {\n  let initializing = false;\n  const initContainerStatuses = get(\n    pod,\n    ['status', 'initContainerStatuses'],\n    [] as ContainerStatus[],\n  );\n  for (let i = initContainerStatuses.length - 1; i >= 0; i--) {\n    const status = initContainerStatuses[i];\n    if (get(status, ['state', 'terminated', 'exitCode']) === 0) {\n      continue;\n    }\n    let waitingReason: string;\n    const terminated = get(status, ['state', 'terminated']);\n    if (terminated) {\n      reason = terminated.reason\n        ? `Init:${terminated.reason}`\n        : terminated.signal === 0\n          ? `Init:ExitCode:${terminated.exitCode}`\n          : `Init:Signal:${terminated.signal}`;\n    } else if (\n      (waitingReason = get(status, ['state', 'waiting', reason])) &&\n      waitingReason !== 'PodInitializing'\n    ) {\n      reason = `Initing:${waitingReason}`;\n    } else {\n      reason = `Initing:${i}/${pod.spec.initContainers.length}`;\n    }\n    initializing = true;\n    break;\n  }\n  return { initializing, reason };\n}\n\n// 将 getPodStatus 得到的多种状态映射到标签类型\n// reference: https://bitbucket.org/mathildetech/link/src/c81161f02f981904b716462a305e09414e5617d3/src/backend/resource/common/podinfo.go#lines-68\nexport function getPodAggregatedStatus(status: string): PodStatusEnum {\n  if (\n    status.split(':')[0] === 'Initing' ||\n    [\n      'Initing',\n      'Pending',\n      'PodInitializing',\n      'ContainerCreating',\n      'Terminating',\n    ].includes(status)\n  ) {\n    return PodStatusEnum.pending;\n  }\n\n  if (status === 'Completed') {\n    return PodStatusEnum.completed;\n  }\n  if (status === 'Running') {\n    return PodStatusEnum.running;\n  }\n\n  return PodStatusEnum.error;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"status.js","sourceRoot":"","sources":["../../../../../../../modules/workload/util-shared/src/lib/utils/status.ts"],"names":[],"mappings":"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","sourcesContent":["import { ContainerStatus, Pod, PodStatusEnum } from '@alauda-fe/common';\nimport { get } from 'lodash-es';\n\n// reference: https://bitbucket.org/mathildetech/link/src/c81161f02f981904b716462a305e09414e5617d3/src/backend/resource/common/pod.go#lines-179\nexport function getPodStatus(pod: Pod): string {\n  let reason = pod.status.phase || pod.status.reason;\n  const { initializing, reason: initReason } = getPodInitStatus(pod, reason);\n  reason = initializing ? initReason : getPodContainerStatus(pod, reason);\n\n  if (pod.metadata.deletionTimestamp && pod.status.reason === 'NodeLost') {\n    reason = 'Unknown';\n  } else if (pod.metadata.deletionTimestamp) {\n    reason = 'Terminating';\n  }\n  return reason;\n}\n\nfunction getPodContainerStatus(pod: Pod, reason: string): string {\n  const containerStatuses: ContainerStatus[] = get(\n    pod,\n    ['status', 'containerStatuses'],\n    [],\n  );\n  for (let i = 0, len = containerStatuses.length; i < len; i++) {\n    const container = containerStatuses[i];\n    let waitingReason, terminatedReason;\n    if ((waitingReason = get(container, ['state', 'waiting', 'reason']))) {\n      return waitingReason;\n    }\n    if (\n      (terminatedReason = get(container, ['state', 'terminated', 'reason']))\n    ) {\n      return terminatedReason;\n    }\n    if (get(container, ['state', 'terminated'])) {\n      const { signal, exitCode } = container.state.terminated;\n      return signal === 0 ? `ExitCode:${exitCode}` : `Signal:${signal}`;\n    }\n  }\n  return reason;\n}\n\nfunction getPodInitStatus(pod: Pod, reason: string) {\n  let initializing = false;\n  const initStatuses = pod.status?.initContainerStatuses ?? [];\n  const initContainers = pod.spec?.initContainers ?? [];\n  const specSidecarNames = new Set<string>(\n    initContainers\n      .filter(c => c?.restartPolicy === 'Always')\n      .map(c => c?.name)\n      .filter((name): name is string => !!name),\n  );\n  // Native sidecars are excluded from init progress only after they have\n  // successfully started. A restartPolicy: Always sidecar that is still waiting\n  // or failed must remain visible so ImagePullBackOff/CrashLoopBackOff/non-zero\n  // exits are surfaced. [AIT-71104]\n  // 仅当 Pod 已 Running（普通 init 必已全部跑完）时才用运行态兜底识别 sidecar，\n  // 避免把恰好在 running 的普通 init 容器误判为 sidecar。[AIT-71104]\n  const podRunning = get(pod, ['status', 'phase']) === 'Running';\n  const sidecarNames: string[] = [\n    ...initStatuses\n      .filter(\n        s =>\n          !!s.name &&\n          specSidecarNames.has(s.name) &&\n          s?.started &&\n          get(s, ['state', 'running']),\n      )\n      .map(s => s?.name),\n    ...(podRunning\n      ? initStatuses\n          .filter(s => s?.started && get(s, ['state', 'running']))\n          .map(s => s?.name)\n      : []),\n  ].filter((name): name is string => !!name);\n\n  // Exclude sidecar statuses from init status calculation\n  const initContainerStatuses = initStatuses.filter(\n    s => !s.name || !sidecarNames.includes(s.name),\n  );\n  for (let i = initContainerStatuses.length - 1; i >= 0; i--) {\n    const status = initContainerStatuses[i];\n    if (get(status, ['state', 'terminated', 'exitCode']) === 0) {\n      continue;\n    }\n    let waitingReason: string;\n    const terminated = get(status, ['state', 'terminated']);\n    if (terminated) {\n      reason = terminated.reason\n        ? `Init:${terminated.reason}`\n        : terminated.signal === 0\n          ? `Init:ExitCode:${terminated.exitCode}`\n          : `Init:Signal:${terminated.signal}`;\n    } else if (\n      (waitingReason = get(status, ['state', 'waiting', 'reason'])) &&\n      waitingReason !== 'PodInitializing'\n    ) {\n      reason = `Initing:${waitingReason}`;\n    } else {\n      const initCount = initContainers.filter(\n        container => !container.name || !sidecarNames.includes(container.name),\n      ).length;\n      reason = `Initing:${i}/${initCount}`;\n    }\n    initializing = true;\n    break;\n  }\n  return { initializing, reason };\n}\n\n// 将 getPodStatus 得到的多种状态映射到标签类型\n// reference: https://bitbucket.org/mathildetech/link/src/c81161f02f981904b716462a305e09414e5617d3/src/backend/resource/common/podinfo.go#lines-68\nexport function getPodAggregatedStatus(status: string): PodStatusEnum {\n  const [phase, initReason] = status.split(':');\n  if (phase === 'Initing') {\n    return !initReason ||\n      initReason === 'PodInitializing' ||\n      initReason === 'ContainerCreating' ||\n      /^\\d+\\/\\d+$/.test(initReason)\n      ? PodStatusEnum.pending\n      : PodStatusEnum.error;\n  }\n\n  if (\n    [\n      'Initing',\n      'Pending',\n      'PodInitializing',\n      'ContainerCreating',\n      'Terminating',\n    ].includes(status)\n  ) {\n    return PodStatusEnum.pending;\n  }\n\n  if (status === 'Completed') {\n    return PodStatusEnum.completed;\n  }\n  if (status === 'Running') {\n    return PodStatusEnum.running;\n  }\n\n  return PodStatusEnum.error;\n}\n"]}

package/lib/directives/index.d.ts

@@ -1,2 +1 @@
-export * from './oam-resource-disabled-container.directive';
 export * from './sync-control.directive';

package/lib/pipes/index.d.ts

@@ -1,3 +1,2 @@
-export * from './is-oam-resource.pipe';
 export * from './range.pipe';
 export * from './short-num.pipe';

package/lib/services/pod-util.service.d.ts

@@ -1,6 +1,6 @@
-import { DialogService } from '@alauda/ui';
+import { DialogService, NotificationService } from '@alauda/ui';
 import { K8sApiService, TranslateService, Container, Pod, Workspace } from '@alauda-fe/common';
-import { ExecInfo } from '../typings';
+import { DebugCopyInfo, ExecInfo } from '../typings';
 import { TerminalService } from './terminal.service';
 import * as i0 from "@angular/core";
 export declare const DEBUG_CONTAINER_SUFFIX = "-debug";
@@ -9,10 +9,16 @@ export declare class PodUtilService {
     private readonly translate;
     private readonly k8sApi;
     private readonly terminal;
-    constructor(dialog: DialogService, translate: TranslateService, k8sApi: K8sApiService, terminal: TerminalService);
+    private readonly notification;
+    constructor(dialog: DialogService, translate: TranslateService, k8sApi: K8sApiService, terminal: TerminalService, notification: NotificationService);
     deletePod(pod: Pod, cluster: string): import("rxjs").Observable<Pod>;
     handleExecInfo(pod: Pod, container: Container, baseParams: Workspace, data: ExecInfo): void;
     handleDebugInfo(pod: Pod, container: Container, baseParams: Workspace): void;
+    /**
+     * Debug (Copy Mode)：先开终端窗口，副本在窗口内创建
+     * 先发异步请求再开窗口会被浏览器当作非用户手势拦截，因此顺序不能调换
+     */
+    handleDebugCopyInfo(pod: Pod, container: Container, baseParams: Workspace, data: DebugCopyInfo): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PodUtilService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PodUtilService>;
 }

package/lib/services/terminal.service.d.ts

@@ -1,6 +1,8 @@
 import { K8sPermissionService, K8sResourceAction } from '@alauda-fe/common';
 import { HttpParamsOptions } from '@angular/common/http';
 import * as i0 from "@angular/core";
+/** 新窗口要打开的页面，复制模式先落在建副本的等待页 */
+export type TerminalModule = 'terminal' | 'terminal/copy-check' | 'vnc';
 export declare class TerminalService {
     private readonly k8sPermission;
     private readonly appBaseHref;
@@ -9,7 +11,15 @@ export declare class TerminalService {
         cluster: string;
         namespace: string;
     }): import("rxjs").Observable<Record<K8sResourceAction.CREATE, boolean>>;
-    openTerminal(queryParams: HttpParamsOptions['fromObject'], module?: 'terminal' | 'vnc'): void;
+    /**
+     * 复制模式需要在当前命名空间建副本、退出时删副本，并连进副本的终端；
+     * 三者缺一都走不通，所以入口按三个权限的交集控制。
+     */
+    getDebugCopyPermissions({ cluster, namespace, }: {
+        cluster: string;
+        namespace: string;
+    }): import("rxjs").Observable<boolean>;
+    openTerminal(queryParams: HttpParamsOptions['fromObject'], module?: TerminalModule): Window;
     static ɵfac: i0.ɵɵFactoryDeclaration<TerminalService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TerminalService>;
 }

package/lib/typings/helpers.d.ts

@@ -35,6 +35,10 @@ export interface ExecInfo {
     user: string;
     command: string;
 }
+export interface DebugCopyInfo {
+    /** 副本中目标容器的启动命令，整段交给 shell 执行 */
+    command: string;
+}
 export interface ResourceQuotaDefinition {
     key: keyof ResourceQuotaItem;
     fallbackKey?: keyof ResourceQuotaItem;

package/lib/typings/k8s-resource-definitions/index.d.ts

@@ -849,10 +849,6 @@ export declare const RESOURCE_DEFINITIONS: {
         readonly apiVersion: string;
         readonly type: string;
     };
-    readonly CERTIFICATE: {
-        readonly type: string;
-        readonly apiGroup: string;
-    };
     readonly SECURITY_RULE: {
         readonly type: string;
         readonly apiGroup: string;
@@ -1125,7 +1121,6 @@ export declare const RESOURCE_TYPES: {
     readonly CODING: "CODING";
     readonly TI_MATRIX: "TI_MATRIX";
     readonly SYSTEM_CONFIG: "SYSTEM_CONFIG";
-    readonly CERTIFICATE: "CERTIFICATE";
     readonly SECURITY_RULE: "SECURITY_RULE";
     readonly REGION: "REGION";
     readonly TOPOLVM_CLUSTER_V2: "TOPOLVM_CLUSTER_V2";
@@ -1808,9 +1803,6 @@ export declare const getYamlApiVersion: (definition: {
     readonly apiGroup: string;
     readonly apiVersion: string;
     readonly type: string;
-} | {
-    readonly type: string;
-    readonly apiGroup: string;
 } | {
     readonly type: string;
     readonly apiGroup: string;
@@ -1877,7 +1869,7 @@ export declare const getYamlApiVersion: (definition: {
     readonly type: string;
     readonly apiGroup: string;
     readonly apiVersion: string;
-} | "VERTICAL_POD_AUTOSCALER" | "POD_AUTOSCALER" | "ROUTE" | "ADDON" | "INSTALLPLAN" | "CEPH_CLUSTER" | "CEPH_FILE_SYSTEM" | "ARTIFACT" | "TDSQL_INSTANCE" | "TDSQL_INSTANCE_BINDING" | "TDSQL_ACCOUNTS" | "TDSQL_INSTANCE_SET" | "CEPH_BLOCK_POOL" | "CSI_DRIVER" | "EPHEMERAL_CONTAINERS" | "APP_CONFIG" | "CEPH_OBJECT_STORE" | "TOPOLVM_CLUSTER" | "VLAN" | "PROVIDER_NETWORK" | "INGRESS_CLASS" | "INGRESS_V1BEAT1" | "NAMESPACE_AUDIT" | "OAM_APP_STATUS" | "OAM_COMPONENT_DEFINITION" | "OAM_TRAIT_DEFINITION" | "OAM_APP_REVISION" | "ALAUDA_BUCKET_REQUEST" | "BUCKET_ACCESS_CLASS" | "BUCKET_ACCESS_REQUEST" | "GATEWAY_CLASS" | "GATEWAY" | "HTTP_ROUTE" | "ENVOY_PROXY" | "TCP_ROUTE" | "UDP_ROUTE" | "ALAUDA_ARTIFACT" | "ALAUDA_ARTIFACT_VERSION" | "ARTIFACT_UPLOAD_PROCESSOR" | "GIT_COMMIT" | "GITOPS_IGNORE_DIFFERENCE" | "GATEKEEPER_CONSTRAINTS" | "ARTIFACT_APP" | "ARTIFACT_VERSION" | "APP_PACKAGE_MANIFEST" | "MINIO_PEER" | "GITOPS_APPLICATIONS" | "GIT_BUILD" | "GIT_BUILD_RUN" | "GIT_BUILDER_IMAGE_CATEGORY" | "VOLUME_SNAPSHOT" | "SUBNET_KUBE_OVN" | "SUBNET_KUBE_OVN_IP" | "L2_ADVERTISEMENT" | "IP_POOL" | "BGP_PEER" | "BGP_ADVERTISEMENT" | "INTER_CONNECTION_SUBNET" | "DATA_VOLUME" | "VM_SNAPSHOT" | "VM_RESTORE" | "VM_IMAGE" | "LIVE_MIGRATION" | "VIRTUAL_MACHINE" | "VIRTUAL_MACHINE_INSTANCE" | "VIRTUAL_MACHINE_POOL" | "ALAUDA_LOADBALANCER2" | "ALB2" | "HELM_REQUEST" | "HELM_REQUEST_V1" | "DEPLOYMENT" | "DAEMONSET" | "STATEFULSET" | "FRONTEND" | "RULE" | "POD" | "PODS_EXEC" | "PODS_ROOT_EXEC" | "CONFIG_MAP" | "ALERT_TEMPLATE" | "APPLICATION" | "APPLICATION_HISTORY" | "CLUSTER" | "CLUSTER_VIEW" | "DAEMON_SET" | "STATEFUL_SET" | "DOMAIN" | "FEATURE" | "ALAUDA_FEATURE_GATE" | "CLUSTER_ALAUDA_FEATURE_GATE" | "HORIZONTAL_POD_AUTOSCALER" | "LOG" | "PROJECT" | "PROMETHEUS_RULE" | "ALERT_HISTORY" | "SELF_SUBJECT_ACCESS_REVIEW" | "VIEW" | "SERVICE" | "LIMIT_RANGE" | "SECRET" | "CRON_JOB" | "ADVANCED_CRON_JOB" | "JOB" | "INGRESS" | "PERSISTENT_VOLUME_CLAIM" | "NAMESPACE" | "NODE" | "NODE_METRICS" | "PV" | "CRD" | "CHART_REPO" | "CHART" | "NETWORK_POLICY" | "SERVICE_ACCOUNT" | "REPLICA_SET" | "POD_SECURITY_POLICY" | "NAMESPACE_OVERVIEW" | "CSP" | "RESOURCE_QUOTA" | "CLUSTER_NETWORK_POLICY" | "PROJECT_QUOTA" | "TKE_CLUSTER" | "TKE_MACHINE" | "MACHINE" | "NODE_GROUP" | "CLUSTERSERVICEVERSION" | "TENANT" | "SUBSCRIPTION" | "PACKAGE_MANIFEST" | "BUCKET_CLASS" | "PRODUCT_CONFIG" | "STORAGE_CLASS" | "VOLUME_SNAPSHOT_CLASS" | "PRODUCT_BASE" | "MODULE_INFO" | "MODULE_CONFIG" | "MODULE_PLUGIN" | "PRODUCT_ENTRY" | "PRODUCT_DOCS_ENTRY" | "SERVICEMESH_GROUP" | "CLUSTER_MODULE" | "USER_SECURITY_POLICY" | "CONNECTOR" | "ACCESS_TOKEN_INFO" | "FUNCTION_RESOURCE" | "USER_BINDING" | "USER" | "GROUP" | "PROJECT_MEMBER" | "ROLE_TEMPLATE" | "BATCH_ACTION" | "EVENT" | "SERVICE_MONITOR" | "OAM_APPLICATION" | "ARGOCD_APPLICATION_SET" | "ARGOCD_APPLICATION" | "OPERATOR_VIEW" | "MODULE_PLUGIN_VIEW" | "RESOURCE_PATCH" | "COMPONENT_PROBER" | "INSPECTION" | "INSPECTION_DETAILS" | "INSPECTION_ITEMS" | "MESSAGE" | "MODULE_HEALTH" | "MODULE_HEALTH_RECORD" | "AUDIT" | "LOG_POLICY" | "FUNCTION_TEST" | "PROJECT_BINDING" | "PROBE" | "REPORT" | "NAMESPACE_RESOURCE_RATIO" | "CUSTOM_RESOURCE_DEFINITION" | "LICENSE" | "RECORD" | "CSI_NODE" | "TSF" | "TDSQL" | "PORTAL" | "NAMESPACE_IMPORT" | "CLUSTER_ADDON_TYPE" | "CLUSTER_CREDENTIAL" | "CODING" | "TI_MATRIX" | "SYSTEM_CONFIG" | "CERTIFICATE" | "SECURITY_RULE" | "REGION" | "TOPOLVM_CLUSTER_V2" | "BUCKET" | "SCHEDULE" | "BACKUP_STORAGE_LOCATION" | "BACKUP_STORAGE_LOCATION_REPO" | "BACKUP" | "DELETE_BACKUP_REQUEST" | "ETCD_BACKUP_RECORD" | "RESTORE" | "RAW_DEVICE" | "APP_RELEASES" | "NOTIFICATION_TEMPLATE" | "NOTIFICATION_GROUP" | "NOTIFICATION" | "TUNNEL_CLUSTER" | "K8S_CLUSTER") => string;
+} | "VERTICAL_POD_AUTOSCALER" | "POD_AUTOSCALER" | "ROUTE" | "ADDON" | "INSTALLPLAN" | "CEPH_CLUSTER" | "CEPH_FILE_SYSTEM" | "ARTIFACT" | "TDSQL_INSTANCE" | "TDSQL_INSTANCE_BINDING" | "TDSQL_ACCOUNTS" | "TDSQL_INSTANCE_SET" | "CEPH_BLOCK_POOL" | "CSI_DRIVER" | "EPHEMERAL_CONTAINERS" | "APP_CONFIG" | "CEPH_OBJECT_STORE" | "TOPOLVM_CLUSTER" | "VLAN" | "PROVIDER_NETWORK" | "INGRESS_CLASS" | "INGRESS_V1BEAT1" | "NAMESPACE_AUDIT" | "OAM_APP_STATUS" | "OAM_COMPONENT_DEFINITION" | "OAM_TRAIT_DEFINITION" | "OAM_APP_REVISION" | "ALAUDA_BUCKET_REQUEST" | "BUCKET_ACCESS_CLASS" | "BUCKET_ACCESS_REQUEST" | "GATEWAY_CLASS" | "GATEWAY" | "HTTP_ROUTE" | "ENVOY_PROXY" | "TCP_ROUTE" | "UDP_ROUTE" | "ALAUDA_ARTIFACT" | "ALAUDA_ARTIFACT_VERSION" | "ARTIFACT_UPLOAD_PROCESSOR" | "GIT_COMMIT" | "GITOPS_IGNORE_DIFFERENCE" | "GATEKEEPER_CONSTRAINTS" | "ARTIFACT_APP" | "ARTIFACT_VERSION" | "APP_PACKAGE_MANIFEST" | "MINIO_PEER" | "GITOPS_APPLICATIONS" | "GIT_BUILD" | "GIT_BUILD_RUN" | "GIT_BUILDER_IMAGE_CATEGORY" | "VOLUME_SNAPSHOT" | "SUBNET_KUBE_OVN" | "SUBNET_KUBE_OVN_IP" | "L2_ADVERTISEMENT" | "IP_POOL" | "BGP_PEER" | "BGP_ADVERTISEMENT" | "INTER_CONNECTION_SUBNET" | "DATA_VOLUME" | "VM_SNAPSHOT" | "VM_RESTORE" | "VM_IMAGE" | "LIVE_MIGRATION" | "VIRTUAL_MACHINE" | "VIRTUAL_MACHINE_INSTANCE" | "VIRTUAL_MACHINE_POOL" | "ALAUDA_LOADBALANCER2" | "ALB2" | "HELM_REQUEST" | "HELM_REQUEST_V1" | "DEPLOYMENT" | "DAEMONSET" | "STATEFULSET" | "FRONTEND" | "RULE" | "POD" | "PODS_EXEC" | "PODS_ROOT_EXEC" | "CONFIG_MAP" | "ALERT_TEMPLATE" | "APPLICATION" | "APPLICATION_HISTORY" | "CLUSTER" | "CLUSTER_VIEW" | "DAEMON_SET" | "STATEFUL_SET" | "DOMAIN" | "FEATURE" | "ALAUDA_FEATURE_GATE" | "CLUSTER_ALAUDA_FEATURE_GATE" | "HORIZONTAL_POD_AUTOSCALER" | "LOG" | "PROJECT" | "PROMETHEUS_RULE" | "ALERT_HISTORY" | "SELF_SUBJECT_ACCESS_REVIEW" | "VIEW" | "SERVICE" | "LIMIT_RANGE" | "SECRET" | "CRON_JOB" | "ADVANCED_CRON_JOB" | "JOB" | "INGRESS" | "PERSISTENT_VOLUME_CLAIM" | "NAMESPACE" | "NODE" | "NODE_METRICS" | "PV" | "CRD" | "CHART_REPO" | "CHART" | "NETWORK_POLICY" | "SERVICE_ACCOUNT" | "REPLICA_SET" | "POD_SECURITY_POLICY" | "NAMESPACE_OVERVIEW" | "CSP" | "RESOURCE_QUOTA" | "CLUSTER_NETWORK_POLICY" | "PROJECT_QUOTA" | "TKE_CLUSTER" | "TKE_MACHINE" | "MACHINE" | "NODE_GROUP" | "CLUSTERSERVICEVERSION" | "TENANT" | "SUBSCRIPTION" | "PACKAGE_MANIFEST" | "BUCKET_CLASS" | "PRODUCT_CONFIG" | "STORAGE_CLASS" | "VOLUME_SNAPSHOT_CLASS" | "PRODUCT_BASE" | "MODULE_INFO" | "MODULE_CONFIG" | "MODULE_PLUGIN" | "PRODUCT_ENTRY" | "PRODUCT_DOCS_ENTRY" | "SERVICEMESH_GROUP" | "CLUSTER_MODULE" | "USER_SECURITY_POLICY" | "CONNECTOR" | "ACCESS_TOKEN_INFO" | "FUNCTION_RESOURCE" | "USER_BINDING" | "USER" | "GROUP" | "PROJECT_MEMBER" | "ROLE_TEMPLATE" | "BATCH_ACTION" | "EVENT" | "SERVICE_MONITOR" | "OAM_APPLICATION" | "ARGOCD_APPLICATION_SET" | "ARGOCD_APPLICATION" | "OPERATOR_VIEW" | "MODULE_PLUGIN_VIEW" | "RESOURCE_PATCH" | "COMPONENT_PROBER" | "INSPECTION" | "INSPECTION_DETAILS" | "INSPECTION_ITEMS" | "MESSAGE" | "MODULE_HEALTH" | "MODULE_HEALTH_RECORD" | "AUDIT" | "LOG_POLICY" | "FUNCTION_TEST" | "PROJECT_BINDING" | "PROBE" | "REPORT" | "NAMESPACE_RESOURCE_RATIO" | "CUSTOM_RESOURCE_DEFINITION" | "LICENSE" | "RECORD" | "CSI_NODE" | "TSF" | "TDSQL" | "PORTAL" | "NAMESPACE_IMPORT" | "CLUSTER_ADDON_TYPE" | "CLUSTER_CREDENTIAL" | "CODING" | "TI_MATRIX" | "SYSTEM_CONFIG" | "SECURITY_RULE" | "REGION" | "TOPOLVM_CLUSTER_V2" | "BUCKET" | "SCHEDULE" | "BACKUP_STORAGE_LOCATION" | "BACKUP_STORAGE_LOCATION_REPO" | "BACKUP" | "DELETE_BACKUP_REQUEST" | "ETCD_BACKUP_RECORD" | "RESTORE" | "RAW_DEVICE" | "APP_RELEASES" | "NOTIFICATION_TEMPLATE" | "NOTIFICATION_GROUP" | "NOTIFICATION" | "TUNNEL_CLUSTER" | "K8S_CLUSTER") => string;
 export type ResourceType = keyof typeof RESOURCE_TYPES;
 export type WorkloadType = typeof RESOURCE_TYPES.DEPLOYMENT | typeof RESOURCE_TYPES.DAEMON_SET | typeof RESOURCE_TYPES.STATEFUL_SET | typeof RESOURCE_TYPES.CRON_JOB;
 export declare const ApplicationTypeMeta: TypeMeta;

package/lib/utils/debug-copy.d.ts

@@ -0,0 +1,38 @@
+import { Container, Pod } from '@alauda-fe/common';
+/** 副本上的来源标记：来源 Pod 名称 */
+export declare const DEBUG_COPY_SOURCE_POD_ANNOTATION = "debug.cpaas.io/source-pod";
+/** 副本上的来源标记：来源容器名称 */
+export declare const DEBUG_COPY_SOURCE_CONTAINER_ANNOTATION = "debug.cpaas.io/source-container";
+/** 副本名称后缀，真实名称由 apiserver 通过 generateName 生成 */
+export declare const DEBUG_COPY_NAME_SUFFIX = "-debug-";
+/** 副本中目标容器之外的容器统一以 shell 启动 */
+export declare const DEBUG_COPY_SHELL = "/bin/sh";
+/**
+ * 该 Pod 本身是不是 Debug (Copy Mode) 创建的副本
+ * 副本上不再提供复制入口，避免对副本再创建副本
+ */
+export declare function isDebugCopyPod(pod: Pod): boolean;
+/**
+ * 容器能否使用 Debug (Copy Mode)
+ * 容器未运行或未就绪时可用，与现有 Debug / EXEC 的可用条件互补；
+ * 因拉取镜像失败而等待中的容器除外，副本同样起不来
+ */
+export declare function canDebugCopyContainer(pod: Pod, container: Container): boolean;
+/** Pod 中可以使用 Debug (Copy Mode) 的容器，二级菜单只列出这些容器 */
+export declare function getDebugCopyContainers(pod: Pod): Container[];
+/** Pod 中是否还有容器可以使用 Debug (Copy Mode)，没有则整个菜单项隐藏 */
+export declare function hasDebugCopyContainer(pod: Pod): boolean;
+/**
+ * 原启动命令与参数按空格拼接展示，与 Pod 详情页 Container 区块一致
+ * 镜像自带的 ENTRYPOINT / CMD 在 Kubernetes 接口中拿不到，未声明时返回空
+ */
+export declare function formatContainerCommand(command: string[]): string;
+/**
+ * 按原 Pod 配置构造调试副本
+ *
+ * 保留：镜像、数据卷、服务账号、密钥、环境变量、资源请求与限制、安全设置、初始化容器；
+ * 原 Pod 已分配节点时保留 nodeName，避免带 ReadWriteOnce 数据卷的副本跨节点挂载失败。
+ * 清除：名称等唯一标识、标签、注解、归属关系、状态、健康检查、生命周期钩子；
+ * 必须清空 ephemeralContainers —— 该字段只能通过子资源添加，创建时带上会被 apiserver 拒绝。
+ */
+export declare function buildDebugCopyPod(pod: Pod, containerName: string, startupCommand: string): Pod;

package/lib/utils/index.d.ts

@@ -1,6 +1,7 @@
 export * from './code-editor-config';
 export * from './constants';
 export * from './crd';
+export * from './debug-copy';
 export * from './format-number';
 export * from './helpers';
 export * from './k8s-util.service';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alauda-fe/workload-util-shared",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "peerDependencies": {
     "@alauda/ui": "^8.0.0",
     "@alauda-fe/common": "1.4.4",

package/esm2022/lib/directives/oam-resource-disabled-container.directive.mjs

@@ -1,53 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { DisabledContainerComponent, TranslateService, ValueHook, } from '@alauda-fe/common';
-import { ChangeDetectorRef, Directive, Input } from '@angular/core';
-import { distinctUntilChanged } from 'rxjs';
-import { isOamResource } from '../pipes/is-oam-resource.pipe';
-import * as i0 from "@angular/core";
-import * as i1 from "@alauda-fe/common";
-/**
- * @description acl-disabled-container 增强指令。
- *
- * 需要注意对 acl-disabled-container的副作用，一旦满足 isOam 的条件，禁用的 tip 会一直保留，并且优先级最高，除非数据源本身发生变化。
- */
-export class OamResourceDisabledContainerDirective {
-    constructor(disabledContainer, translate, cdr) {
-        this.disabledContainer = disabledContainer;
-        this.translate = translate;
-        this.cdr = cdr;
-    }
-    static { this.ɵfac = function OamResourceDisabledContainerDirective_Factory(t) { return new (t || OamResourceDisabledContainerDirective)(i0.ɵɵdirectiveInject(i1.DisabledContainerComponent), i0.ɵɵdirectiveInject(i1.TranslateService), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
-    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: OamResourceDisabledContainerDirective, selectors: [["acl-disabled-container", "rcIsOamDisabled", ""]], inputs: { rcIsOamDisabled: "rcIsOamDisabled" }, standalone: true }); }
-}
-__decorate([
-    ValueHook(function (resource) {
-        const oamDisabledTooltip = this.translate.get('oam_asset_action_disabled_tip');
-        if (isOamResource(resource)) {
-            this.disabledContainer.isDisabled$
-                .pipe(distinctUntilChanged())
-                .subscribe(() => {
-                Promise.resolve().then(() => {
-                    this.disabledContainer.isDisabled = true;
-                    this.cdr.markForCheck();
-                });
-            });
-            this.disabledContainer.tooltip$
-                .pipe(distinctUntilChanged())
-                .subscribe(() => {
-                this.disabledContainer.tooltip = oamDisabledTooltip;
-                this.cdr.markForCheck();
-            });
-        }
-    }),
-    __metadata("design:type", Object)
-], OamResourceDisabledContainerDirective.prototype, "rcIsOamDisabled", void 0);
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(OamResourceDisabledContainerDirective, [{
-        type: Directive,
-        args: [{
-                standalone: true,
-                selector: 'acl-disabled-container[rcIsOamDisabled]',
-            }]
-    }], () => [{ type: i1.DisabledContainerComponent }, { type: i1.TranslateService }, { type: i0.ChangeDetectorRef }], { rcIsOamDisabled: [{
-            type: Input
-        }] }); })();
-//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/pipes/is-oam-resource.pipe.mjs

@@ -1,17 +0,0 @@
-import { LABELS, METADATA } from '@alauda-fe/common';
-import { Pipe } from '@angular/core';
-import { get } from 'lodash-es';
-import * as i0 from "@angular/core";
-export const isOamResource = (resource) => !!get(resource, [METADATA, LABELS, 'app.oam.dev/name']);
-export class isOamResourcePipe {
-    constructor() {
-        this.transform = isOamResource;
-    }
-    static { this.ɵfac = function isOamResourcePipe_Factory(t) { return new (t || isOamResourcePipe)(); }; }
-    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "rcIsOamResource", type: isOamResourcePipe, pure: true, standalone: true }); }
-}
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(isOamResourcePipe, [{
-        type: Pipe,
-        args: [{ name: 'rcIsOamResource', standalone: true }]
-    }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtb2FtLXJlc291cmNlLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL3dvcmtsb2FkL3V0aWwtc2hhcmVkL3NyYy9saWIvcGlwZXMvaXMtb2FtLXJlc291cmNlLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFzQixNQUFNLEVBQUUsUUFBUSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDekUsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFDcEQsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLFdBQVcsQ0FBQzs7QUFFaEMsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLENBQStCLFFBQVcsRUFBRSxFQUFFLENBQ3pFLENBQUMsQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxrQkFBa0IsQ0FBQyxDQUFDLENBQUM7QUFHMUQsTUFBTSxPQUFPLGlCQUFpQjtJQUQ5QjtRQUVFLGNBQVMsR0FBRyxhQUFhLENBQUM7S0FDM0I7a0ZBRlksaUJBQWlCO3lGQUFqQixpQkFBaUI7O2lGQUFqQixpQkFBaUI7Y0FEN0IsSUFBSTtlQUFDLEVBQUUsSUFBSSxFQUFFLGlCQUFpQixFQUFFLFVBQVUsRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBLdWJlcm5ldGVzUmVzb3VyY2UsIExBQkVMUywgTUVUQURBVEEgfSBmcm9tICdAYWxhdWRhLWZlL2NvbW1vbic7XG5pbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBnZXQgfSBmcm9tICdsb2Rhc2gtZXMnO1xuXG5leHBvcnQgY29uc3QgaXNPYW1SZXNvdXJjZSA9IDxUIGV4dGVuZHMgS3ViZXJuZXRlc1Jlc291cmNlPihyZXNvdXJjZTogVCkgPT5cbiAgISFnZXQocmVzb3VyY2UsIFtNRVRBREFUQSwgTEFCRUxTLCAnYXBwLm9hbS5kZXYvbmFtZSddKTtcblxuQFBpcGUoeyBuYW1lOiAncmNJc09hbVJlc291cmNlJywgc3RhbmRhbG9uZTogdHJ1ZSB9KVxuZXhwb3J0IGNsYXNzIGlzT2FtUmVzb3VyY2VQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybSA9IGlzT2FtUmVzb3VyY2U7XG59XG4iXX0=

package/lib/directives/oam-resource-disabled-container.directive.d.ts

@@ -1,17 +0,0 @@
-import { DisabledContainerComponent, KubernetesResource, TranslateService } from '@alauda-fe/common';
-import { ChangeDetectorRef } from '@angular/core';
-import * as i0 from "@angular/core";
-/**
- * @description acl-disabled-container 增强指令。
- *
- * 需要注意对 acl-disabled-container的副作用，一旦满足 isOam 的条件，禁用的 tip 会一直保留，并且优先级最高，除非数据源本身发生变化。
- */
-export declare class OamResourceDisabledContainerDirective {
-    private readonly disabledContainer;
-    private readonly translate;
-    private readonly cdr;
-    rcIsOamDisabled: KubernetesResource;
-    constructor(disabledContainer: DisabledContainerComponent, translate: TranslateService, cdr: ChangeDetectorRef);
-    static ɵfac: i0.ɵɵFactoryDeclaration<OamResourceDisabledContainerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<OamResourceDisabledContainerDirective, "acl-disabled-container[rcIsOamDisabled]", never, { "rcIsOamDisabled": { "alias": "rcIsOamDisabled"; "required": false; }; }, {}, never, never, true, never>;
-}

package/lib/pipes/is-oam-resource.pipe.d.ts

@@ -1,9 +0,0 @@
-import { KubernetesResource } from '@alauda-fe/common';
-import { PipeTransform } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare const isOamResource: <T extends KubernetesResource>(resource: T) => boolean;
-export declare class isOamResourcePipe implements PipeTransform {
-    transform: <T extends KubernetesResource>(resource: T) => boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<isOamResourcePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<isOamResourcePipe, "rcIsOamResource", true>;
-}