@floegence/redevplugin-ui 0.6.6 → 0.6.8

package/dist/contracts.gen.d.ts

@@ -136,12 +136,12 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "owner-scope-inventory-registry";
     readonly path: "spec/plugin/owner-scope-inventories-v1.json";
     readonly version: "owner-scope-inventory-registry-v1";
-    readonly sha256: "92a2d6ed3a9038e95285faa108e2186cf9d0df343854741c551f8c4039f91217";
+    readonly sha256: "f655313a641368383b3d84b6ea4f6a2a2ef42a44a4dd23f71211361c9c2e0505";
 }, {
     readonly id: "owner-scope-inventory-schema";
     readonly path: "spec/plugin/owner-scope-inventory-v1.schema.json";
     readonly version: "owner-scope-inventory-v1";
-    readonly sha256: "972e4fe3cc74339c211ba8a50951ad0f4ae4265d3d34b20f03d0e4888638e254";
+    readonly sha256: "21dc4980103f3a36f4252ce141d7350476ec00968e8a320695e450274e928be1";
 }, {
     readonly id: "owner-scope-migration-schema";
     readonly path: "spec/plugin/owner-scope-migration-v1.schema.json";
@@ -176,7 +176,7 @@ export declare const redevPluginContractArtifacts: readonly [{
     readonly id: "plugin-platform-openapi";
     readonly path: "spec/openapi/plugin-platform-v8.yaml";
     readonly version: "plugin-platform-v8";
-    readonly sha256: "290883ff79b74badbf9f6feddb4dfbef820a4ef4622a7e3fca815e3abb2c4eac";
+    readonly sha256: "39bcfcfb846c868945ab0d21404747b2f5f083574c7ead5aca64f65b98212b7d";
 }, {
     readonly id: "process-containment-schema";
     readonly path: "spec/plugin/process-containment-v1.schema.json";

package/dist/contracts.gen.js

@@ -146,13 +146,13 @@ export const redevPluginContractArtifacts = [
         id: "owner-scope-inventory-registry",
         path: "spec/plugin/owner-scope-inventories-v1.json",
         version: "owner-scope-inventory-registry-v1",
-        sha256: "92a2d6ed3a9038e95285faa108e2186cf9d0df343854741c551f8c4039f91217",
+        sha256: "f655313a641368383b3d84b6ea4f6a2a2ef42a44a4dd23f71211361c9c2e0505",
     },
     {
         id: "owner-scope-inventory-schema",
         path: "spec/plugin/owner-scope-inventory-v1.schema.json",
         version: "owner-scope-inventory-v1",
-        sha256: "972e4fe3cc74339c211ba8a50951ad0f4ae4265d3d34b20f03d0e4888638e254",
+        sha256: "21dc4980103f3a36f4252ce141d7350476ec00968e8a320695e450274e928be1",
     },
     {
         id: "owner-scope-migration-schema",
@@ -194,7 +194,7 @@ export const redevPluginContractArtifacts = [
         id: "plugin-platform-openapi",
         path: "spec/openapi/plugin-platform-v8.yaml",
         version: "plugin-platform-v8",
-        sha256: "290883ff79b74badbf9f6feddb4dfbef820a4ef4622a7e3fca815e3abb2c4eac",
+        sha256: "39bcfcfb846c868945ab0d21404747b2f5f083574c7ead5aca64f65b98212b7d",
     },
     {
         id: "process-containment-schema",

package/dist/openapi.gen.d.ts

@@ -19,6 +19,91 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/_redevplugin/api/plugins/external-packages/inspect": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Resolves and inspects a package from a caller-selected URL or GitHub repository without installing it. Package identity, hashes, provenance, signature state, approval, and update eligibility are computed by the platform and cannot be supplied by the caller. */
+        post: operations["inspectExternalPackage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/_redevplugin/api/plugins/external-packages/upload/inspect": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Uploads and inspects a package for installation without committing it. Package identity, hashes, provenance, signature state, approval, and update eligibility are computed by the platform and cannot be supplied by the caller. The returned inspection is committed and reconciled through the shared external-package commit/query routes. */
+        post: operations["inspectUploadedExternalPackageInstall"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/_redevplugin/api/plugins/{plugin_instance_id}/external-packages/upload/inspect": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        /** @description Uploads and inspects a package for an optimistic-concurrency-controlled update without committing it. Package identity, hashes, provenance, signature state, approval, and update eligibility are computed by the platform and cannot be supplied by the caller. The returned inspection is committed and reconciled through the shared external-package commit/query routes. */
+        put: operations["inspectUploadedExternalPackageUpdate"];
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/_redevplugin/api/plugins/external-packages/commit": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Commits one unexpired inspection after the user confirms its exact server-computed digest. An absent signature does not make a package ineligible for installation; signature assessment affects trust classification and automatic-update eligibility only. */
+        post: operations["commitExternalPackage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/_redevplugin/api/plugins/external-packages/commit/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Reconciles the commit result for one inspection without repeating the mutation. */
+        post: operations["queryExternalPackageCommit"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/_redevplugin/api/plugins/install-release-ref": {
         parameters: {
             query?: never;
@@ -890,6 +975,16 @@ export interface components {
             ok: true;
             data: components["schemas"]["PluginRecord"];
         };
+        ExternalPackageInspectionSuccessResponse: {
+            /** @constant */
+            ok: true;
+            data: components["schemas"]["ExternalPackageInspection"];
+        };
+        ExternalPackageCommitSuccessResponse: {
+            /** @constant */
+            ok: true;
+            data: components["schemas"]["ExternalPackageCommitResult"];
+        };
         PluginCatalogSuccessResponse: {
             /** @constant */
             ok: true;
@@ -898,7 +993,7 @@ export interface components {
         PluginFeaturesSuccessResponse: {
             /** @constant */
             ok: true;
-            data: ("release" | "runtime" | "capability" | "connectivity" | "secrets" | "core_action")[];
+            data: ("release" | "runtime" | "capability" | "connectivity" | "secrets" | "core_action" | "external_package")[];
         };
         CompatibilitySuccessResponse: {
             /** @constant */
@@ -1515,6 +1610,315 @@ export interface components {
             /** Format: date-time */
             updated_at?: string;
         };
+        /** @description Closed install or update intent. Update concurrency values are supplied by the caller, while package identity is always derived from the inspected artifact. */
+        ExternalPackageIntentRequest: {
+            /** @constant */
+            action: "install";
+        } | {
+            /** @constant */
+            action: "update";
+            plugin_instance_id: string;
+            expected_management_revision: number;
+        };
+        /** @description Server-resolved install or update intent. The platform generates the install instance identifier during inspection. */
+        ExternalPackageIntent: {
+            /** @constant */
+            action: "install";
+            plugin_instance_id: string;
+        } | {
+            /** @constant */
+            action: "update";
+            plugin_instance_id: string;
+            expected_management_revision: number;
+        };
+        /** @description Caller-selected external source. Redirect resolution, package hashes, identity, and provenance are derived by the platform. */
+        ExternalPackageSource: {
+            /** @constant */
+            kind: "package_url";
+            /** Format: uri */
+            url: string;
+        } | {
+            /** @constant */
+            kind: "github_repository";
+            /** Format: uri */
+            url: string;
+            /** @description Optional exact release tag. When omitted, the resolver selects the repository's latest eligible release. */
+            tag?: string;
+        };
+        /** @description Requests server-side inspection. Trust, hashes, package identity, approval, provenance, signature assessment, and update eligibility are intentionally not caller-controlled. */
+        InspectExternalPackageRequest: {
+            intent: components["schemas"]["ExternalPackageIntentRequest"];
+            source: components["schemas"]["ExternalPackageSource"];
+        };
+        /** @description Confirms the exact immutable inspection. The digest cannot override any inspected fact. */
+        CommitExternalPackageRequest: {
+            inspection_id: string;
+            confirmation_digest: string;
+        };
+        QueryExternalPackageCommitRequest: {
+            inspection_id: string;
+            commit_id?: string;
+        };
+        /** @description Cryptographic signature fact computed over the inspected artifact. The absent state is installable and affects trust classification and automatic-update eligibility only. */
+        ExternalPackageSignatureAssessment: {
+            /** @enum {string} */
+            state: "verified" | "absent" | "unknown_signer" | "invalid" | "revoked" | "unavailable";
+            reason_codes: string[];
+            assessed_hashes: components["schemas"]["TrustHashSet"];
+            algorithm?: string;
+            key_id?: string;
+            /** Format: date-time */
+            assessed_at: string;
+            assessment_epoch?: string;
+        };
+        /** @description Credential-free redirect projection. Userinfo, query strings, and fragments are never exposed. */
+        ExternalPackageRedirectHop: {
+            /** Format: uri */
+            origin: string;
+            path: string;
+        };
+        /** @description Stable, credential-free source provenance computed after URL, GitHub release, or uploaded-package resolution. Upload identifiers are opaque server-generated values and cannot be supplied by callers. */
+        ExternalPackageSourceProvenance: {
+            /** @constant */
+            kind: "package_url";
+            /** Format: uri */
+            source_origin: string;
+            source_path: string;
+            redirect_chain: components["schemas"]["ExternalPackageRedirectHop"][];
+            package_sha256: string;
+            /** Format: date-time */
+            resolved_at: string;
+        } | {
+            /** @constant */
+            kind: "package_upload";
+            /** @description Opaque server-generated identifier for the staged uploaded artifact. */
+            upload_id: string;
+            package_sha256: string;
+            /** Format: date-time */
+            resolved_at: string;
+        } | {
+            /** @constant */
+            kind: "github_repository";
+            /** @description Stable GitHub repository database ID encoded as decimal text. */
+            repository_id: string;
+            /** @description Stable GitHub release database ID encoded as decimal text. */
+            release_id: string;
+            /** @description Stable GitHub release asset database ID encoded as decimal text. */
+            asset_id: string;
+            /** Format: uri */
+            repository_url: string;
+            /** @description Display-only owner login; repository_id remains authoritative across renames. */
+            owner: string;
+            /** @description Display-only repository name; repository_id remains authoritative across renames. */
+            repository: string;
+            resolved_commit_sha: string;
+            release_tag?: string;
+            asset_name?: string;
+            package_sha256: string;
+            /** Format: date-time */
+            resolved_at: string;
+        };
+        /** @description Execution decision independent from signature state. Session and owner hashes are excluded from this public projection. */
+        ExternalPackageExecutionApproval: {
+            /** @enum {string} */
+            state: "pending" | "user_approved" | "policy_approved" | "policy_blocked";
+            reason_codes: string[];
+            /** Format: date-time */
+            assessed_at: string;
+            /** Format: date-time */
+            approved_at?: string;
+        };
+        /** @description Automatic-update decision. Unsigned or otherwise unverified packages remain installable but are normally manual-only. */
+        ExternalPackageUpdateEligibility: {
+            /** @enum {string} */
+            state: "manual_only" | "automatic_eligible";
+            reason_codes: string[];
+            /** Format: date-time */
+            assessed_at: string;
+        };
+        ExternalPackagePermissionSummary: {
+            permission_id: string;
+            methods: string[];
+        };
+        ExternalPackageMethodRouteSummary: {
+            /** @enum {string} */
+            kind: "capability" | "worker" | "core_action";
+            binding_id?: string;
+            target_method?: string;
+            worker_id?: string;
+            action_id?: string;
+        };
+        ExternalPackageConfirmationSummary: {
+            /** @enum {string} */
+            mode: "none" | "required" | "risk_based";
+            preflight_method?: string;
+            request_hash_fields: string[];
+            plan_hash_required: boolean;
+        };
+        ExternalPackageCancelSummary: {
+            cancelable: boolean;
+            /** @enum {string} */
+            disable_behavior: "cancel" | "orphan" | "wait";
+            /** @enum {string} */
+            uninstall_behavior: "cancel_then_block_delete" | "force_cleanup_allowed";
+            ack_timeout_ms: number;
+        };
+        ExternalPackageMethodSummary: {
+            method: string;
+            route: components["schemas"]["ExternalPackageMethodRouteSummary"];
+            /** @enum {string} */
+            effect: "read" | "write" | "delete" | "execute" | "admin";
+            /** @enum {string} */
+            execution: "sync" | "operation" | "subscription";
+            dangerous: boolean;
+            preflight_only: boolean;
+            required_permissions: string[];
+            confirmation: components["schemas"]["ExternalPackageConfirmationSummary"];
+            cancel?: components["schemas"]["ExternalPackageCancelSummary"];
+        };
+        ExternalPackageCapabilityContractSummary: {
+            binding_id: string;
+            capability_id: string;
+            capability_version: string;
+            contract_sha256: string;
+        };
+        ExternalPackageWorkerSummary: {
+            worker_id: string;
+            artifact: string;
+            /** @constant */
+            abi: "redevplugin-wasm-worker-v2";
+            /** @constant */
+            mode: "job";
+            scope: components["schemas"]["ResourceScopeKind"];
+            memory_limit_bytes: number;
+            idle_timeout_ms: number;
+        };
+        ExternalPackageNetworkMethodAccessSummary: {
+            method: string;
+            operations: ("http" | "http_stream" | "websocket_round_trip" | "tcp_round_trip" | "udp_round_trip")[];
+            http_methods: ("GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS")[];
+        };
+        ExternalPackageNetworkSummary: {
+            connector_id: string;
+            /** @enum {string} */
+            transport: "http" | "websocket" | "tcp" | "udp";
+            scope: components["schemas"]["ResourceScopeKind"];
+            destinations: string[];
+            auth_declared: boolean;
+            tls_declared: boolean;
+            method_access: components["schemas"]["ExternalPackageNetworkMethodAccessSummary"][];
+        };
+        ExternalPackageStorageMethodAccessSummary: {
+            method: string;
+            operations: ("read" | "write" | "delete" | "list" | "get" | "put" | "query" | "exec")[];
+        };
+        ExternalPackageStorageSummary: {
+            store_id: string;
+            /** @enum {string} */
+            kind: "kv" | "files" | "sqlite";
+            scope: components["schemas"]["ResourceScopeKind"];
+            quota_bytes: number;
+            quota_files?: number;
+            schema_version: number;
+            method_access: components["schemas"]["ExternalPackageStorageMethodAccessSummary"][];
+        };
+        ExternalPackageSecretRefSummary: {
+            setting_key: string;
+            secret_ref: string;
+            scope: components["schemas"]["ResourceScopeKind"];
+        };
+        ExternalPackageCoreActionSummary: {
+            method: string;
+            action_id: string;
+            /** @enum {string} */
+            effect: "read" | "write" | "delete" | "execute" | "admin";
+        };
+        ExternalPackageIntentSummary: {
+            intent_id: string;
+            method: string;
+        };
+        ExternalPackageSurfaceSummary: {
+            surface_id: string;
+            /** @enum {string} */
+            kind: "view" | "command" | "background";
+            /** @enum {string} */
+            intent: "primary" | "secondary" | "utility";
+            label: string;
+            entry: string;
+            icon?: string;
+            default_size?: components["schemas"]["ExternalPackageSizeSummary"];
+        };
+        ExternalPackageSizeSummary: {
+            width: number;
+            height: number;
+        };
+        /** @description Closed, display-ready projection of every security-relevant declaration in the inspected manifest. */
+        ExternalPackageSecuritySummary: {
+            summary_sha256: string;
+            permissions: components["schemas"]["ExternalPackagePermissionSummary"][];
+            methods: components["schemas"]["ExternalPackageMethodSummary"][];
+            capability_contracts: components["schemas"]["ExternalPackageCapabilityContractSummary"][];
+            workers: components["schemas"]["ExternalPackageWorkerSummary"][];
+            network: components["schemas"]["ExternalPackageNetworkSummary"][];
+            storage: components["schemas"]["ExternalPackageStorageSummary"][];
+            secret_refs: components["schemas"]["ExternalPackageSecretRefSummary"][];
+            core_actions: components["schemas"]["ExternalPackageCoreActionSummary"][];
+            intents: components["schemas"]["ExternalPackageIntentSummary"][];
+            surfaces: components["schemas"]["ExternalPackageSurfaceSummary"][];
+        };
+        /** @description Immutable inspection projection. Package identity and all four trust/security facts are server-derived. */
+        ExternalPackageInspection: {
+            inspection_id: string;
+            /** Format: date-time */
+            expires_at: string;
+            intent: components["schemas"]["ExternalPackageIntent"];
+            publisher_id: string;
+            plugin_id: string;
+            version: components["schemas"]["StrictSemVer"];
+            inspected_hashes: components["schemas"]["TrustHashSet"];
+            signature_assessment: components["schemas"]["ExternalPackageSignatureAssessment"];
+            source_provenance: components["schemas"]["ExternalPackageSourceProvenance"];
+            execution_approval: components["schemas"]["ExternalPackageExecutionApproval"];
+            update_eligibility: components["schemas"]["ExternalPackageUpdateEligibility"];
+            security_summary: components["schemas"]["ExternalPackageSecuritySummary"];
+            confirmation_digest: string;
+        };
+        /** @description Immutable successful commit evidence. */
+        ExternalPackageCommitReceipt: {
+            commit_id: string;
+            inspection_id: string;
+            package_sha256: string;
+            management_revision: number;
+            /** Format: date-time */
+            committed_at: string;
+        };
+        /** @description Closed commit reconciliation union. A committed result repeats all four facts so clients never infer them from legacy trust_state alone. A failed result is terminal evidence that a durable commit did not occur and requires a fresh inspection before retrying. */
+        ExternalPackageCommitResult: {
+            /** @constant */
+            status: "committed";
+            inspection_id: string;
+            intent: components["schemas"]["ExternalPackageIntent"];
+            receipt: components["schemas"]["ExternalPackageCommitReceipt"];
+            plugin: components["schemas"]["PluginRecord"];
+            signature_assessment: components["schemas"]["ExternalPackageSignatureAssessment"];
+            source_provenance: components["schemas"]["ExternalPackageSourceProvenance"];
+            execution_approval: components["schemas"]["ExternalPackageExecutionApproval"];
+            update_eligibility: components["schemas"]["ExternalPackageUpdateEligibility"];
+            security_summary: components["schemas"]["ExternalPackageSecuritySummary"];
+        } | {
+            /** @constant */
+            status: "in_progress";
+            inspection_id: string;
+            intent: components["schemas"]["ExternalPackageIntent"];
+            retry_after_ms: number;
+        } | {
+            /** @constant */
+            status: "failed";
+            inspection_id: string;
+            intent: components["schemas"]["ExternalPackageIntent"];
+            /** @constant */
+            failure_code: "host_restarted_before_commit";
+        };
         /** @enum {string} */
         TrustState: "verified" | "unsigned_local" | "untrusted" | "needs_review" | "trust_unavailable" | "blocked_security";
         TrustHashSet: {
@@ -1551,6 +1955,11 @@ export interface components {
                 [key: string]: unknown;
             };
             local_import_provenance?: components["schemas"]["LocalImportProvenance"];
+            signature_assessment?: components["schemas"]["ExternalPackageSignatureAssessment"];
+            source_provenance?: components["schemas"]["ExternalPackageSourceProvenance"];
+            execution_approval?: components["schemas"]["ExternalPackageExecutionApproval"];
+            update_eligibility?: components["schemas"]["ExternalPackageUpdateEligibility"];
+            security_summary?: components["schemas"]["ExternalPackageSecuritySummary"];
             capability_contracts?: components["schemas"]["CapabilityContractPin"][];
             manifest: components["schemas"]["ManifestV5"];
             package_entries: components["schemas"]["PackageEntry"][];
@@ -1578,6 +1987,11 @@ export interface components {
                 [key: string]: unknown;
             };
             local_import_provenance?: components["schemas"]["LocalImportProvenance"];
+            signature_assessment?: components["schemas"]["ExternalPackageSignatureAssessment"];
+            source_provenance?: components["schemas"]["ExternalPackageSourceProvenance"];
+            execution_approval?: components["schemas"]["ExternalPackageExecutionApproval"];
+            update_eligibility?: components["schemas"]["ExternalPackageUpdateEligibility"];
+            security_summary?: components["schemas"]["ExternalPackageSecuritySummary"];
             capability_contracts?: components["schemas"]["CapabilityContractPin"][];
             /** @enum {string} */
             enable_state: "disabled" | "enabled" | "disabled_by_policy" | "disabled_incompatible";
@@ -2782,6 +3196,24 @@ export interface components {
                 "application/json": components["schemas"]["PluginRecordSuccessResponse"];
             };
         };
+        /** @description Immutable server-computed package inspection and confirmation boundary. */
+        ExternalPackageInspectionResponse: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ExternalPackageInspectionSuccessResponse"];
+            };
+        };
+        /** @description External package commit reconciliation result with explicit trust, approval, provenance, and update facts. */
+        ExternalPackageCommitResponse: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ExternalPackageCommitSuccessResponse"];
+            };
+        };
         /** @description Installed plugin catalog response with typed registry records. */
         PluginCatalogResponse: {
             headers: {
@@ -3041,6 +3473,21 @@ export interface components {
         SurfaceInstanceID: string;
     };
     requestBodies: {
+        InspectExternalPackageRequest: {
+            content: {
+                "application/json": components["schemas"]["InspectExternalPackageRequest"];
+            };
+        };
+        CommitExternalPackageRequest: {
+            content: {
+                "application/json": components["schemas"]["CommitExternalPackageRequest"];
+            };
+        };
+        QueryExternalPackageCommitRequest: {
+            content: {
+                "application/json": components["schemas"]["QueryExternalPackageCommitRequest"];
+            };
+        };
         InstallReleaseRefRequest: {
             content: {
                 "application/json": components["schemas"]["InstallReleaseRefRequest"];
@@ -3293,6 +3740,84 @@ export interface operations {
             default: components["responses"]["MutationPlatformErrorResponse"];
         };
     };
+    inspectExternalPackage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["InspectExternalPackageRequest"];
+        responses: {
+            200: components["responses"]["ExternalPackageInspectionResponse"];
+            default: components["responses"]["MutationPlatformErrorResponse"];
+        };
+    };
+    inspectUploadedExternalPackageInstall: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/vnd.redevplugin.package+zip": string;
+            };
+        };
+        responses: {
+            200: components["responses"]["ExternalPackageInspectionResponse"];
+            default: components["responses"]["MutationPlatformErrorResponse"];
+        };
+    };
+    inspectUploadedExternalPackageUpdate: {
+        parameters: {
+            query?: never;
+            header: {
+                /** @description Canonical decimal management revision. Duplicate, combined, empty, or whitespace-padded values are rejected. */
+                "X-ReDevPlugin-Expected-Management-Revision": number;
+            };
+            path: {
+                plugin_instance_id: components["parameters"]["PluginInstanceID"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/vnd.redevplugin.package+zip": string;
+            };
+        };
+        responses: {
+            200: components["responses"]["ExternalPackageInspectionResponse"];
+            default: components["responses"]["MutationPlatformErrorResponse"];
+        };
+    };
+    commitExternalPackage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["CommitExternalPackageRequest"];
+        responses: {
+            200: components["responses"]["ExternalPackageCommitResponse"];
+            default: components["responses"]["MutationPlatformErrorResponse"];
+        };
+    };
+    queryExternalPackageCommit: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: components["requestBodies"]["QueryExternalPackageCommitRequest"];
+        responses: {
+            200: components["responses"]["ExternalPackageCommitResponse"];
+            default: components["responses"]["PlatformErrorResponse"];
+        };
+    };
     installReleaseRef: {
         parameters: {
             query?: never;

package/dist/platform.d.ts

@@ -31,6 +31,12 @@ export type PluginPackageHashSet = PlatformSchemas["PackageHashSet"];
 export type PluginReleaseRef = PlatformSchemas["PluginReleaseRef"];
 export type PluginInstallReleaseRefRequest = PlatformSchemas["InstallReleaseRefRequest"];
 export type PluginUpdateReleaseRefRequest = PlatformSchemas["UpdateReleaseRefRequest"];
+export type PluginInspectExternalPackageRequest = PlatformSchemas["InspectExternalPackageRequest"];
+export type PluginUploadedExternalPackageIntent = PlatformSchemas["ExternalPackageIntentRequest"];
+export type PluginExternalPackageInspection = PlatformSchemas["ExternalPackageInspection"];
+export type PluginCommitExternalPackageRequest = PlatformSchemas["CommitExternalPackageRequest"];
+export type PluginQueryExternalPackageCommitRequest = PlatformSchemas["QueryExternalPackageCommitRequest"];
+export type PluginExternalPackageCommitResult = PlatformSchemas["ExternalPackageCommitResult"];
 export type PluginDowngradeRequest = PlatformSchemas["DowngradeRequest"];
 export type PluginEnableRequest = PlatformSchemas["EnableRequest"];
 export type PluginDisableRequest = PlatformSchemas["DisableRequest"];
@@ -119,6 +125,10 @@ export declare class PluginPlatformClient {
     features(options?: PluginRequestOptions): Promise<PluginFeatures>;
     getCompatibility(options?: PluginRequestOptions): Promise<PluginCompatibilityManifest>;
     installReleaseRef(request: PluginInstallReleaseRefRequest, options?: PluginRequestOptions): Promise<PluginRecord>;
+    inspectExternalPackage(request: PluginInspectExternalPackageRequest, options?: PluginRequestOptions): Promise<PluginExternalPackageInspection>;
+    inspectUploadedExternalPackage(intent: PluginUploadedExternalPackageIntent, packageBlob: Blob, options?: PluginRequestOptions): Promise<PluginExternalPackageInspection>;
+    commitExternalPackage(request: PluginCommitExternalPackageRequest, options?: PluginRequestOptions): Promise<PluginExternalPackageCommitResult>;
+    queryExternalPackageCommit(request: PluginQueryExternalPackageCommitRequest, options?: PluginRequestOptions): Promise<PluginExternalPackageCommitResult>;
     updateReleaseRef(request: PluginUpdateReleaseRefRequest, options?: PluginRequestOptions): Promise<PluginRecord>;
     downgradePlugin(request: PluginDowngradeRequest, options?: PluginRequestOptions): Promise<PluginRecord>;
     enablePlugin(request: PluginEnableRequest, options?: PluginRequestOptions): Promise<PluginRecord>;

package/dist/platform.js

@@ -26,6 +26,7 @@ export class PluginPlatformClient {
     #surfaceScope;
     #surfaceTransport;
     #onMutationOutcomeUnknown;
+    #externalInspectionTargets = new Map();
     constructor(options = {}) {
         this.#fetch = options.fetch ?? defaultFetch();
         this.#apiBaseURL = trimTrailingSlash(options.apiBaseURL ?? "");
@@ -39,6 +40,56 @@ export class PluginPlatformClient {
     installReleaseRef(request, options = {}) {
         return this.#requestMutation("POST", "/_redevplugin/api/plugins/install-release-ref", request, options);
     }
+    async inspectExternalPackage(request, options = {}) {
+        const inspection = await this.#requestMutation("POST", "/_redevplugin/api/plugins/external-packages/inspect", request, options);
+        this.#externalInspectionTargets.set(inspection.inspection_id, inspection.intent.plugin_instance_id ?? "");
+        return inspection;
+    }
+    async inspectUploadedExternalPackage(intent, packageBlob, options = {}) {
+        const canonicalIntent = canonicalUploadedExternalPackageIntent(intent);
+        if (!(packageBlob instanceof Blob)) {
+            throw new TypeError("external package upload must be a Blob");
+        }
+        const update = canonicalIntent.action === "update";
+        const path = update
+            ? `/_redevplugin/api/plugins/${encodeURIComponent(canonicalIntent.plugin_instance_id)}/external-packages/upload/inspect`
+            : "/_redevplugin/api/plugins/external-packages/upload/inspect";
+        const inspection = await this.#requestPackageUploadInspection(update ? "PUT" : "POST", path, packageBlob, options, update
+            ? { "X-ReDevPlugin-Expected-Management-Revision": String(canonicalIntent.expected_management_revision) }
+            : {});
+        this.#externalInspectionTargets.set(inspection.inspection_id, update ? canonicalIntent.plugin_instance_id : "");
+        return inspection;
+    }
+    async commitExternalPackage(request, options = {}) {
+        const target = this.#externalInspectionTargets.get(request.inspection_id);
+        let result;
+        try {
+            result = await this.#requestMutation("POST", "/_redevplugin/api/plugins/external-packages/commit", request, options);
+        }
+        catch (error) {
+            await this.#handleMutationFailure(error, target || undefined, "External package commit and local surface teardown failed");
+            throw error;
+        }
+        if (result.status === "committed") {
+            await disposePluginSurfaceScope(this.#surfaceScope, result.plugin.plugin_instance_id);
+            this.#externalInspectionTargets.delete(request.inspection_id);
+        }
+        else if (result.status === "failed") {
+            this.#externalInspectionTargets.delete(request.inspection_id);
+        }
+        return result;
+    }
+    async queryExternalPackageCommit(request, options = {}) {
+        const result = await this.#requestQuery("/_redevplugin/api/plugins/external-packages/commit/query", request, options);
+        if (result.status === "committed") {
+            await disposePluginSurfaceScope(this.#surfaceScope, result.plugin.plugin_instance_id);
+            this.#externalInspectionTargets.delete(request.inspection_id);
+        }
+        else if (result.status === "failed") {
+            this.#externalInspectionTargets.delete(request.inspection_id);
+        }
+        return result;
+    }
     updateReleaseRef(request, options = {}) {
         return this.#mutatePlugin("/_redevplugin/api/plugins/update-release-ref", request, options);
     }
@@ -296,6 +347,58 @@ export class PluginPlatformClient {
         }, operation);
         return readMutationPlatformResponse(response);
     }
+    async #requestPackageUploadInspection(method, path, body, options, metadataHeaders) {
+        const operation = `${method} ${path}`;
+        assertMutationDispatchable(options.signal, operation);
+        const response = await dispatchMutationRequest(this.#fetch, this.#apiBaseURL + path, {
+            method,
+            headers: {
+                "Accept": "application/json",
+                "Content-Type": "application/vnd.redevplugin.package+zip",
+                ...metadataHeaders,
+            },
+            body,
+            credentials: "same-origin",
+            signal: options.signal,
+        }, operation);
+        return readMutationPlatformResponse(response);
+    }
+}
+function canonicalUploadedExternalPackageIntent(intent) {
+    if (typeof intent !== "object" || intent === null || Array.isArray(intent)) {
+        throw new TypeError("uploaded external package intent must be a closed install or update object");
+    }
+    const value = intent;
+    const keys = Object.keys(value).sort();
+    if (value.action === "install") {
+        if (keys.length !== 1 || keys[0] !== "action") {
+            throw new TypeError("uploaded external package install intent accepts only action");
+        }
+        return { action: "install" };
+    }
+    if (value.action !== "update") {
+        throw new TypeError("uploaded external package intent action must be install or update");
+    }
+    const updateKeys = ["action", "expected_management_revision", "plugin_instance_id"];
+    if (keys.length !== updateKeys.length || keys.some((key, index) => key !== updateKeys[index])) {
+        throw new TypeError("uploaded external package update intent requires only action, plugin_instance_id, and expected_management_revision");
+    }
+    if (typeof value.plugin_instance_id !== "string" ||
+        value.plugin_instance_id.length === 0 ||
+        value.plugin_instance_id.trim() !== value.plugin_instance_id ||
+        value.plugin_instance_id.startsWith(".") ||
+        value.plugin_instance_id.includes("/")) {
+        throw new TypeError("uploaded external package update plugin_instance_id must be a canonical non-empty string");
+    }
+    if (!Number.isSafeInteger(value.expected_management_revision) ||
+        value.expected_management_revision <= 0) {
+        throw new TypeError("uploaded external package update expected_management_revision must be a positive safe integer");
+    }
+    return {
+        action: "update",
+        plugin_instance_id: value.plugin_instance_id,
+        expected_management_revision: value.expected_management_revision,
+    };
 }
 const sessionScopeCountKeys = [
     "surfaces",

package/package.json

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