@wtfalch/foundry 0.21.0 → 0.22.0

package/dist/plan/plan-apply.d.ts

@@ -9,7 +9,7 @@ import { type AdoptCandidate, type AdoptInput, type AdoptPlan } from './adopt.js
 import { type AgoraHostPort } from './agora.js';
 import { type StepAction } from './diff.js';
 import { type LiveReaders, type LiveResource, type PlatformLiveReaders } from './live.js';
-import { type HeldKeyResolver } from './platform-org.js';
+import { type EdgePortName, type HeldKeyResolver } from './platform-org.js';
 import type { CallsSfuConnectionPort } from './platform-sfu.js';
 /** Who did it, for `@wtfalch/audit`'s "who, when, the plan, the result" (#9, #19). */
 export interface AuditActor {
@@ -142,6 +142,8 @@ export interface StepExecutionContext {
      * scope key can never collide with the `system:kind:key` form.
      */
     recordScopeId(key: string, id: string): void;
+    /** Removes a recorded id (any key form). Optional: a context without it cannot forget one. */
+    forgetId?(key: string): void;
     /**
      * Writes every id recorded so far to the store now, not only at the end of
      * the run. For an id that must survive a crash mid-step: the ai key's id
@@ -161,6 +163,14 @@ export interface StepExecutor {
     execute(action: StepAction, context: StepExecutionContext): Promise<{
         resourceId?: string;
     } | undefined>;
+    /**
+     * #555: which of the edge-routed ports (`dns`, `zones`, `access`,
+     * `ratelimits`, `tunnels`) this executor was built with its own
+     * implementation of, which it uses before edge. The planner blocks a step
+     * that needs edge only if the port it needs is not listed here. Optional:
+     * an executor without it supplies none.
+     */
+    ownEdgePorts?(): Partial<Record<EdgePortName, boolean>>;
 }
 /**
  * #167: {@link StepExecutionContext}'s platform-scoped counterpart -- what
@@ -212,6 +222,10 @@ export interface PlatformStepExecutor {
         hc?: string;
         /** #540: see `PlanPlatformOptions.blocked.heartbeatsExecutorMissing` (`platform-diff.ts`). */
         heartbeatsExecutorMissing?: boolean;
+        /** See `PlanPlatformOptions.blocked.archonRunsInsideApp`. */
+        archonRunsInsideApp?: boolean;
+        /** See `PlanPlatformOptions.blocked.archonDeployRunning`. */
+        archonDeployRunning?: string;
     }>;
     /**
      * Steps whose live state differs from the declared one in a way the recorded

package/dist/plan/plan-apply.js

@@ -13,7 +13,7 @@ import { FILES_ROOT_UNDELIVERED_SCOPE_KEY, entryFilesUndeliveredScopeKey, } from
 import { readLivePlatformResources, readLiveResources, } from './live.js';
 import { lockedHostnames } from './locked-hostnames.js';
 import { PLATFORM_ARCHON_KEY, PLATFORM_FILES_APPLIED_HOSTNAME_SCOPE_KEY, PLATFORM_FILES_KEY, appStepKey, planPlatform as computePlatformPlanDetail, toPlatformPlan, } from './platform-diff.js';
-import { DEFAULT_ORG_PLATFORM_READINESS, ORG_PLATFORM_KEY_REFS, agoraHostValuesFromPlatform, heldPlatformKeyRefs, orgPlatformReadinessFrom, } from './platform-org.js';
+import { DEFAULT_ORG_PLATFORM_READINESS, ORG_PLATFORM_KEY_REFS, agoraHostValuesFromPlatform, dnsBlockedReason, heldPlatformKeyRefs, orgPlatformReadinessFrom, } from './platform-org.js';
 import { PLATFORM_AUTH_BROKER_MAIL_KEY_REF } from './platform-providers.js';
 import { liveWorkers, workerTraceScopeKeys } from './worker.js';
 /** #441: the lease scope that serializes every mutation of one company, and the one for the shared platform. */
