@owox/backend 0.37.0 → 0.39.0

package/dist/src/plugin-host/services/external-credential-definition-sync.service.js

@@ -17,6 +17,7 @@ const credential_external_definition_registry_service_1 = require("../../data-ma
 const external_credential_manifest_1 = require("../../data-marts/credentials/services/external-credential-manifest");
 const credential_types_1 = require("../../data-marts/credentials/credential.types");
 const github_read_policy_enum_1 = require("../enums/github-read-policy.enum");
+const plugin_host_errors_1 = require("../errors/plugin-host.errors");
 const github_repo_locator_util_1 = require("../utils/github-repo-locator.util");
 const semver_util_1 = require("../utils/semver.util");
 const github_api_service_1 = require("./github-api.service");
@@ -30,7 +31,10 @@ let ExternalCredentialDefinitionSyncService = class ExternalCredentialDefinition
         this.github = github;
         this.registry = registry;
     }
-    async syncLocator(locator) {
+    syncLocator(locator) {
+        return this.settleLocator(locator, input => this.registry.register(input));
+    }
+    async settleLocator(locator, settle) {
         const ref = parseExternalLocator(locator);
         const repo = await this.github.getRepo(ref, github_read_policy_enum_1.GithubReadPolicy.CONFIGURED);
         const releases = (await this.github.listReleases(ref, github_read_policy_enum_1.GithubReadPolicy.CONFIGURED))
@@ -54,7 +58,7 @@ let ExternalCredentialDefinitionSyncService = class ExternalCredentialDefinition
                 continue;
             }
             try {
-                return await this.registry.register({
+                return await settle({
                     githubRepoId: repo.githubRepoId,
                     repoOwner: repo.owner,
                     repoName: repo.name,
@@ -77,19 +81,51 @@ let ExternalCredentialDefinitionSyncService = class ExternalCredentialDefinition
         throw new ExternalCredentialRequirementError('No eligible Credential definition release was found');
     }
     async resolveRequirements(requirements) {
-        const resolved = [];
+        const settled = await this.settleRequirements(requirements, locator => this.syncLocator(locator));
+        return settled.map(({ requirement, definition }) => {
+            if (!definition)
+                return requirement;
+            const external = {
+                id: definition.contract.id,
+                definitionId: definition.definitionId,
+                optional: typeof requirement === 'string' ? false : requirement.optional,
+                models: typeof requirement === 'string' ? undefined : requirement.models,
+            };
+            return external;
+        });
+    }
+    async previewRequirements(requirements) {
+        await this.settleRequirements(requirements, async (locator) => {
+            try {
+                return await this.settleLocator(locator, input => this.registry.preview(input));
+            }
+            catch (error) {
+                if (error instanceof plugin_host_errors_1.InvalidRepoLocatorError ||
+                    error instanceof plugin_host_errors_1.GithubRepoNotFoundError ||
+                    error instanceof plugin_host_errors_1.GithubRepoNotAccessibleError) {
+                    const installationUrl = error instanceof plugin_host_errors_1.GithubRepoNotAccessibleError
+                        ? error.errorDetails?.installationUrl
+                        : undefined;
+                    throw new ExternalCredentialRequirementError(`${locator}: ${error.message}${installationUrl ? ` ${installationUrl}` : ''}`);
+                }
+                throw error;
+            }
+        });
+    }
+    async settleRequirements(requirements, settle) {
+        const settled = [];
         for (const requirement of requirements) {
             const locator = typeof requirement === 'string' ? requirement : requirement.id;
             if (!locator.startsWith('@')) {
                 if (locator !== 'ai' && !builtin_credential_definitions_1.BUILTIN_CREDENTIAL_DEFINITION_IDS.has(locator)) {
                     throw new ExternalCredentialRequirementError(`Unknown Credential requirement "${locator}"; use ai, a built-in definition, or @owner/repository`);
                 }
-                resolved.push(requirement);
+                settled.push({ requirement, definition: null });
                 continue;
             }
             let definition;
             try {
-                definition = await this.syncLocator(locator);
+                definition = await settle(locator);
             }
             catch (error) {
                 if (error instanceof ExternalCredentialRequirementError)
@@ -99,23 +135,19 @@ let ExternalCredentialDefinitionSyncService = class ExternalCredentialDefinition
                 }
                 throw error;
             }
-            const external = {
-                id: definition.contract.id,
-                definitionId: definition.definitionId,
-                optional: typeof requirement === 'string' ? false : requirement.optional,
-                models: typeof requirement === 'string' ? undefined : requirement.models,
-            };
-            resolved.push(external);
+            settled.push({ requirement, definition });
         }
         const keys = new Set();
-        for (const requirement of resolved) {
-            const key = (0, credential_types_1.normalizeCredentialRequirement)(requirement).key;
+        for (const { requirement, definition } of settled) {
+            const key = definition
+                ? definition.contract.id
+                : (0, credential_types_1.normalizeCredentialRequirement)(requirement).key;
             if (keys.has(key)) {
                 throw new ExternalCredentialRequirementError(`Duplicate resolved Credential handle ${key}`);
             }
             keys.add(key);
         }
-        return resolved;
+        return settled;
     }
 };
 exports.ExternalCredentialDefinitionSyncService = ExternalCredentialDefinitionSyncService;

package/dist/src/plugin-host/services/plugin-action-dispatcher.service.d.ts

@@ -0,0 +1,13 @@
+import { GracefulShutdownService } from '../../common/scheduler/services/graceful-shutdown.service';
+import { PluginHostConfigService } from '../config/plugin-host.config';
+import type { PluginActionExecution } from '../entities/plugin-action-execution.entity';
+import { PluginActionExecutionService } from './plugin-action-execution.service';
+export declare class PluginActionDispatcherService {
+    private readonly executions;
+    private readonly shutdown;
+    private readonly config;
+    private readonly logger;
+    constructor(executions: PluginActionExecutionService, shutdown: GracefulShutdownService, config: PluginHostConfigService);
+    dispatch(execution: PluginActionExecution, backendUrl: string, token: string, timeoutSeconds: number): Promise<void>;
+    private call;
+}

package/dist/src/plugin-host/services/plugin-action-dispatcher.service.js

@@ -0,0 +1,140 @@
+"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 PluginActionDispatcherService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginActionDispatcherService = void 0;
+const common_1 = require("@nestjs/common");
+const internal_helpers_1 = require("@owox/internal-helpers");
+const guarded_dispatcher_1 = require("../../common/helpers/guarded-dispatcher");
+const read_bounded_body_helper_1 = require("../../common/helpers/read-bounded-body.helper");
+const safe_url_helper_1 = require("../../common/helpers/safe-url.helper");
+const graceful_shutdown_service_1 = require("../../common/scheduler/services/graceful-shutdown.service");
+const plugin_host_config_1 = require("../config/plugin-host.config");
+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_outcome_util_1 = require("../utils/plugin-action-outcome.util");
+const plugin_action_execution_service_1 = require("./plugin-action-execution.service");
+const MAX_RESPONSE_BYTES = plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxResultBytes + 1024;
+const UNSTORABLE_RESULT = {
+    status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.FAILED,
+    errorCode: 'BACKEND_INVALID_RESPONSE',
+    errorMessage: 'The result could not be stored',
+};
+let PluginActionDispatcherService = PluginActionDispatcherService_1 = class PluginActionDispatcherService {
+    executions;
+    shutdown;
+    config;
+    logger = new common_1.Logger(PluginActionDispatcherService_1.name);
+    constructor(executions, shutdown, config) {
+        this.executions = executions;
+        this.shutdown = shutdown;
+        this.config = config;
+    }
+    async dispatch(execution, backendUrl, token, timeoutSeconds) {
+        const processId = this.shutdown.registerActiveProcess(`plugin-action-${execution.id}`);
+        const startedAt = Date.now();
+        const controller = new AbortController();
+        let stopReason;
+        const stop = (reason) => {
+            stopReason ??= reason;
+            controller.abort();
+        };
+        const deadline = setTimeout(() => stop('deadline'), Math.max(0, (execution.deadlineAt?.getTime() ?? startedAt) - startedAt));
+        const poll = setInterval(() => {
+            this.executions.findStatus(execution.id).then(status => {
+                if (status !== plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING)
+                    stop('ended');
+            }, () => undefined);
+        }, plugin_action_limits_1.PLUGIN_ACTION_LIMITS.cancelPollMs);
+        try {
+            let outcome;
+            try {
+                outcome = await this.call(execution.id, backendUrl, token, controller.signal);
+            }
+            catch (error) {
+                outcome =
+                    stopReason === 'deadline'
+                        ? timedOut(timeoutSeconds)
+                        : stopReason === 'ended'
+                            ? null
+                            : unreachable(error);
+            }
+            finally {
+                clearTimeout(deadline);
+                clearInterval(poll);
+            }
+            let recorded = false;
+            if (outcome) {
+                try {
+                    recorded = await this.executions.finish(execution.id, outcome);
+                }
+                catch (error) {
+                    if (outcome.status !== plugin_action_execution_status_enum_1.PluginActionExecutionStatus.SUCCEEDED)
+                        throw error;
+                    this.logger.error(`Plugin action ${execution.id} could not store its result`, (0, internal_helpers_1.castError)(error).stack);
+                    outcome = UNSTORABLE_RESULT;
+                    recorded = await this.executions.finish(execution.id, outcome);
+                }
+            }
+            const status = recorded && outcome ? outcome.status : await this.executions.findStatus(execution.id);
+            const errorCode = recorded && outcome?.status === plugin_action_execution_status_enum_1.PluginActionExecutionStatus.FAILED
+                ? outcome.errorCode
+                : '-';
+            this.logger.log(`Plugin action finished executionId=${execution.id} action=${execution.action} status=${status} errorCode=${errorCode} durationMs=${Date.now() - startedAt}`);
+        }
+        catch (error) {
+            this.logger.error(`Plugin action ${execution.id} could not record its outcome`, (0, internal_helpers_1.castError)(error).stack);
+        }
+        finally {
+            this.shutdown.unregisterActiveProcess(processId);
+        }
+    }
+    async call(executionId, backendUrl, token, signal) {
+        await (0, safe_url_helper_1.assertPublicHttpUrl)(backendUrl, { allowedProtocols: ['https:'] });
+        const response = await fetch(backendUrl, (0, guarded_dispatcher_1.withGuardedDispatcher)({
+            method: 'POST',
+            redirect: 'manual',
+            signal,
+            headers: { 'content-type': 'application/json', 'x-owox-execution-token': token },
+            body: JSON.stringify({ owox: 1, host: this.config.publicOrigin, executionId }),
+        }));
+        const body = await (0, read_bounded_body_helper_1.readBoundedBody)(response, MAX_RESPONSE_BYTES);
+        return (0, plugin_action_outcome_util_1.classifyBackendResponse)(response.status, body?.toString('utf8') ?? null);
+    }
+};
+exports.PluginActionDispatcherService = PluginActionDispatcherService;
+exports.PluginActionDispatcherService = PluginActionDispatcherService = PluginActionDispatcherService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [plugin_action_execution_service_1.PluginActionExecutionService,
+        graceful_shutdown_service_1.GracefulShutdownService,
+        plugin_host_config_1.PluginHostConfigService])
+], PluginActionDispatcherService);
+function timedOut(seconds) {
+    return {
+        status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.TIMED_OUT,
+        errorMessage: `The action did not finish within ${seconds} s`,
+    };
+}
+function unreachable(error) {
+    return {
+        status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.FAILED,
+        errorCode: 'BACKEND_UNREACHABLE',
+        errorMessage: `The backend could not be reached (${reasonOf(error)})`,
+    };
+}
+function reasonOf(error) {
+    if (error instanceof safe_url_helper_1.UnsafeUrlError)
+        return error.reason;
+    const { cause, name } = (0, internal_helpers_1.castError)(error);
+    const code = cause?.code;
+    return typeof code === 'string' ? code : name;
+}
+//# sourceMappingURL=plugin-action-dispatcher.service.js.map

package/dist/src/plugin-host/services/plugin-action-execution.service.d.ts

@@ -0,0 +1,69 @@
+import { Repository } from 'typeorm';
+import { PluginActionExecution } from '../entities/plugin-action-execution.entity';
+import { PluginInstallation } from '../entities/plugin-installation.entity';
+import { PluginActionExecutionStatus, type PluginActionTrigger } from '../enums/plugin-action-execution-status.enum';
+export interface InsertRunningExecutionInput {
+    pluginId: string;
+    pluginVersionId: string;
+    installationId: string;
+    projectId: string;
+    userId: string;
+    action: string;
+    input: unknown;
+    inputBytes: number;
+    role: string;
+    timeoutSeconds: number;
+    tokenHash: string;
+    trigger: PluginActionTrigger;
+}
+declare const TOKEN_OWNER_COLUMNS: {
+    readonly id: true;
+    readonly pluginId: true;
+    readonly installationId: true;
+    readonly projectId: true;
+    readonly userId: true;
+    readonly role: true;
+};
+export type ExecutionTokenOwner = Pick<PluginActionExecution, keyof typeof TOKEN_OWNER_COLUMNS>;
+declare const SUMMARY_COLUMNS: {
+    readonly id: true;
+    readonly installationId: true;
+    readonly action: true;
+    readonly status: true;
+    readonly trigger: true;
+    readonly startedAt: true;
+    readonly deadlineAt: true;
+    readonly finishedAt: true;
+    readonly errorCode: true;
+    readonly errorMessage: true;
+    readonly result: true;
+};
+export type PluginActionExecutionSummary = Pick<PluginActionExecution, keyof typeof SUMMARY_COLUMNS>;
+export type FinishExecutionInput = {
+    status: PluginActionExecutionStatus.SUCCEEDED;
+    result: unknown;
+} | {
+    status: PluginActionExecutionStatus.FAILED;
+    errorCode: string;
+    errorMessage: string;
+} | {
+    status: PluginActionExecutionStatus.TIMED_OUT;
+    errorMessage: string;
+};
+export declare class PluginActionExecutionService {
+    private readonly executions;
+    private readonly installations;
+    constructor(executions: Repository<PluginActionExecution>, installations: Repository<PluginInstallation>);
+    insertRunning(request: InsertRunningExecutionInput): Promise<PluginActionExecution>;
+    assertWithinStartLimits(installationId: string, now: number): Promise<void>;
+    findById(id: string): Promise<PluginActionExecutionSummary | null>;
+    findWithInput(id: string): Promise<PluginActionExecution | null>;
+    findStatus(id: string): Promise<PluginActionExecutionStatus | null>;
+    findRunningByTokenHash(tokenHash: string, now: Date): Promise<ExecutionTokenOwner | null>;
+    finish(id: string, outcome: FinishExecutionInput): Promise<boolean>;
+    cancel(id: string, installationId: string): Promise<boolean>;
+    timeOutOrphans(deadlineBefore: Date): Promise<number>;
+    clearPayloads(finishedBefore: Date, signal?: AbortSignal): Promise<number>;
+    deleteFinished(finishedBefore: Date, signal?: AbortSignal): Promise<number>;
+}
+export {};

package/dist/src/plugin-host/services/plugin-action-execution.service.js

@@ -0,0 +1,239 @@
+"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.PluginActionExecutionService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const typeorm_transactional_1 = require("typeorm-transactional");
+const plugin_action_limits_1 = require("../constants/plugin-action-limits");
+const plugin_action_execution_entity_1 = require("../entities/plugin-action-execution.entity");
+const plugin_installation_entity_1 = require("../entities/plugin-installation.entity");
+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 HOUR_MS = 60 * 60 * 1000;
+const MINUTE_MS = 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+function byteLength(value) {
+    return value === null || value === undefined ? 0 : Buffer.byteLength(JSON.stringify(value) ?? '');
+}
+const TOKEN_OWNER_COLUMNS = {
+    id: true,
+    pluginId: true,
+    installationId: true,
+    projectId: true,
+    userId: true,
+    role: true,
+};
+const SUMMARY_COLUMNS = {
+    id: true,
+    installationId: true,
+    action: true,
+    status: true,
+    trigger: true,
+    startedAt: true,
+    deadlineAt: true,
+    finishedAt: true,
+    errorCode: true,
+    errorMessage: true,
+    result: true,
+};
+let PluginActionExecutionService = class PluginActionExecutionService {
+    executions;
+    installations;
+    constructor(executions, installations) {
+        this.executions = executions;
+        this.installations = installations;
+    }
+    async insertRunning(request) {
+        const lock = await this.installations
+            .createQueryBuilder()
+            .update(plugin_installation_entity_1.PluginInstallation)
+            .set({ modifiedAt: () => 'modifiedAt' })
+            .where('id = :id', { id: request.installationId })
+            .andWhere('uninstalledAt IS NULL')
+            .execute();
+        if (lock.affected !== 1) {
+            throw new plugin_action_errors_1.InstallationInactiveError();
+        }
+        const now = Date.now();
+        const running = await this.executions.countBy({
+            installationId: request.installationId,
+            status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING,
+            deadlineAt: (0, typeorm_2.MoreThan)(new Date(now)),
+        });
+        if (running >= plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxRunningPerInstallation) {
+            throw new plugin_action_errors_1.TooManyExecutionsError();
+        }
+        await this.assertWithinStartLimits(request.installationId, now);
+        const startedAt = new Date(Math.floor(now / 1000) * 1000);
+        return this.executions.save(this.executions.create({
+            pluginId: request.pluginId,
+            pluginVersionId: request.pluginVersionId,
+            installationId: request.installationId,
+            projectId: request.projectId,
+            userId: request.userId,
+            action: request.action,
+            input: request.input,
+            trigger: request.trigger,
+            status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING,
+            role: request.role,
+            tokenHash: request.tokenHash,
+            startedAt,
+            deadlineAt: new Date(Math.ceil((now + request.timeoutSeconds * 1000) / 1000) * 1000),
+            finishedAt: null,
+            errorCode: null,
+            errorMessage: null,
+            result: null,
+            payloadBytes: request.inputBytes,
+        }));
+    }
+    async assertWithinStartLimits(installationId, now) {
+        const raw = await this.executions
+            .createQueryBuilder('e')
+            .select('SUM(CASE WHEN e.startedAt > :minuteAgo THEN 1 ELSE 0 END)', 'perMinute')
+            .addSelect('SUM(CASE WHEN e.startedAt > :dayAgo THEN 1 ELSE 0 END)', 'perDay')
+            .addSelect('SUM(e.payloadBytes)', 'bytes')
+            .where('e.installationId = :installationId', { installationId })
+            .andWhere('e.startedAt > :bytesSince')
+            .setParameters({
+            minuteAgo: new Date(now - MINUTE_MS),
+            dayAgo: new Date(now - DAY_MS),
+            bytesSince: new Date(now - 2 * plugin_action_limits_1.PLUGIN_ACTION_LIMITS.payloadRetentionHours * HOUR_MS),
+        })
+            .getRawOne();
+        const perMinute = Number(raw?.perMinute ?? 0);
+        const perDay = Number(raw?.perDay ?? 0);
+        const bytes = Number(raw?.bytes ?? 0);
+        if (perMinute >= plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxStartsPerInstallationPerMinute) {
+            throw new plugin_action_errors_1.TooManyExecutionsError(`${plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxStartsPerInstallationPerMinute} starts per minute reached`);
+        }
+        if (perDay >= plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxStartsPerInstallationPerDay) {
+            throw new plugin_action_errors_1.TooManyExecutionsError(`${plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxStartsPerInstallationPerDay} starts per day reached`);
+        }
+        if (bytes >= plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxPayloadBytesPerInstallation) {
+            throw new plugin_action_errors_1.TooManyExecutionsError(`${plugin_action_limits_1.PLUGIN_ACTION_LIMITS.maxPayloadBytesPerInstallation / (1024 * 1024)} MiB of stored payloads reached`);
+        }
+    }
+    findById(id) {
+        return this.executions.findOne({ select: SUMMARY_COLUMNS, where: { id } });
+    }
+    findWithInput(id) {
+        return this.executions.findOneBy({ id });
+    }
+    async findStatus(id) {
+        const row = await this.executions.findOne({
+            select: { id: true, status: true },
+            where: { id },
+        });
+        return row?.status ?? null;
+    }
+    findRunningByTokenHash(tokenHash, now) {
+        return this.executions.findOne({
+            select: TOKEN_OWNER_COLUMNS,
+            where: { tokenHash, status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING, deadlineAt: (0, typeorm_2.MoreThan)(now) },
+        });
+    }
+    async finish(id, outcome) {
+        const { affected } = await this.executions.update({ id, status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING }, {
+            status: outcome.status,
+            finishedAt: new Date(),
+            errorCode: outcome.status === plugin_action_execution_status_enum_1.PluginActionExecutionStatus.FAILED ? outcome.errorCode : null,
+            errorMessage: 'errorMessage' in outcome ? outcome.errorMessage : null,
+            result: (outcome.status === plugin_action_execution_status_enum_1.PluginActionExecutionStatus.SUCCEEDED
+                ? outcome.result
+                : null),
+            ...(outcome.status === plugin_action_execution_status_enum_1.PluginActionExecutionStatus.SUCCEEDED && {
+                payloadBytes: () => `payloadBytes + ${byteLength(outcome.result)}`,
+            }),
+        });
+        return affected === 1;
+    }
+    async cancel(id, installationId) {
+        const { affected } = await this.executions.update({ id, installationId, status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING }, {
+            status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.CANCELLED,
+            finishedAt: new Date(),
+            errorMessage: 'The execution was cancelled',
+        });
+        return affected === 1;
+    }
+    async timeOutOrphans(deadlineBefore) {
+        const { affected } = await this.executions.update({ status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.RUNNING, deadlineAt: (0, typeorm_2.LessThan)(deadlineBefore) }, {
+            status: plugin_action_execution_status_enum_1.PluginActionExecutionStatus.TIMED_OUT,
+            finishedAt: new Date(),
+            errorMessage: 'The execution outlived its replica',
+        });
+        return affected ?? 0;
+    }
+    clearPayloads(finishedBefore, signal) {
+        return inBatches(signal, async () => {
+            const rows = await this.executions.find({
+                select: { id: true, errorCode: true },
+                where: { payloadsClearedAt: (0, typeorm_2.IsNull)(), finishedAt: (0, typeorm_2.LessThan)(finishedBefore) },
+                take: plugin_action_limits_1.PLUGIN_ACTION_LIMITS.sweepBatchSize,
+            });
+            if (rows.length === 0)
+                return 0;
+            const pluginAuthored = rows.filter(row => (0, plugin_action_limits_1.isPluginOwnedErrorCode)(row.errorCode));
+            if (pluginAuthored.length > 0) {
+                await this.executions.update({ id: (0, typeorm_2.In)(pluginAuthored.map(row => row.id)) }, { errorMessage: null });
+            }
+            await this.executions.update({ id: (0, typeorm_2.In)(rows.map(row => row.id)) }, {
+                input: () => 'NULL',
+                result: () => 'NULL',
+                payloadsClearedAt: new Date(),
+                payloadBytes: 0,
+            });
+            return rows.length;
+        });
+    }
+    deleteFinished(finishedBefore, signal) {
+        return inBatches(signal, async () => {
+            const rows = await this.executions.find({
+                select: { id: true },
+                where: { finishedAt: (0, typeorm_2.LessThan)(finishedBefore) },
+                take: plugin_action_limits_1.PLUGIN_ACTION_LIMITS.sweepBatchSize,
+            });
+            if (rows.length > 0) {
+                await this.executions.delete({ id: (0, typeorm_2.In)(rows.map(row => row.id)) });
+            }
+            return rows.length;
+        });
+    }
+};
+exports.PluginActionExecutionService = PluginActionExecutionService;
+__decorate([
+    (0, typeorm_transactional_1.Transactional)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], PluginActionExecutionService.prototype, "insertRunning", null);
+exports.PluginActionExecutionService = PluginActionExecutionService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(plugin_action_execution_entity_1.PluginActionExecution)),
+    __param(1, (0, typeorm_1.InjectRepository)(plugin_installation_entity_1.PluginInstallation)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository])
+], PluginActionExecutionService);
+async function inBatches(signal, batch) {
+    let total = 0;
+    while (!signal?.aborted) {
+        const handled = await batch();
+        total += handled;
+        if (handled < plugin_action_limits_1.PLUGIN_ACTION_LIMITS.sweepBatchSize)
+            break;
+    }
+    return total;
+}
+//# sourceMappingURL=plugin-action-execution.service.js.map

