@owox/backend 0.37.0 → 0.39.0

package/dist/src/plugin-host/services/remote-url-validator.service.d.ts

@@ -13,6 +13,13 @@ export declare class RemoteUrlValidatorService {
     private readonly logger;
     constructor(config: PluginHostConfigService);
     validate(rawUrl: string): Promise<RemoteUrlCheckResult>;
+    checkPublicHttps(rawUrl: string): Promise<{
+        readonly ok: true;
+    } | {
+        readonly ok: false;
+        readonly code: ReleaseRejectionCode;
+        readonly detail: string;
+    }>;
     private run;
     private walk;
     private guard;

package/dist/src/plugin-host/services/remote-url-validator.service.js

@@ -34,6 +34,10 @@ let RemoteUrlValidatorService = RemoteUrlValidatorService_1 = class RemoteUrlVal
             return this.reject(release_rejection_code_enum_1.ReleaseRejectionCode.URL_UNREACHABLE, 'The delivery URL could not be read');
         }
     }
+    async checkPublicHttps(rawUrl) {
+        const guarded = await this.guard(rawUrl);
+        return guarded.ok ? { ok: true } : guarded;
+    }
     async run(rawUrl) {
         const walked = await this.walk(rawUrl, release_rejection_code_enum_1.ReleaseRejectionCode.URL_UNREACHABLE);
         if (!walked.ok) {

package/dist/src/plugin-host/system-triggers/plugin-action-execution-sweep.processor.d.ts

@@ -0,0 +1,14 @@
+import { SystemTrigger } from '../../common/scheduler/shared/entities/system-trigger.entity';
+import { BaseSystemTaskProcessor } from '../../common/scheduler/system-tasks/base-system-task.processor';
+import { SystemTriggerType } from '../../common/scheduler/system-tasks/system-trigger-type';
+import { PluginActionExecutionService } from '../services/plugin-action-execution.service';
+export declare class PluginActionExecutionSweepProcessor extends BaseSystemTaskProcessor {
+    private readonly executions;
+    private readonly logger;
+    constructor(executions: PluginActionExecutionService);
+    getType(): SystemTriggerType;
+    getDefaultCron(): string;
+    process(_trigger: SystemTrigger, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

package/dist/src/plugin-host/system-triggers/plugin-action-execution-sweep.processor.js

@@ -0,0 +1,50 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var PluginActionExecutionSweepProcessor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginActionExecutionSweepProcessor = void 0;
+const common_1 = require("@nestjs/common");
+const base_system_task_processor_1 = require("../../common/scheduler/system-tasks/base-system-task.processor");
+const system_trigger_type_1 = require("../../common/scheduler/system-tasks/system-trigger-type");
+const plugin_action_limits_1 = require("../constants/plugin-action-limits");
+const plugin_action_execution_service_1 = require("../services/plugin-action-execution.service");
+const CRON = '* * * * *';
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+let PluginActionExecutionSweepProcessor = PluginActionExecutionSweepProcessor_1 = class PluginActionExecutionSweepProcessor extends base_system_task_processor_1.BaseSystemTaskProcessor {
+    executions;
+    logger = new common_1.Logger(PluginActionExecutionSweepProcessor_1.name);
+    constructor(executions) {
+        super();
+        this.executions = executions;
+    }
+    getType() {
+        return system_trigger_type_1.SystemTriggerType.PLUGIN_ACTION_EXECUTION_SWEEP;
+    }
+    getDefaultCron() {
+        return CRON;
+    }
+    async process(_trigger, options) {
+        const now = Date.now();
+        const timedOut = await this.executions.timeOutOrphans(new Date(now - plugin_action_limits_1.PLUGIN_ACTION_LIMITS.orphanGraceMs));
+        await this.executions.clearPayloads(new Date(now - plugin_action_limits_1.PLUGIN_ACTION_LIMITS.payloadRetentionHours * HOUR_MS), options?.signal);
+        await this.executions.deleteFinished(new Date(now - plugin_action_limits_1.PLUGIN_ACTION_LIMITS.rowRetentionDays * DAY_MS), options?.signal);
+        if (timedOut > 0) {
+            this.logger.warn(`${timedOut} plugin action executions outlived the replica that dispatched them and were marked TIMED_OUT`);
+        }
+    }
+};
+exports.PluginActionExecutionSweepProcessor = PluginActionExecutionSweepProcessor;
+exports.PluginActionExecutionSweepProcessor = PluginActionExecutionSweepProcessor = PluginActionExecutionSweepProcessor_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_action_execution_service_1.PluginActionExecutionService])
+], PluginActionExecutionSweepProcessor);
+//# sourceMappingURL=plugin-action-execution-sweep.processor.js.map