@@ -773,6 +773,9 @@ export class FoundryPlanApply {
             recordScopeId: (key, id) => {
                 serviceIds[key] = id;
             },
+            forgetId: (key) => {
+                delete serviceIds[key];
+            },
             persistScopeIds: async () => {
                 await this.store.putAppliedState({
                     orgId,
@@ -938,7 +941,13 @@ export class FoundryPlanApply {
         catch {
             // not held
         }
-        return { ...readiness, mailKeyHeld, canHoldSecrets: typeof heldKeys?.put === 'function' };
+        return {
+            ...readiness,
+            mailKeyHeld,
+            canHoldSecrets: typeof heldKeys?.put === 'function',
+            dnsBlocked: dnsBlockedReason(platform, recorded),
+            ownEdgePorts: this.executor.ownEdgePorts?.(),
+        };
     }
     /**
      * #177: `AgoraHostValues` from the applied platform, the same
@@ -1171,7 +1180,7 @@ function destroyTargets(serviceIds, orgId) {
             continue;
         }
         for (const [resourceKey, id] of Object.entries(serviceIds)) {
-            if (!resourceKey.startsWith(prefix))
+            if (!resourceKey.startsWith(prefix) || !id)
                 continue;
             // Archon#271: foundry did not create an adopted app or database, so it never deletes it.
             if (adopted.has(resourceKey))
@@ -1224,7 +1233,7 @@ function destroyTargets(serviceIds, orgId) {
         targets.push({ system: 'edge', kind: 'key', key: entryKey, id });
     }
     for (const [resourceKey, id] of Object.entries(serviceIds)) {
-        if (!resourceKey.startsWith('zitadel:app:'))
+        if (!resourceKey.startsWith('zitadel:app:') || !id)
             continue;
         targets.push({
             system: 'zitadel',

package/dist/plan/platform-diff.d.ts

@@ -135,6 +135,15 @@ export declare const PLATFORM_ARCHON_INTEGRATIONS_KEY_SYNCED_SCOPE_KEY = "archon
  * values until someone redeploys by hand (#467).
  */
 export declare const PLATFORM_ARCHON_ENVS_DEPLOYED_SCOPE_KEY = "archon_envs_deployed_hash";
+/**
+ * The uuid of the deployment Archon's step triggered without waiting
+ * (`PlatformArchonDeps.runsInsideApp`), `pending` between the trigger and the
+ * moment its uuid is known. The next plan reads that deployment's status:
+ * running blocks the step, failed or unknown plans it again, finished lets the
+ * next run of the step confirm it (the integrations key-synced marker) and
+ * clear this.
+ */
+export declare const PLATFORM_ARCHON_DEPLOYMENT_SCOPE_KEY = "archon_deployment";
 /**
  * #211 round 4: the broker app id Archon last registered its entry with.
  * `provisionPlatformArchon` reads the broker to register with from
@@ -414,6 +423,16 @@ export declare function platformMailMxHost(apex: string): string;
  */
 export declare const ORG_MAIL_APPLIED_APEX_SCOPE_KEY = "mail_applied_apex";
 export declare const ORG_MAIL_APPLIED_HOST_SCOPE_KEY = "mail_applied_host";
+/**
+ * #554: the mode and `usesDomain` the step last applied. No reader lists a
+ * live `coolify mail <org>` resource, so `planMail` decides "applied" from
+ * the record. Records written before these keys existed lack them; a
+ * missing mode vouches for `hosted` only, a missing `usesDomain` only when
+ * the declared domain equals the recorded `mail_domain`. A park records
+ * mode `off`.
+ */
+export declare const ORG_MAIL_APPLIED_MODE_SCOPE_KEY = "mail_applied_mode";
+export declare const ORG_MAIL_APPLIED_USES_DOMAIN_SCOPE_KEY = "mail_applied_uses_domain";
 /**
  * The key of a hosting entry in a `coolify:app` or `cloudflare:access` step
  * and in the ids recorded for it: `<orgId>:<entry key>`, so a second entry
@@ -577,6 +596,12 @@ export declare const PLATFORM_AI_MIGRATE_BLOCKED_SCOPE_KEY = "ai_platform_migrat
  * that throws) is repaired by the next one.
  */
 export declare const PLATFORM_AI_DEPLOY_PENDING_SCOPE_KEY = "ai_platform_deploy_pending";
+/**
+ * Set before the `coolify:jobs` step writes the scheduler's env and cleared
+ * once its deploy finished, so a run that dies in between is repaired by the
+ * next one. The planner plans the step while it is set.
+ */
+export declare const JOBS_DEPLOY_PENDING_SCOPE_KEY = "jobs_deploy_pending";
 /**
  * #171: the resource key `planFiles` plans under and `FoundryPlatformStepExecutor`
  * dispatches on, the {@link PLATFORM_AUTH_KEY} shape for the files host.
@@ -839,6 +864,15 @@ export interface PlanPlatformOptions {
          * steps" note in `platform-providers.ts`'s `FoundryPlatformStepExecutor.blockedSteps`.
          */
         heartbeatsApiKeyMissing?: boolean;
+        /**
+         * The host runs inside Archon's app (`PlatformArchonDeps.runsInsideApp`):
+         * Archon's step redeploys it, so it is ordered last in the plan, after
+         * every step that would otherwise be lost when the old container stops.
+         * Not a block.
+         */
+        archonRunsInsideApp?: boolean;
+        /** Why Archon's step must wait: the deployment it triggered is still running. Blocks even an applied step. */
+        archonDeployRunning?: string;
     };
     /**
      * Steps whose live state differs from the declared one in a way the recorded

package/dist/plan/platform-diff.js

@@ -156,6 +156,15 @@ export const PLATFORM_ARCHON_INTEGRATIONS_KEY_SYNCED_SCOPE_KEY = 'archon_integra
  * values until someone redeploys by hand (#467).
  */
 export const PLATFORM_ARCHON_ENVS_DEPLOYED_SCOPE_KEY = 'archon_envs_deployed_hash';
+/**
+ * The uuid of the deployment Archon's step triggered without waiting
+ * (`PlatformArchonDeps.runsInsideApp`), `pending` between the trigger and the
+ * moment its uuid is known. The next plan reads that deployment's status:
+ * running blocks the step, failed or unknown plans it again, finished lets the
+ * next run of the step confirm it (the integrations key-synced marker) and
+ * clear this.
+ */
+export const PLATFORM_ARCHON_DEPLOYMENT_SCOPE_KEY = 'archon_deployment';
 /**
  * #211 round 4: the broker app id Archon last registered its entry with.
  * `provisionPlatformArchon` reads the broker to register with from
@@ -451,6 +460,16 @@ export function platformMailMxHost(apex) {
  */
 export const ORG_MAIL_APPLIED_APEX_SCOPE_KEY = 'mail_applied_apex';
 export const ORG_MAIL_APPLIED_HOST_SCOPE_KEY = 'mail_applied_host';
+/**
+ * #554: the mode and `usesDomain` the step last applied. No reader lists a
+ * live `coolify mail <org>` resource, so `planMail` decides "applied" from
+ * the record. Records written before these keys existed lack them; a
+ * missing mode vouches for `hosted` only, a missing `usesDomain` only when
+ * the declared domain equals the recorded `mail_domain`. A park records
+ * mode `off`.
+ */
+export const ORG_MAIL_APPLIED_MODE_SCOPE_KEY = 'mail_applied_mode';
+export const ORG_MAIL_APPLIED_USES_DOMAIN_SCOPE_KEY = 'mail_applied_uses_domain';
 /**
  * The key of a hosting entry in a `coolify:app` or `cloudflare:access` step
  * and in the ids recorded for it: `<orgId>:<entry key>`, so a second entry
@@ -653,6 +672,12 @@ export const PLATFORM_AI_MIGRATE_BLOCKED_SCOPE_KEY = 'ai_platform_migrate_blocke
  * that throws) is repaired by the next one.
  */
 export const PLATFORM_AI_DEPLOY_PENDING_SCOPE_KEY = 'ai_platform_deploy_pending';
+/**
+ * Set before the `coolify:jobs` step writes the scheduler's env and cleared
+ * once its deploy finished, so a run that dies in between is repaired by the
+ * next one. The planner plans the step while it is set.
+ */
+export const JOBS_DEPLOY_PENDING_SCOPE_KEY = 'jobs_deploy_pending';
 /**
  * #171: the resource key `planFiles` plans under and `FoundryPlatformStepExecutor`
  * dispatches on, the {@link PLATFORM_AUTH_KEY} shape for the files host.
@@ -900,7 +925,7 @@ export function planPlatform(platform, live, options = {}) {
         plannedSteps.push(zone);
     // #173: the jobs scheduler, second of the eight services this frame leaves
     // open (this file's own doc comment above).
-    const jobs = planJobs(platform, byKey, claimed, jobsObservable);
+    const jobs = planJobs(platform, byKey, claimed, jobsObservable, recordedIds);
     if (jobs.step)
         plannedSteps.push(jobs.step);
     // A blocked SFU is reported in `unmanaged`, not planned: a step the
@@ -963,8 +988,10 @@ export function planPlatform(platform, live, options = {}) {
     // #175: last, on purpose. Archon's sign-in client lives in the sign-in
     // `planAuth` builds, and its env reads what every other service's step
     // records or delivers, so in one apply it runs after all of them.
-    const archon = planArchon(platform, recordedIds, blocked.archon ?? dnsBlocked?.('Archon'), authReady, drifted.archon);
-    if (archon.step)
+    const archon = planArchon(platform, recordedIds, blocked.archon ?? dnsBlocked?.('Archon'), authReady, drifted.archon, blocked.archonDeployRunning);
+    // The host runs inside this app: its step ends by redeploying the process
+    // that runs the plan, so it goes after everything else (pushed below).
+    if (archon.step && !blocked.archonRunsInsideApp)
         plannedSteps.push(archon.step);
     // #257: after every service above, so a database any of them just
     // recorded is already visible to `recordedIds` on this same plan.
@@ -976,6 +1003,8 @@ export function planPlatform(platform, live, options = {}) {
     const heartbeats = planHeartbeats(platform, recordedIds, hcReady, blocked.heartbeatsExecutorMissing ?? false, blocked.heartbeatsApiKeyMissing ?? false);
     if (heartbeats.step)
         plannedSteps.push(heartbeats.step);
+    if (archon.step && blocked.archonRunsInsideApp)
+        plannedSteps.push(archon.step);
     // #251: one line per service whose recorded applied ref no longer matches
     // what the next apply would use (or, for zitadel, what is actually live).
     // Never pushed into `plannedSteps` -- see `VersionChangeItem`'s own doc
@@ -1114,7 +1143,7 @@ export const JOBS_SCHEDULER_KEY = 'jobs';
  * (`diff.ts`'s eventual `jobs:registration`) has nothing to register against
  * before this exists.
  */
-function planJobs(platform, byKey, claimed, observable) {
+function planJobs(platform, byKey, claimed, observable, recordedIds) {
     const key = resourceKey('coolify', 'jobs', JOBS_SCHEDULER_KEY);
     const live = byKey.get(key);
     if (live)
@@ -1125,8 +1154,14 @@ function planJobs(platform, byKey, claimed, observable) {
         // The step also starts the scheduler's database (0.16.3), so a live app
         // whose database the reader saw stopped plans it again. A status the
         // reader could not read is absent, and plans nothing.
+        // An app without `DATABASE_URL_OWNER` also plans it again: the step
+        // sets the owner and runtime URLs the scheduler's migrate stage needs.
+        // So does a recorded pending deploy: the step wrote its env and died
+        // before the deploy finished.
         const databaseStatus = live.config.databaseStatus;
-        if (typeof databaseStatus !== 'string' || databaseStatus.startsWith('running')) {
+        if (live.config.ownerUrlMissing !== true &&
+            !recordedIds[JOBS_DEPLOY_PENDING_SCOPE_KEY] &&
+            (typeof databaseStatus !== 'string' || databaseStatus.startsWith('running'))) {
             return { step: null, blocked: null };
         }
     }
@@ -2215,9 +2250,12 @@ function planAi(platform, recordedIds, executorBlocked) {
  * ({@link PLATFORM_ARCHON_CONNECTOR_APP_SCOPE_KEY}) plans the step again, as
  * {@link planAuth} does.
  */
-function planArchon(platform, recordedIds, executorBlocked, authReady, drifted) {
+function planArchon(platform, recordedIds, executorBlocked, authReady, drifted, deployRunning) {
     if (!platform.archon.enabled)
         return { step: null, blocked: null };
+    // A deploy the step triggered is still running: planning it again would deploy twice.
+    if (deployRunning)
+        return { step: null, blocked: deployRunning };
     const key = resourceKey('coolify', 'app', PLATFORM_ARCHON_KEY);
     const applied = Boolean(recordedIds[key]) &&
         Boolean(recordedIds[PLATFORM_ARCHON_CONNECTOR_APP_SCOPE_KEY]) &&

package/dist/plan/platform-org.d.ts

@@ -35,6 +35,8 @@ export declare const NO_DOMAIN_MAIL_APEX = "oikos.host";
  * names the same "positional arguments that shifted on every merge" problem
  * this avoids).
  */
+/** The edge-routed ports an executor may be given its own implementation of. */
+export type EdgePortName = 'dns' | 'zones' | 'access' | 'ratelimits' | 'tunnels';
 export interface OrgPlatformReadiness {
     /**
      * `null` until the platform's own mail server (#169) is enabled and
@@ -96,6 +98,22 @@ export interface OrgPlatformReadiness {
      * used to say there was none; N1 is no longer deployed by hand).
      */
     edgeReady: boolean;
+    /**
+     * #555: why a company step that writes through edge cannot run yet, `null`
+     * or absent when none is blocked. DNS records, zones, Access apps, rate
+     * limit rules and tunnels all go through edge unless the host supplies its
+     * own port ({@link ownEdgePorts}); while edge is not applied, `diff.ts`
+     * reports each such step blocked instead of planning one that would fail
+     * half way.
+     */
+    dnsBlocked?: string | null;
+    /**
+     * #555: the edge-routed ports the host's executor supplies itself
+     * (`FoundryStepExecutorPorts.dns` / `zones` / `access` / `ratelimits` /
+     * `tunnels`). The executor uses these before edge, so a step that needs
+     * only these is not blocked by {@link dnsBlocked}.
+     */
+    ownEdgePorts?: Partial<Record<EdgePortName, boolean>>;
     /** `https://<platform.edge.hostname>`, which an entry with `uses.edge` gets as `EDGE_URL`. `null` until `edgeReady`. */
     edgeUrl?: string | null;
     /**
@@ -149,6 +167,16 @@ export interface HeldKeyResolver {
  * (which could carry provider detail) goes nowhere.
  */
 export declare function heldPlatformKeyRefs(heldKeys: HeldKeyResolver): Promise<Set<string>>;
+/**
+ * #555: the reason no company step may write DNS yet, `null` when one may.
+ * Every DNS record, zone, Access app, rate limit rule and tunnel call goes
+ * through edge unless the host supplies its own port
+ * ({@link OrgPlatformReadiness.ownEdgePorts}), so edge must be enabled and
+ * applied (the same check as `edgeReady`, without the host-port half). {@link FoundryPlanApply} sets
+ * {@link OrgPlatformReadiness.dnsBlocked} from this; the pure
+ * {@link orgPlatformReadinessFrom} leaves it unset (nothing blocked).
+ */
+export declare function dnsBlockedReason(platform: DeclaredPlatform, platformRecordedIds: Readonly<Record<string, string>>): string | null;
 /**
  * `FoundryPlanApply.computeFreshPlan`'s own precedent for turning a
  * `PlatformStore`'s `get()`/`getServiceIds()` into what an org's plan needs.

package/dist/plan/platform-org.js

@@ -63,6 +63,23 @@ export async function heldPlatformKeyRefs(heldKeys) {
 function coolifyAppApplied(platformRecordedIds, key) {
     return Boolean(platformRecordedIds[`coolify:app:${key}`]);
 }
+/**
+ * #555: the reason no company step may write DNS yet, `null` when one may.
+ * Every DNS record, zone, Access app, rate limit rule and tunnel call goes
+ * through edge unless the host supplies its own port
+ * ({@link OrgPlatformReadiness.ownEdgePorts}), so edge must be enabled and
+ * applied (the same check as `edgeReady`, without the host-port half). {@link FoundryPlanApply} sets
+ * {@link OrgPlatformReadiness.dnsBlocked} from this; the pure
+ * {@link orgPlatformReadinessFrom} leaves it unset (nothing blocked).
+ */
+export function dnsBlockedReason(platform, platformRecordedIds) {
+    if (!platform.edge.enabled) {
+        return 'every DNS record is written through edge, and the platform does not enable edge';
+    }
+    return coolifyAppApplied(platformRecordedIds, PLATFORM_EDGE_KEY)
+        ? null
+        : 'every DNS record is written through edge, and edge is not applied yet';
+}
 /**
  * `FoundryPlanApply.computeFreshPlan`'s own precedent for turning a
  * `PlatformStore`'s `get()`/`getServiceIds()` into what an org's plan needs.

package/dist/plan/platform-providers.d.ts

@@ -117,7 +117,7 @@ export declare const JOBS_ADMIN_TOKEN_REF = "jobs:scheduler:adminToken";
  * org's own app, reused here for the platform's one scheduler instead of once
  * per org.
  */
-type JobsCoolifyPort = Pick<CoolifyPort, 'findProjectByName' | 'createProject' | 'findOrCreateEnvironment' | 'listServers' | 'requireGithubApp' | 'findApplicationByName' | 'createGithubAppApplication' | 'listDatabases' | 'createPostgresDatabase' | 'getDatabase' | 'raw' | 'bulkUpsertEnvs' | 'getApplication' | 'deploy'>;
+type JobsCoolifyPort = Pick<CoolifyPort, 'findProjectByName' | 'createProject' | 'findOrCreateEnvironment' | 'listServers' | 'requireGithubApp' | 'findApplicationByName' | 'createGithubAppApplication' | 'listDatabases' | 'createPostgresDatabase' | 'getDatabase' | 'raw' | 'bulkUpsertEnvs' | 'listEnvs' | 'getApplication' | 'deploy'>;
 /**
  * Options for {@link FoundryPlatformStepExecutor}'s constructor, replacing
  * four positional arguments that shifted on every merge that added a
@@ -290,6 +290,8 @@ export declare class FoundryPlatformStepExecutor implements PlatformStepExecutor
         hc?: string;
         heartbeatsExecutorMissing?: boolean;
         heartbeatsApiKeyMissing?: boolean;
+        archonRunsInsideApp?: boolean;
+        archonDeployRunning?: string;
     }>;
     /**
      * Whether Archon's live Access policy lets through anyone but the declared
@@ -474,7 +476,7 @@ export interface PlatformMailRuntime {
  * {@link PlatformStepExecutionContext}, bundled like {@link PlatformAuthDeps}.
  */
 export interface PlatformArchonDeps {
-    coolify: Pick<CoolifyPort, 'findProjectByName' | 'createProject' | 'findOrCreateEnvironment' | 'listServers' | 'findApplicationByName' | 'getApplication' | 'requireGithubApp' | 'createGithubAppApplication' | 'createDockerfileApplication' | 'listDatabases' | 'createPostgresDatabase' | 'getDatabase' | 'raw' | 'bulkUpsertEnvs' | 'listEnvs' | 'deleteEnv' | 'updateApplication' | 'deploy' | 'deployAndWait'>;
+    coolify: Pick<CoolifyPort, 'findProjectByName' | 'createProject' | 'findOrCreateEnvironment' | 'listServers' | 'findApplicationByName' | 'getApplication' | 'requireGithubApp' | 'createGithubAppApplication' | 'createDockerfileApplication' | 'listDatabases' | 'createPostgresDatabase' | 'getDatabase' | 'raw' | 'bulkUpsertEnvs' | 'listEnvs' | 'deleteEnv' | 'updateApplication' | 'deploy' | 'deployAndWait' | 'getDeployment'>;
     /** F4.dns: every DNS record call, through edge at its recorded address (see {@link PlatformDnsFactory}). */
     dns: PlatformDnsFactory;
     /** F4.tunnels: every tunnel call, through edge at its recorded address (see {@link PlatformTunnelsFactory}). */
@@ -493,6 +495,15 @@ export interface PlatformArchonDeps {
      * Access app nobody can pass.
      */
     accessEmails: readonly string[];
+    /**
+     * True when the host process runs inside the Coolify app this step
+     * redeploys (Archon's console is `platform:archon`). A deploy that waits
+     * would be killed with the old container, so the step then records every
+     * applied marker first, and triggers the deploy last, without waiting.
+     * The planner puts the step last in the plan. Next plan: the step runs
+     * again only if the app is not running (`archonRedeployFailed`).
+     */
+    runsInsideApp?: boolean;
     /**
      * Reads a secret an earlier step handed to the host through
      * `deliverSecret`, or `null` when none is held under `ref` yet -- the same
@@ -1154,7 +1165,7 @@ export declare class ProvidersPlatformCloudflareReader implements PlatformCloudf
 export declare class ProvidersPlatformCoolifyReader implements PlatformCoolifyReader {
     private readonly client;
     private readonly platformStore;
-    constructor(client: Pick<CoolifyPort, 'getApplication' | 'getDatabase' | 'listDatabaseBackups' | 'raw'>, platformStore: Pick<PlatformStore, 'getServiceIds'>);
+    constructor(client: Pick<CoolifyPort, 'getApplication' | 'getDatabase' | 'listDatabaseBackups' | 'listEnvs' | 'raw'>, platformStore: Pick<PlatformStore, 'getServiceIds'>);
     listResources(): Promise<LiveResource[]>;
 }
 /** Scope id (no `:`): the share domains the runner's Coolify `domains` was last set to, comma-joined. */