package/dist/src/plugin-host/services/plugin-action-starter.service.d.ts

@@ -0,0 +1,22 @@
+import type { StartedPluginActionExecution } from '../dto/domain/plugin-action-execution.dto';
+import type { PluginInstallation } from '../entities/plugin-installation.entity';
+import type { PluginVersion } from '../entities/plugin-version.entity';
+import { type PluginActionTrigger } from '../enums/plugin-action-execution-status.enum';
+import { ActionInputValidatorService } from './action-input-validator.service';
+import { PluginActionDispatcherService } from './plugin-action-dispatcher.service';
+import { PluginActionExecutionService } from './plugin-action-execution.service';
+export interface PluginActionStart {
+    readonly installation: Pick<PluginInstallation, 'id' | 'projectId' | 'userId'>;
+    readonly version: PluginVersion;
+    readonly action: string;
+    readonly input: unknown;
+    readonly role: string;
+    readonly trigger: PluginActionTrigger;
+}
+export declare class PluginActionStarterService {
+    private readonly validator;
+    private readonly executions;
+    private readonly dispatcher;
+    constructor(validator: ActionInputValidatorService, executions: PluginActionExecutionService, dispatcher: PluginActionDispatcherService);
+    start(request: PluginActionStart): Promise<StartedPluginActionExecution>;
+}