Function connectionCheckHealth

packages/core/sdk/src/executor.ts:3341–3432

(
      ref: ConnectionRef,
      options?: {
        /** Skip the probe and return the persisted verdict when it is younger
         *  than this. The server owns the freshness decision so N open tabs
         *  revalidating on load cannot stampede an upstream. Omit = always
         *  probe (the manual "Check now"). */
        readonly ifStaleMs?: number;
      },
    )

      });

    const connectionCheckHealth = (
      ref: ConnectionRef,
      options?: {
        /** Skip the probe and return the persisted verdict when it is younger
         *  than this. The server owns the freshness decision so N open tabs
         *  revalidating on load cannot stampede an upstream. Omit = always
         *  probe (the manual "Check now"). */
        readonly ifStaleMs?: number;
      },
    ): Effect.Effect<
      HealthCheckResult,
      ConnectionNotFoundError | IntegrationNotFoundError | StorageFailure
    > =>
      Effect.gen(function* () {
        const connectionRow = yield* findConnectionRow(ref);
        if (!connectionRow) {
          return yield* new ConnectionNotFoundError({
            owner: ref.owner,
            integration: ref.integration,
            name: ref.name,
          });
        }
        if (options?.ifStaleMs !== undefined) {
          const cached = Option.getOrNull(decodeLastHealth(connectionRow.last_health));
          if (cached && Date.now() - cached.checkedAt < options.ifStaleMs) {
            yield* annotateHealthVerdict("cache", cached);
            return cached;
          }
        }
        const integrationRow = yield* findIntegrationRow(ref.integration);
        if (!integrationRow) {
          return yield* new IntegrationNotFoundError({ slug: ref.integration });
        }
        const runtime = runtimes.get(integrationRow.plugin_id);
        const check = runtime?.plugin.checkHealth;
        if (!runtime || !check) {
          const result = unknownHealth();
          yield* annotateHealthVerdict("no_capability", result);
          return result;
        }
        const spec = describeHealthCheckForRow(integrationRow) ?? undefined;
        if (spec === undefined && connectionRow.oauth_client != null) {
          // No probe operation is declared, so "healthy" here means only "the
          // credential resolved (refreshing if due)" — a refresh failure is
          // the one real signal this path can produce, and it must not hide
          // inside a green span.
          const result = yield* oauthCredentialHealthWithoutProbe(connectionRow);
          yield* annotateHealthVerdict("credential_only", result);
          yield* persistHealthResult(ref, result);
          return result;
        }

        const result = yield* Effect.gen(function* () {
          const values = yield* resolveConnectionValues(connectionRow);
          const record = rowToIntegrationRecord(
            integrationRow,
            describeAuthMethodsForRow(integrationRow),
          );