package/dist/src/plugin-host/use-cases/cancel-plugin-action-execution.service.d.ts

@@ -0,0 +1,8 @@
+import { CancelPluginActionExecutionCommand } from '../dto/domain/plugin-action-execution.command';
+import type { PluginActionExecutionView } from '../dto/domain/plugin-action-execution.dto';
+import { PluginActionExecutionService } from '../services/plugin-action-execution.service';
+export declare class CancelPluginActionExecutionService {
+    private readonly executions;
+    constructor(executions: PluginActionExecutionService);
+    run(command: CancelPluginActionExecutionCommand): Promise<PluginActionExecutionView>;
+}

package/dist/src/plugin-host/use-cases/cancel-plugin-action-execution.service.js

@@ -0,0 +1,39 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelPluginActionExecutionService = void 0;
+const common_1 = require("@nestjs/common");
+const plugin_action_errors_1 = require("../errors/plugin-action.errors");
+const plugin_action_execution_mapper_1 = require("../mappers/plugin-action-execution.mapper");
+const plugin_action_execution_service_1 = require("../services/plugin-action-execution.service");
+let CancelPluginActionExecutionService = class CancelPluginActionExecutionService {
+    executions;
+    constructor(executions) {
+        this.executions = executions;
+    }
+    async run(command) {
+        const installationId = command.context.installationId;
+        if (installationId) {
+            await this.executions.cancel(command.id, installationId);
+        }
+        const execution = await this.executions.findById(command.id);
+        if (!execution || execution.installationId !== installationId) {
+            throw new plugin_action_errors_1.ExecutionNotFoundError();
+        }
+        return (0, plugin_action_execution_mapper_1.toPluginActionExecutionView)(execution);
+    }
+};
+exports.CancelPluginActionExecutionService = CancelPluginActionExecutionService;
+exports.CancelPluginActionExecutionService = CancelPluginActionExecutionService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_action_execution_service_1.PluginActionExecutionService])
+], CancelPluginActionExecutionService);
+//# sourceMappingURL=cancel-plugin-action-execution.service.js.map

package/dist/src/plugin-host/use-cases/check-plugin-release.service.d.ts

@@ -0,0 +1,22 @@
+import { PluginHostConfigService } from '../config/plugin-host.config';
+import { CheckPluginReleaseCommand, PluginReleaseCheckResultDto } from '../dto/domain/check-plugin-release.command';
+import { GithubApiService } from '../services/github-api.service';
+import { PluginPublicationService } from '../services/plugin-publication.service';
+import { PluginVersionService } from '../services/plugin-version.service';
+import { PluginService } from '../services/plugin.service';
+import { PublicationAuthorizationService } from '../services/publication-authorization.service';
+import { ReleaseCandidateRulesService } from '../services/release-candidate-rules.service';
+export declare class CheckPluginReleaseService {
+    private readonly pluginService;
+    private readonly authorization;
+    private readonly publications;
+    private readonly versionService;
+    private readonly githubApi;
+    private readonly candidateRules;
+    private readonly config;
+    private readonly lastCheckAt;
+    constructor(pluginService: PluginService, authorization: PublicationAuthorizationService, publications: PluginPublicationService, versionService: PluginVersionService, githubApi: GithubApiService, candidateRules: ReleaseCandidateRulesService, config: PluginHostConfigService);
+    run(command: CheckPluginReleaseCommand): Promise<PluginReleaseCheckResultDto>;
+    private versionConflict;
+    private claimSlot;
+}

