@floegence/redevplugin-ui 3.0.12 → 3.0.14

package/dist/openapi.gen.d.ts

@@ -2089,6 +2089,8 @@ export interface components {
         };
         ListExecutionsRequest: {
             plugin_instance_id?: string;
+            /** @enum {string} */
+            operation_scope?: "release_install";
             cursor?: number;
             limit?: number;
         };
@@ -2356,7 +2358,8 @@ export interface components {
             failure_code?: string;
             /** @enum {string} */
             failure_stage?: "download" | "verify" | "install" | "enable";
-        };
+            retryable?: boolean;
+        } & unknown;
         PublicError: {
             code: string;
             message: string;

package/dist/platform.d.ts

@@ -77,11 +77,15 @@ export type PluginSettingsPatchRequest = PluginSettingsPatchBase & ({
 export type PluginCapabilityContractPin = PlatformSchemas["HostCapabilityPinV1"];
 export type PluginExecution = PlatformSchemas["Execution"];
 export type PluginEvent = PlatformSchemas["Event"];
+export type PluginReleaseInstallProgressEvent = PlatformSchemas["ReleaseInstallProgressEvent"];
 export type PluginStartReleaseInstallExecutionRequest = PlatformSchemas["StartReleaseInstallExecutionRequest"];
 export type PluginExecutionList = PlatformSchemas["ExecutionList"];
 export type PluginExecutionEventList = PlatformSchemas["ExecutionEventList"];
 export type PluginExecutionListOptions = PlatformSchemas["ListExecutionsRequest"];
+export type PluginReleaseInstallExecutionListOptions = Omit<PluginExecutionListOptions, "operation_scope">;
 export type PluginExecutionEventListOptions = PlatformSchemas["ListExecutionEventsRequest"];
+/** Reads the stable release-install progress projection from an execution event. */
+export declare function decodePluginReleaseInstallProgressEvent(event: PluginEvent): PluginReleaseInstallProgressEvent | undefined;
 export type PluginIntentRecord = PlatformSchemas["PluginIntentRecord"];
 export type PluginIntentList = PlatformSchemas["PluginIntentList"];
 export type PluginIntentListOptions = PlatformSchemas["ListIntentsQueryRequest"];
@@ -144,6 +148,7 @@ export declare class PluginPlatformClient {
     getSettings(pluginInstanceId: string, scope: PluginResourceScopeKind, options?: PluginRequestOptions): Promise<PluginSettingsSnapshot>;
     patchSettings(pluginInstanceId: string, request: PluginSettingsPatchRequest, options?: PluginRequestOptions): Promise<PluginSettingsSnapshot>;
     listExecutions(options?: PluginExecutionListOptions, requestOptions?: PluginRequestOptions): Promise<PluginExecutionList>;
+    listReleaseInstallExecutions(options?: PluginReleaseInstallExecutionListOptions, requestOptions?: PluginRequestOptions): Promise<PluginExecutionList>;
     startReleaseInstallExecution(request: PluginStartReleaseInstallExecutionRequest, options?: PluginRequestOptions): Promise<PluginExecution>;
     getExecution(executionID: string, options?: PluginRequestOptions): Promise<PluginExecution>;
     cancelExecution(executionID: string, reason?: string, options?: PluginRequestOptions): Promise<PluginExecution>;

package/dist/platform.js

@@ -20,6 +20,58 @@ function toPluginSurfaceHostBootstrap(value) {
         runtimeGenerationId: value.runtime_generation_id,
     };
 }
+const releaseInstallStages = ["download", "verify", "install", "enable"];
+const releaseInstallStatuses = ["pending", "running", "completed", "failed"];
+const releaseInstallProgressKeys = [
+    "task_id",
+    "request_id",
+    "stage",
+    "status",
+    "completed",
+    "total",
+    "failure_code",
+    "failure_stage",
+    "retryable",
+];
+/** Reads the stable release-install progress projection from an execution event. */
+export function decodePluginReleaseInstallProgressEvent(event) {
+    const payload = event?.payload;
+    if (!isRecord(payload))
+        return undefined;
+    const value = payload.install_progress;
+    if (!isRecord(value) || !hasOnlyKeys(value, releaseInstallProgressKeys))
+        return undefined;
+    if (!isNonEmptyString(value.task_id) || !isNonEmptyString(value.request_id))
+        return undefined;
+    if (value.task_id !== event.execution_id)
+        return undefined;
+    if (!isOneOf(value.stage, releaseInstallStages) || !isOneOf(value.status, releaseInstallStatuses)) {
+        return undefined;
+    }
+    const hasCompleted = value.completed !== undefined;
+    const hasTotal = value.total !== undefined;
+    if (hasCompleted !== hasTotal)
+        return undefined;
+    if (hasCompleted &&
+        (!isSafeIntegerAtLeast(value.completed, 0) || !isSafeIntegerAtLeast(value.total, 1))) {
+        return undefined;
+    }
+    if (hasCompleted && Number(value.completed) > Number(value.total))
+        return undefined;
+    const failed = value.status === "failed";
+    if (failed) {
+        if (!isNonEmptyString(value.failure_code) ||
+            !isOneOf(value.failure_stage, releaseInstallStages) ||
+            value.failure_stage !== value.stage ||
+            typeof value.retryable !== "boolean") {
+            return undefined;
+        }
+    }
+    else if (value.failure_code !== undefined || value.failure_stage !== undefined || value.retryable !== undefined) {
+        return undefined;
+    }
+    return value;
+}
 export class PluginPlatformClient {
     #fetch;
     #apiBaseURL;
@@ -161,6 +213,9 @@ export class PluginPlatformClient {
     listExecutions(options = {}, requestOptions = {}) {
         return this.#requestQuery("/_redevplugin/api/plugins/executions/query", options, requestOptions);
     }
+    listReleaseInstallExecutions(options = {}, requestOptions = {}) {
+        return this.listExecutions({ ...options, operation_scope: "release_install" }, requestOptions);
+    }
     startReleaseInstallExecution(request, options = {}) {
         return this.#requestMutation("POST", "/_redevplugin/api/plugins/executions/release-installs", request, options);
     }
@@ -412,6 +467,22 @@ function isPluginSessionScopeRevokeResult(value) {
         return false;
     return sessionScopeCountKeys.every((key) => Number.isSafeInteger(counts[key]) && Number(counts[key]) >= 0);
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, keys) {
+    const allowed = new Set(keys);
+    return Object.keys(value).every((key) => allowed.has(key));
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function isOneOf(value, values) {
+    return typeof value === "string" && values.includes(value);
+}
+function isSafeIntegerAtLeast(value, minimum) {
+    return Number.isSafeInteger(value) && Number(value) >= minimum;
+}
 function isExactRecord(value, keys) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return false;

package/dist/surface.js

@@ -1902,29 +1902,6 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
     '    close();',
     '    return;',
     '}',
-    'const __rpVerifyDynamicImportBlocked = () => new Promise((resolve, reject) => {',
-    '    const specifier = "data:text/javascript,export default 1";',
-    '    let settled = false;',
-    '    let timeout;',
-    '    const cleanup = () => { __rpRemoveEventListener("securitypolicyviolation", onViolation, true); if (timeout !== undefined) __rpClearTimeout(timeout); };',
-    '    const finishBlocked = () => { if (settled) return; settled = true; cleanup(); resolve(true); };',
-    '    const finishEscaped = () => {',
-    '        if (settled) { __rpReportFailure(new TypeError("Dynamic import escaped the ReDevPlugin worker sandbox")); return; }',
-    '        settled = true; cleanup(); resolve(false);',
-    '    };',
-    '    const onViolation = (event) => {',
-    '        const directive = String(event && (event.effectiveDirective || event.violatedDirective) || "");',
-    '        const blockedURI = String(event && event.blockedURI || "");',
-    '        if ((directive === "script-src" || directive === "script-src-elem") && (blockedURI === "data" || blockedURI.startsWith("data:"))) finishBlocked();',
-    '    };',
-    '    __rpAddEventListener("securitypolicyviolation", onViolation, true);',
-    '    timeout = __rpSetTimeout(() => { if (settled) return; settled = true; cleanup(); reject(new TypeError("Dynamic import sandbox verification timed out")); }, 1000);',
-    '    try {',
-    '        import(specifier).then(finishEscaped, finishBlocked);',
-    '    } catch {',
-    '        finishBlocked();',
-    '    }',
-    '});',
     'let __rpClaimed = false;',
     'const __rpBridge = Object.freeze({ claim() { if (__rpClaimed) return undefined; __rpClaimed = true; return Object.freeze({ surfaceHandle: __rpSurfaceHandle, port: __rpPort }); } });',
     'Object.defineProperty(globalThis, ' + JSON.stringify(workerGlobalKey) + ', { configurable: false, enumerable: false, writable: false, value: __rpBridge });',
@@ -1944,7 +1921,6 @@ export function createOpaquePluginBootstrapHTML(options = {}) {
     'addEventListener("unhandledrejection", (event) => __rpReportFailure(event.reason || "plugin worker rejected"), { capture: true });',
     'void (async () => {',
     '    try {',
-    '        if (!await __rpVerifyDynamicImportBlocked()) throw new TypeError("Dynamic import escaped the ReDevPlugin worker sandbox");',
     '        __redevpluginPluginMain();',
     '        setTimeout(() => { if (!__rpFailed) __rpControlPost({ type: "redevplugin.worker.ready" }); }, 0);',
     '    } catch (error) {',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/redevplugin-ui",
-  "version": "3.0.12",
+  "version": "3.0.14",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -40,7 +40,7 @@
     "dist"
   ],
   "dependencies": {
-    "@floegence/redevplugin-contracts": "3.0.12"
+    "@floegence/redevplugin-contracts": "3.0.14"
   },
   "publishConfig": {
     "access": "public"