Function updateSpec

packages/plugins/openapi/src/sdk/plugin.ts:762–852

(rawSlug: string, input?: OpenApiUpdateSpecInput)

      // the curated description, connections, and policies are all untouched -
      // this is the "spec changed upstream" path, not a re-add.
      const updateSpec = (rawSlug: string, input?: OpenApiUpdateSpecInput) =>
        Effect.gen(function* () {
          const slug = IntegrationSlug.make(rawSlug);
          const record = yield* ctx.core.integrations.get(slug);
          const current = record ? decodeOpenApiIntegrationConfig(record.config) : null;
          if (!record || !current) {
            return yield* new IntegrationNotFoundError({ slug });
          }

          // The new spec source: explicit input wins; otherwise re-fetch from
          // where the spec originally came from. A pasted-blob integration has
          // no origin, so updating it requires a new input.
          const specInput: OpenApiSpecInput | null =
            input?.spec ?? (current.sourceUrl ? { kind: "url", url: current.sourceUrl } : null);
          if (specInput === null) {
            return yield* new OpenApiParseError({
              message:
                "This integration's spec was pasted inline and has no source URL to re-fetch. Provide the updated spec content.",
            });
          }

          // Resolve + compile BEFORE the transaction (same Hyperdrive-deadlock
          // rule as addSpec: never hold BEGIN across a network fetch).
          const resolved = yield* resolveSpecForInput(specInput, httpClientLayer);
          const compiled = yield* compileOpenApiSpec(resolved.specText);

          const previousOperations = yield* ctx.storage.listOperations(rawSlug);
          const previousNames = new Set(previousOperations.map((op) => op.toolName));
          const nextNames = new Set(compiled.definitions.map((def) => def.toolPath));

          // The resolved spec text lives in the plugin blob store keyed by its
          // content hash (`spec/<hash>`); the config carries only the hash. Put
          // the blob outside the transaction - re-puts are idempotent and an
          // aborted config update just leaves an unreferenced blob.
          const specHash = yield* sha256Hex(resolved.specText);
          yield* ctx.storage.putSpec(specHash, resolved.specText);
          yield* ctx.storage.putDefs(specHash, JSON.stringify(compiled.hoistedDefs));

          const nextConfig: OpenApiIntegrationConfig = {
            ...current,
            specHash,
            ...(specInputToSourceUrl(specInput) !== undefined
              ? { sourceUrl: specInputToSourceUrl(specInput) }
              : {}),
          };

          yield* ctx.transaction(
            Effect.gen(function* () {
              yield* ctx.core.integrations.update(slug, {
                config: nextConfig satisfies OpenApiIntegrationConfig as IntegrationConfig,
              });
              yield* ctx.storage.putOperations(
                rawSlug,
                openApiStoredOperationsFromCompiled(rawSlug, compiled),
              );
            }),
          );