package/dist/src/plugin-host/use-cases/check-plugin-release.service.js

@@ -0,0 +1,152 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckPluginReleaseService = void 0;
+const common_1 = require("@nestjs/common");
+const plugin_host_config_1 = require("../config/plugin-host.config");
+const github_access_mode_enum_1 = require("../enums/github-access-mode.enum");
+const release_rejection_code_enum_1 = require("../enums/release-rejection-code.enum");
+const plugin_host_errors_1 = require("../errors/plugin-host.errors");
+const github_api_service_1 = require("../services/github-api.service");
+const plugin_publication_service_1 = require("../services/plugin-publication.service");
+const plugin_version_service_1 = require("../services/plugin-version.service");
+const plugin_service_1 = require("../services/plugin.service");
+const publication_authorization_service_1 = require("../services/publication-authorization.service");
+const release_candidate_rules_service_1 = require("../services/release-candidate-rules.service");
+const github_repo_locator_util_1 = require("../utils/github-repo-locator.util");
+const semver_util_1 = require("../utils/semver.util");
+const plugin_publisher_access_1 = require("./plugin-publisher-access");
+let CheckPluginReleaseService = class CheckPluginReleaseService {
+    pluginService;
+    authorization;
+    publications;
+    versionService;
+    githubApi;
+    candidateRules;
+    config;
+    lastCheckAt = new Map();
+    constructor(pluginService, authorization, publications, versionService, githubApi, candidateRules, config) {
+        this.pluginService = pluginService;
+        this.authorization = authorization;
+        this.publications = publications;
+        this.versionService = versionService;
+        this.githubApi = githubApi;
+        this.candidateRules = candidateRules;
+        this.config = config;
+    }
+    async run(command) {
+        const namedSemver = command.version === undefined ? null : eligibleSemver(command.version);
+        const locator = (0, github_repo_locator_util_1.parseGithubRepoLocator)(command.repoLocator);
+        const plugin = await this.pluginService.findByRepoName(locator.owner, locator.name);
+        const isPublisher = this.authorization.isDeploymentPublisher(command.context);
+        const notFound = () => new common_1.NotFoundException(`Plugin ${locator.owner}/${locator.name} was not found on this deployment`);
+        if (!plugin ||
+            !(isPublisher || (await (0, plugin_publisher_access_1.managesPublicationOf)(this.publications, plugin.id, command.context)))) {
+            throw notFound();
+        }
+        this.claimSlot(`${plugin.id}:${command.context.userId || command.context.apiKeyId}`);
+        const ref = { owner: plugin.repoOwner, name: plugin.repoName };
+        if ((await this.githubApi.getRepo(ref)).githubRepoId !== plugin.githubRepoId) {
+            throw notFound();
+        }
+        const current = plugin.currentVersionId
+            ? await this.versionService.findById(plugin.currentVersionId)
+            : null;
+        const semver = namedSemver ?? (current ? nextVersionOf(current.semver) : null);
+        const identity = {
+            pluginId: plugin.id,
+            repository: `${ref.owner}/${ref.name}`,
+            candidateVersion: semver,
+        };
+        const commitSha = await this.githubApi.resolveCommitSha(ref, command.ref);
+        if (!commitSha) {
+            return {
+                ...identity,
+                commitSha: null,
+                baselineVersion: null,
+                collectionsEvaluated: false,
+                issues: [
+                    {
+                        code: release_rejection_code_enum_1.ReleaseRejectionCode.COMMIT_UNRESOLVABLE,
+                        detail: `Ref ${command.ref} does not resolve to a commit`,
+                    },
+                ],
+            };
+        }
+        const versionIssue = semver ? await this.versionConflict(plugin.id, semver, current) : null;
+        const report = await this.candidateRules.collectAll({
+            pluginId: plugin.id,
+            ref,
+            commitSha,
+            semver,
+        });
+        return {
+            ...identity,
+            commitSha,
+            baselineVersion: report.baselineSemver,
+            collectionsEvaluated: report.collectionsEvaluated,
+            issues: [...(versionIssue ? [versionIssue] : []), ...report.issues],
+        };
+    }
+    async versionConflict(pluginId, semver, current) {
+        const recorded = await this.versionService.findBySemver(pluginId, semver);
+        if (recorded) {
+            return {
+                code: release_rejection_code_enum_1.ReleaseRejectionCode.VERSION_CONFLICT,
+                detail: `Version ${semver} is already recorded from commit ${recorded.commitSha}`,
+            };
+        }
+        if (current && (0, semver_util_1.compareSemver)(semver, current.semver) < 0) {
+            return {
+                code: release_rejection_code_enum_1.ReleaseRejectionCode.VERSION_CONFLICT,
+                detail: `Version ${semver} is lower than the current version ${current.semver}; release sync stops at the current version, so it would never become current`,
+            };
+        }
+        return null;
+    }
+    claimSlot(key) {
+        const mode = this.config.isAppModeConfigured
+            ? github_access_mode_enum_1.GithubAccessMode.APP
+            : this.config.githubToken
+                ? github_access_mode_enum_1.GithubAccessMode.SERVER_TOKEN
+                : github_access_mode_enum_1.GithubAccessMode.ANONYMOUS;
+        const intervalMs = this.config.getSyncMinIntervalMs(mode);
+        const now = Date.now();
+        const last = this.lastCheckAt.get(key);
+        if (last !== undefined && now - last < intervalMs) {
+            throw new plugin_host_errors_1.PluginCheckRateLimitedError(Math.ceil((last + intervalMs - now) / 1000));
+        }
+        this.lastCheckAt.set(key, now);
+    }
+};
+exports.CheckPluginReleaseService = CheckPluginReleaseService;
+exports.CheckPluginReleaseService = CheckPluginReleaseService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_service_1.PluginService,
+        publication_authorization_service_1.PublicationAuthorizationService,
+        plugin_publication_service_1.PluginPublicationService,
+        plugin_version_service_1.PluginVersionService,
+        github_api_service_1.GithubApiService,
+        release_candidate_rules_service_1.ReleaseCandidateRulesService,
+        plugin_host_config_1.PluginHostConfigService])
+], CheckPluginReleaseService);
+function nextVersionOf(current) {
+    const [major, minor, patch] = current.split('.').map(Number);
+    return major === 0 ? `0.${minor}.${patch + 1}` : `${major}.${minor + 1}.0`;
+}
+function eligibleSemver(version) {
+    const parsed = (0, semver_util_1.parseReleaseTag)(version);
+    if (!parsed.ok) {
+        throw new common_1.BadRequestException(`Version ${version} is not eligible: use X.Y.Z, optionally prefixed with v, without prerelease or build metadata`);
+    }
+    return (0, semver_util_1.formatSemver)(parsed.parts);
+}
+//# sourceMappingURL=check-plugin-release.service.js.map

package/dist/src/plugin-host/use-cases/find-plugin-by-repository.service.d.ts

@@ -0,0 +1,9 @@
+import { FindPluginByRepositoryCommand } from '../dto/domain/find-plugin-by-repository.command';
+import { PluginPublicationService } from '../services/plugin-publication.service';
+export declare class FindPluginByRepositoryService {
+    private readonly publications;
+    constructor(publications: PluginPublicationService);
+    run(command: FindPluginByRepositoryCommand): Promise<{
+        pluginId: string;
+    }>;
+}

package/dist/src/plugin-host/use-cases/find-plugin-by-repository.service.js

@@ -0,0 +1,35 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindPluginByRepositoryService = void 0;
+const common_1 = require("@nestjs/common");
+const plugin_publication_service_1 = require("../services/plugin-publication.service");
+const github_repo_locator_util_1 = require("../utils/github-repo-locator.util");
+let FindPluginByRepositoryService = class FindPluginByRepositoryService {
+    publications;
+    constructor(publications) {
+        this.publications = publications;
+    }
+    async run(command) {
+        const { owner, name } = (0, github_repo_locator_util_1.parseGithubRepoLocator)(command.repository);
+        const pluginId = await this.publications.findDeploymentPluginIdByRepo(command.context.projectId, owner, name);
+        if (!pluginId) {
+            throw new common_1.NotFoundException('No public plugin is published from this repository');
+        }
+        return { pluginId };
+    }
+};
+exports.FindPluginByRepositoryService = FindPluginByRepositoryService;
+exports.FindPluginByRepositoryService = FindPluginByRepositoryService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_publication_service_1.PluginPublicationService])
+], FindPluginByRepositoryService);
+//# sourceMappingURL=find-plugin-by-repository.service.js.map

package/dist/src/plugin-host/use-cases/get-current-plugin-action-execution.service.d.ts

@@ -0,0 +1,14 @@
+import { type CredentialConsumerBindingFacade } from '../../data-marts/credentials/facades/credential-consumer-binding.facade';
+import { GetCurrentPluginActionExecutionCommand } from '../dto/domain/plugin-action-execution.command';
+import type { PluginActionWorkerContext } from '../dto/domain/plugin-action-execution.dto';
+import { PluginActionExecutionService } from '../services/plugin-action-execution.service';
+import { PluginVersionService } from '../services/plugin-version.service';
+import { PluginService } from '../services/plugin.service';
+export declare class GetCurrentPluginActionExecutionService {
+    private readonly executions;
+    private readonly plugins;
+    private readonly versions;
+    private readonly credentialBindings;
+    constructor(executions: PluginActionExecutionService, plugins: PluginService, versions: PluginVersionService, credentialBindings: CredentialConsumerBindingFacade);
+    run(command: GetCurrentPluginActionExecutionCommand): Promise<PluginActionWorkerContext>;
+}

package/dist/src/plugin-host/use-cases/get-current-plugin-action-execution.service.js

@@ -0,0 +1,85 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCurrentPluginActionExecutionService = void 0;
+const common_1 = require("@nestjs/common");
+const credential_consumer_binding_facade_1 = require("../../data-marts/credentials/facades/credential-consumer-binding.facade");
+const credential_types_1 = require("../../data-marts/credentials/credential.types");
+const plugin_action_errors_1 = require("../errors/plugin-action.errors");
+const plugin_action_execution_service_1 = require("../services/plugin-action-execution.service");
+const plugin_version_service_1 = require("../services/plugin-version.service");
+const plugin_service_1 = require("../services/plugin.service");
+const credential_handles_util_1 = require("../utils/credential-handles.util");
+let GetCurrentPluginActionExecutionService = class GetCurrentPluginActionExecutionService {
+    executions;
+    plugins;
+    versions;
+    credentialBindings;
+    constructor(executions, plugins, versions, credentialBindings) {
+        this.executions = executions;
+        this.plugins = plugins;
+        this.versions = versions;
+        this.credentialBindings = credentialBindings;
+    }
+    async run(command) {
+        const { context } = command;
+        if (!context.executionId) {
+            throw new plugin_action_errors_1.ExecutionTokenRequiredError();
+        }
+        const execution = await this.executions.findWithInput(context.executionId);
+        if (!execution?.deadlineAt || execution.installationId !== context.installationId) {
+            throw new plugin_action_errors_1.ExecutionNotFoundError();
+        }
+        const plugin = await this.plugins.findById(execution.pluginId);
+        const current = plugin?.currentVersionId
+            ? await this.versions.findById(plugin.currentVersionId)
+            : null;
+        const started = current?.id === execution.pluginVersionId
+            ? current
+            : await this.versions.findById(execution.pluginVersionId);
+        if (!plugin || !current || !started) {
+            throw new plugin_action_errors_1.ExecutionNotFoundError();
+        }
+        const ready = await this.credentialBindings.assertConsumerReady({
+            projectId: context.projectId,
+            userId: context.userId,
+            roles: context.roles ?? [],
+            consumerType: 'plugin-installation',
+            consumerId: execution.installationId,
+            requirements: (current.credentialRequirements ?? []).filter(requirement => (0, credential_types_1.normalizeCredentialRequirement)(requirement).definitionId !== null),
+        });
+        return {
+            executionId: execution.id,
+            action: execution.action,
+            input: execution.input,
+            trigger: execution.trigger,
+            deadlineAt: execution.deadlineAt,
+            plugin: { id: plugin.id, repositoryId: plugin.githubRepoId },
+            pluginVersion: started.semver,
+            installationId: execution.installationId,
+            projectId: execution.projectId,
+            userId: execution.userId,
+            credentialHandles: (0, credential_handles_util_1.toCredentialHandles)(ready),
+        };
+    }
+};
+exports.GetCurrentPluginActionExecutionService = GetCurrentPluginActionExecutionService;
+exports.GetCurrentPluginActionExecutionService = GetCurrentPluginActionExecutionService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Inject)(credential_consumer_binding_facade_1.CREDENTIAL_CONSUMER_BINDING_FACADE)),
+    __metadata("design:paramtypes", [plugin_action_execution_service_1.PluginActionExecutionService,
+        plugin_service_1.PluginService,
+        plugin_version_service_1.PluginVersionService, Object])
+], GetCurrentPluginActionExecutionService);
+//# sourceMappingURL=get-current-plugin-action-execution.service.js.map

package/dist/src/plugin-host/use-cases/get-plugin-action-execution.service.d.ts

@@ -0,0 +1,9 @@
+import { GetPluginActionExecutionCommand } from '../dto/domain/plugin-action-execution.command';
+import type { PluginActionExecutionView } from '../dto/domain/plugin-action-execution.dto';
+import { PluginActionExecutionService } from '../services/plugin-action-execution.service';
+export declare class GetPluginActionExecutionService {
+    private readonly executions;
+    constructor(executions: PluginActionExecutionService);
+    run(command: GetPluginActionExecutionCommand): Promise<PluginActionExecutionView>;
+    private find;
+}

package/dist/src/plugin-host/use-cases/get-plugin-action-execution.service.js

@@ -0,0 +1,67 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPluginActionExecutionService = void 0;
+const common_1 = require("@nestjs/common");
+const plugin_action_limits_1 = require("../constants/plugin-action-limits");
+const plugin_action_execution_status_enum_1 = require("../enums/plugin-action-execution-status.enum");
+const plugin_action_errors_1 = require("../errors/plugin-action.errors");
+const plugin_action_execution_mapper_1 = require("../mappers/plugin-action-execution.mapper");
+const plugin_action_execution_service_1 = require("../services/plugin-action-execution.service");
+let GetPluginActionExecutionService = class GetPluginActionExecutionService {
+    executions;
+    constructor(executions) {
+        this.executions = executions;
+    }
+    async run(command) {
+        const waitUntil = Date.now() + command.waitSeconds * 1000;
+        const execution = await this.find(command);
+        let status = execution.status;
+        let polled = false;
+        while (status !== null && !(0, plugin_action_execution_status_enum_1.isFinalPluginActionStatus)(status)) {
+            const remaining = waitUntil - Date.now();
+            if (remaining <= 0 || command.signal.aborted)
+                break;
+            await pause(Math.min(plugin_action_limits_1.PLUGIN_ACTION_LIMITS.waitPollMs, remaining), command.signal);
+            if (command.signal.aborted)
+                break;
+            status = await this.executions.findStatus(command.id);
+            polled = true;
+        }
+        return (0, plugin_action_execution_mapper_1.toPluginActionExecutionView)(polled ? await this.find(command) : execution);
+    }
+    async find(command) {
+        const execution = await this.executions.findById(command.id);
+        if (!execution || execution.installationId !== command.context.installationId) {
+            throw new plugin_action_errors_1.ExecutionNotFoundError();
+        }
+        return execution;
+    }
+};
+exports.GetPluginActionExecutionService = GetPluginActionExecutionService;
+exports.GetPluginActionExecutionService = GetPluginActionExecutionService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_action_execution_service_1.PluginActionExecutionService])
+], GetPluginActionExecutionService);
+function pause(ms, signal) {
+    return new Promise(resolve => {
+        const elapsed = new AbortController();
+        const timer = setTimeout(() => {
+            elapsed.abort();
+            resolve();
+        }, ms);
+        signal.addEventListener('abort', () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true, signal: elapsed.signal });
+    });
+}
+//# sourceMappingURL=get-plugin-action-execution.service.js.map

package/dist/src/plugin-host/use-cases/get-plugin-installation-entry.service.js

@@ -18,6 +18,7 @@ const plugin_host_errors_1 = require("../errors/plugin-host.errors");
 const plugin_installation_service_1 = require("../services/plugin-installation.service");
 const plugin_version_service_1 = require("../services/plugin-version.service");
 const plugin_service_1 = require("../services/plugin.service");
+const credential_handles_util_1 = require("../utils/credential-handles.util");
 const credential_consumer_binding_facade_1 = require("../../data-marts/credentials/facades/credential-consumer-binding.facade");
 let GetPluginInstallationEntryService = class GetPluginInstallationEntryService {
     installations;
@@ -62,13 +63,7 @@ let GetPluginInstallationEntryService = class GetPluginInstallationEntryService
             displayName: version.displayName,
             pluginId: plugin.id,
             versionId: version.id,
-            credentialHandles: readyRequirements.map(requirement => requirement.definitionId === null
-                ? {
-                    name: requirement.key,
-                    kind: 'ai',
-                    models: requirement.models,
-                }
-                : { name: requirement.key, kind: 'exact' }),
+            credentialHandles: (0, credential_handles_util_1.toCredentialHandles)(readyRequirements),
         };
     }
 };

package/dist/src/plugin-host/use-cases/install-plugin.service.js

@@ -69,13 +69,16 @@ let InstallPluginService = class InstallPluginService {
         }
         const existing = await this.installations.findOne(plugin.id, command.context.projectId, command.context.userId);
         let firstInstall = false;
+        let wasUninstalled = false;
         let installation;
         if (existing) {
+            wasUninstalled = existing.uninstalledAt !== null;
             installation = await this.restore(existing);
         }
         else {
             const claimed = await this.installations.installOrFind(plugin.id, command.context.projectId, command.context.userId);
             firstInstall = claimed.wonRace;
+            wasUninstalled = claimed.installation.uninstalledAt !== null;
             installation = claimed.wonRace
                 ? claimed.installation
                 : await this.restore(claimed.installation);
@@ -99,6 +102,7 @@ let InstallPluginService = class InstallPluginService {
             authorityScope: plugin_publication_scope_enum_1.PluginPublicationScope.MEMBER,
             projectId: command.context.projectId,
             userId: command.context.userId,
+            ...(firstInstall ? {} : { beforeState: { uninstalled: wasUninstalled } }),
             afterState: { versionId: plugin.currentVersionId },
         });
         return {

package/dist/src/plugin-host/use-cases/list-installations.service.d.ts

@@ -2,6 +2,7 @@ import { ListInstallationsCommand } from '../dto/domain/list-installations.comma
 import { InstalledPluginDto } from '../dto/domain/plugin-installation.dto';
 import { PluginPresentationMapper } from '../mappers/plugin-presentation.mapper';
 import { PluginInstallationService } from '../services/plugin-installation.service';
+import { PluginPublicationService } from '../services/plugin-publication.service';
 import { PluginVersionService } from '../services/plugin-version.service';
 import { PluginService } from '../services/plugin.service';
 export declare class ListInstallationsService {
@@ -9,6 +10,7 @@ export declare class ListInstallationsService {
     private readonly pluginService;
     private readonly versionService;
     private readonly mapper;
-    constructor(installations: PluginInstallationService, pluginService: PluginService, versionService: PluginVersionService, mapper: PluginPresentationMapper);
+    private readonly publications;
+    constructor(installations: PluginInstallationService, pluginService: PluginService, versionService: PluginVersionService, mapper: PluginPresentationMapper, publications: PluginPublicationService);
     run(command: ListInstallationsCommand): Promise<InstalledPluginDto[]>;
 }