@heroku/sdk 0.11.2 → 0.12.0

package/dist/core/create-client.d.ts

@@ -7,7 +7,7 @@ type RoutesModule = Record<string, Record<string, RouteDefinition>>;
  * and `stream` are deliberately excluded — those belong on the
  * individual route call, not on the client wrapper.
  */
-export type StickyRouteOptions = Pick<RequestOptions, 'headers' | 'signal' | 'timeout'> & {
+export type StickyRouteOptions = Pick<RequestOptions, 'headers' | 'reauthorize' | 'signal' | 'timeout'> & {
     /**
      * Request body applied to write calls on the derived client. Primarily
      * for methods whose route metadata lacks `hasRequestBody` (e.g. DELETE
@@ -30,7 +30,12 @@ export type RoutesClientExtras<T> = {
      * Returns a same-shaped client where each route call applies the
      * provided options. Caller-supplied headers override the api-client's
      * defaults; subsequent `withOptions` calls layer headers and replace
-     * signal / timeout.
+     * signal / timeout / reauthorize.
+     *
+     * Pass `reauthorize: false` to opt the derived client's calls out of the
+     * client-level 401 refresh (see {@link RequestOptions.reauthorize}) — for
+     * call sites where a 401 means something other than an expired Heroku
+     * credential and must not drive a login.
      *
      * The original client is not mutated.
      */

package/dist/core/create-client.js

@@ -11,12 +11,15 @@ function mergeStickyOptions(base, next) {
     if (next.headers || base?.headers) {
         merged.headers = { ...base?.headers, ...next.headers };
     }
-    // signal, timeout, and body are not additive — last wins, but only if
-    // the caller actually set them. Otherwise the previous value persists.
+    // signal, timeout, reauthorize, and body are not additive — last wins,
+    // but only if the caller actually set them. Otherwise the previous value
+    // persists.
     if (next.signal !== undefined)
         merged.signal = next.signal;
     if (next.timeout !== undefined)
         merged.timeout = next.timeout;
+    if (next.reauthorize !== undefined)
+        merged.reauthorize = next.reauthorize;
     if (next.body !== undefined)
         merged.body = next.body;
     return merged;

package/dist/core/extend-resource.d.ts

@@ -1,3 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import { HerokuApiClient } from '@heroku/heroku-fetch';
 import type { DashboardBackendClient } from '../services/dashboard-backend.js';
 import type { DataClient } from '../services/data.js';
 import type { MetricsClient } from '../services/metrics.js';
@@ -14,10 +16,58 @@ type BaseResourceCtx = {
     platform: PlatformClient;
     repositories: RepositoriesClient;
 };
-export type ResourceCtx = BaseResourceCtx & {
+export type ResourceCtx = {
+    /**
+     * Build a raw {@link HerokuApiClient} that inherits the SDK's resolved
+     * client options for the `inheritFrom` service bundle (token,
+     * `userAgent`/headers, `signal`, `timeout`, `warn`, …), with `overrides`
+     * applied last.
+     *
+     * `inheritFrom` selects *which resolved option bundle to start from* — not
+     * the wire service; pass `service` in `overrides` to redirect the client to
+     * a different host and auth behavior. The returned client is raw, NOT the
+     * managed service client: it does not carry that client's `defaultAccept`
+     * (e.g. the platform's `version=3.sdk`) or routes proxy, so callers issue
+     * `get`/`post`/`stream` directly and set `Accept` per call.
+     *
+     * When `overrides.service === 'custom'` the inherited bundle is narrowed to
+     * identity and cancellation only (never auth/routing), so a custom stream
+     * host can't receive the Heroku token, a `reauthorize` login callback, or
+     * consumer headers. Prefer {@link makeCustomHostClient} for that case rather
+     * than assembling the overrides by hand.
+     *
+     * Optional for compatibility with existing extension contexts; prefer
+     * {@link makeCtxClient} at call sites so a context predating this stays
+     * on the pre-threading behavior.
+     *
+     * TODO(next major): make this required on ResourceCtx and drop the
+     * {@link makeCtxClient} fallback once external hand-built contexts are no
+     * longer supported.
+     */
+    makeClient?: (inheritFrom: ServiceName, overrides?: HerokuApiClientOptions) => HerokuApiClient;
     /** Available to SDK-provided extensions; optional for compatibility with existing extension contexts. */
     repositoriesApi?: RepositoriesApiClient;
-};
+} & BaseResourceCtx;
+/**
+ * Build a raw {@link HerokuApiClient} from a resource context, inheriting the
+ * SDK's resolved client options for the `inheritFrom` service bundle
+ * (identity, `signal`, `warn`, token, …) with `overrides` applied last. Falls
+ * back to a bare client carrying only `overrides` when the context predates
+ * {@link ResourceCtx.makeClient} (e.g. a hand-built test ctx, or a standalone
+ * call with no SDK behind it), preserving the pre-threading behavior exactly.
+ */
+export declare function makeCtxClient(ctx: Pick<ResourceCtx, 'makeClient'>, inheritFrom: ServiceName, overrides?: HerokuApiClientOptions): HerokuApiClient;
+/**
+ * Build a raw {@link HerokuApiClient} for a non-Heroku-credential host — a
+ * custom stream/API host the routes-generated clients don't cover (logplex,
+ * busl, exec-manager). Inherits only the SDK's identity and cancellation from
+ * the platform option bundle; forces `service: 'custom'`, the given `baseUrl`,
+ * and an empty `token`, and drops every auth/routing option (`reauthorize`,
+ * `headers`, `hooks`, `twoFactor`, `region`, …) so none crosses to the
+ * third-party origin. `overrides` the call site explicitly sets still apply —
+ * use them for a per-host header or timeout, not to smuggle inherited auth.
+ */
+export declare function makeCustomHostClient(ctx: Pick<ResourceCtx, 'makeClient'>, baseUrl: string, overrides?: Omit<HerokuApiClientOptions, 'baseUrl' | 'service' | 'token'>): HerokuApiClient;
 export type ResourceMethods = Record<string, (...args: any[]) => any>;
 export type ResourceExtension<S extends ServiceName = ServiceName, R extends string = string, M extends ResourceMethods = ResourceMethods> = {
     factory: (ctx: ResourceCtx) => M;

package/dist/core/extend-resource.js

@@ -1,3 +1,30 @@
+import { HerokuApiClient } from '@heroku/heroku-fetch';
+/**
+ * Build a raw {@link HerokuApiClient} from a resource context, inheriting the
+ * SDK's resolved client options for the `inheritFrom` service bundle
+ * (identity, `signal`, `warn`, token, …) with `overrides` applied last. Falls
+ * back to a bare client carrying only `overrides` when the context predates
+ * {@link ResourceCtx.makeClient} (e.g. a hand-built test ctx, or a standalone
+ * call with no SDK behind it), preserving the pre-threading behavior exactly.
+ */
+export function makeCtxClient(ctx, inheritFrom, overrides = {}) {
+    return ctx.makeClient ? ctx.makeClient(inheritFrom, overrides) : new HerokuApiClient(overrides);
+}
+/**
+ * Build a raw {@link HerokuApiClient} for a non-Heroku-credential host — a
+ * custom stream/API host the routes-generated clients don't cover (logplex,
+ * busl, exec-manager). Inherits only the SDK's identity and cancellation from
+ * the platform option bundle; forces `service: 'custom'`, the given `baseUrl`,
+ * and an empty `token`, and drops every auth/routing option (`reauthorize`,
+ * `headers`, `hooks`, `twoFactor`, `region`, …) so none crosses to the
+ * third-party origin. `overrides` the call site explicitly sets still apply —
+ * use them for a per-host header or timeout, not to smuggle inherited auth.
+ */
+export function makeCustomHostClient(ctx, baseUrl, overrides = {}) {
+    return makeCtxClient(ctx, 'platform', {
+        ...overrides, baseUrl, service: 'custom', token: '',
+    });
+}
 export function extendResource(service, resource, factory) {
     return { factory, resource, service };
 }

package/dist/core/heroku-sdk.js

@@ -1,3 +1,4 @@
+import { HerokuApiClient } from '@heroku/heroku-fetch';
 import { createDashboardBackendClient } from '../services/dashboard-backend.js';
 import { createDataClient } from '../services/data.js';
 import { createMetricsClient } from '../services/metrics.js';
@@ -5,7 +6,17 @@ import { createNotificationsClient } from '../services/notifications.js';
 import { createPlatformClient } from '../services/platform.js';
 import { createRepositoriesApiClient } from '../services/repositories-api.js';
 import { createRepositoriesClient } from '../services/repositories.js';
+import { SDK_VERSION } from '../version.js';
 import { mergeExtensions } from './extensions-proxy.js';
+/**
+ * Default `User-Agent` identity for SDK-originated traffic. {@link HerokuSDK}
+ * applies it as a fill-if-absent default on every service client (in its
+ * `#getClientOptions` merge), so requests the SDK drives stay identifiable even
+ * when the consumer passes no `userAgent`. A consumer-supplied
+ * `clientOptions.userAgent` — or a per-service override — wins. The version is
+ * stamped from package.json at build time; see `src/version.ts`.
+ */
+const DEFAULT_USER_AGENT = { name: '@heroku/sdk', version: SDK_VERSION };
 function partitionByService(extensions) {
     const map = new Map();
     for (const ext of extensions) {
@@ -15,6 +26,26 @@ function partitionByService(extensions) {
     }
     return map;
 }
+/**
+ * The options a custom-host client (`service: 'custom'`) inherits from the
+ * SDK's resolved bundle: identity and cancellation only. Every
+ * Heroku-credential-domain option — auth (`token`, `reauthorize`, `twoFactor`),
+ * routing (`headers`, `region`, `defaultAccept`), and consumer
+ * `hooks`/`onResponseMetadata` — is intentionally dropped so it never reaches a
+ * third-party origin (logplex, busl, exec-manager): sending the bearer token or
+ * a consumer `Authorization` header cross-origin would leak credentials, and
+ * inheriting `reauthorize` would turn a non-Heroku 401 into a spurious
+ * `heroku login`.
+ */
+function pickCustomHostOptions(options) {
+    return {
+        ...(options.debug !== undefined && { debug: options.debug }),
+        ...(options.signal !== undefined && { signal: options.signal }),
+        ...(options.timeout !== undefined && { timeout: options.timeout }),
+        ...(options.userAgent !== undefined && { userAgent: options.userAgent }),
+        ...(options.warn !== undefined && { warn: options.warn }),
+    };
+}
 export class HerokuSDK {
     #clientOptions;
     #clientOptionsByService;
@@ -72,6 +103,7 @@ export class HerokuSDK {
         const serviceOptions = { ...serviceOverride };
         delete serviceOptions.service;
         return {
+            userAgent: DEFAULT_USER_AGENT,
             ...this.#clientOptions,
             ...serviceOptions,
         };
@@ -86,6 +118,17 @@ export class HerokuSDK {
                 enumerable: true,
                 get: () => this.#getRawData(),
             },
+            makeClient: {
+                enumerable: true,
+                value: (inheritFrom, overrides = {}) => {
+                    const resolved = this.#getClientOptions(inheritFrom);
+                    // A custom host is not the Heroku credential domain: start from
+                    // identity/cancellation only, never the auth/routing options that
+                    // would leak across origins or drive a re-login on a foreign 401.
+                    const base = overrides.service === 'custom' ? pickCustomHostOptions(resolved) : resolved;
+                    return new HerokuApiClient({ ...base, ...overrides });
+                },
+            },
             metrics: {
                 enumerable: true,
                 get: () => this.#getRawMetrics(),
@@ -122,7 +165,7 @@ export class HerokuSDK {
         return this.#rawMetrics;
     }
     #getRawNotifications() {
-        this.#rawNotifications ??= createNotificationsClient(this.#clientOptions);
+        this.#rawNotifications ??= createNotificationsClient(this.#getClientOptions('notifications'));
         return this.#rawNotifications;
     }
     #getRawPlatform() {

package/dist/resources/platform/dyno/exec.d.ts

@@ -109,8 +109,13 @@ export type ExchangeExecCredentialsOptions = {
  * `Authorization` header survive). The caller feeds the returned info,
  * plus the private key it holds, to its own SSH transport; the SDK does
  * not open the connection.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export declare function exchangeExecCredentials(appIdentity: string, options: ExchangeExecCredentialsOptions): Promise<ExecCredentials>;
+export declare function exchangeExecCredentials(appIdentity: string, options: ExchangeExecCredentialsOptions, ctx?: Pick<ResourceCtx, 'makeClient'>): Promise<ExecCredentials>;
 /** A running exec reservation, as reported by the exec-manager status endpoint. */
 export type ExecReservation = {
     [key: string]: unknown;
@@ -130,5 +135,10 @@ export type ExecStatusOptions = {
  * custom-host Basic-auth setup as {@link exchangeExecCredentials}. The
  * caller correlates each reservation's `dyno_name` with live dyno state
  * for display.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export declare function execStatus(appIdentity: string, options: ExecStatusOptions): Promise<ExecReservation[]>;
+export declare function execStatus(appIdentity: string, options: ExecStatusOptions, ctx?: Pick<ResourceCtx, 'makeClient'>): Promise<ExecReservation[]>;

package/dist/resources/platform/dyno/exec.js

@@ -1,4 +1,5 @@
-import { HerokuApiClient, NotFoundError } from '@heroku/heroku-fetch';
+import { NotFoundError } from '@heroku/heroku-fetch';
+import { makeCustomHostClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 import { waitForInfo } from './wait-for-info.js';
@@ -107,11 +108,16 @@ export async function restartForExec(ctx, appIdentity, dynoIdentity, options = {
  * `Authorization` header survive). The caller feeds the returned info,
  * plus the private key it holds, to its own SSH transport; the SDK does
  * not open the connection.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export async function exchangeExecCredentials(appIdentity, options) {
+export async function exchangeExecCredentials(appIdentity, options, ctx = {}) {
     options.signal?.throwIfAborted();
     const endpoint = resolveExecEndpoint(appIdentity, options.apiKey, options.configVars);
-    const client = newExecClient(endpoint.baseUrl, options.clientOptions);
+    const client = newExecClient(endpoint.baseUrl, options.clientOptions, ctx);
     const path = `${endpoint.apiPath}/${encodeURIComponent(options.dyno)}`;
     const response = await client.put(path, { client_key: options.publicKey }, {
         headers: {
@@ -130,11 +136,16 @@ export async function exchangeExecCredentials(appIdentity, options) {
  * custom-host Basic-auth setup as {@link exchangeExecCredentials}. The
  * caller correlates each reservation's `dyno_name` with live dyno state
  * for display.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export async function execStatus(appIdentity, options) {
+export async function execStatus(appIdentity, options, ctx = {}) {
     options.signal?.throwIfAborted();
     const endpoint = resolveExecEndpoint(appIdentity, options.apiKey, options.configVars);
-    const client = newExecClient(endpoint.baseUrl, options.clientOptions);
+    const client = newExecClient(endpoint.baseUrl, options.clientOptions, ctx);
     const response = await client.get(endpoint.apiPath, {
         headers: { ...options.headers, Authorization: endpoint.authorization },
         signal: options.signal,
@@ -169,10 +180,13 @@ function resolveExecEndpoint(appIdentity, apiKey, configVars) {
         baseUrl: `${url.protocol}//${url.host}`,
     };
 }
-function newExecClient(baseUrl, clientOptions) {
-    return new HerokuApiClient({
-        ...clientOptions, baseUrl, service: 'custom', token: '',
-    });
+function newExecClient(baseUrl, clientOptions, ctx = {}) {
+    // exec-manager is a custom host with Basic auth embedded per request. The
+    // custom-host client forces `token: ''` and inherits only the SDK's identity
+    // (User-Agent) and signal — never `reauthorize`/headers, so a bad-Basic 401
+    // can't drive a spurious `heroku login`. The caller's `clientOptions` still
+    // apply on top.
+    return makeCustomHostClient(ctx, baseUrl, clientOptions);
 }
 function toBasicAuth(username, password) {
     return `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;

package/dist/resources/platform/dyno/index.js

@@ -35,10 +35,10 @@ export async function restartDynos(ctx, appIdentity, target, options = {}) {
 }
 export const dynoExtensions = extendResource('platform', 'dyno', ctx => ({
     enableExec: (appIdentity, options) => (enableExec(ctx, appIdentity, options)),
-    exchangeExecCredentials: (appIdentity, options) => (exchangeExecCredentials(appIdentity, options)),
+    exchangeExecCredentials: (appIdentity, options) => (exchangeExecCredentials(appIdentity, options, ctx)),
     execPrereqs: (appIdentity, options) => (execPrereqs(ctx, appIdentity, options)),
-    execStatus: (appIdentity, options) => (execStatus(appIdentity, options)),
-    listExtended: (appIdentity, options) => (listExtended(appIdentity, options)),
+    execStatus: (appIdentity, options) => (execStatus(appIdentity, options, ctx)),
+    listExtended: (appIdentity, options) => (listExtended(appIdentity, options, ctx)),
     restart: (appIdentity, target, options) => (restartDynos(ctx, appIdentity, target, options)),
     restartForExec: (appIdentity, dynoIdentity, options) => (restartForExec(ctx, appIdentity, dynoIdentity, options)),
     run: (appIdentity, command, options) => (runDyno(ctx, appIdentity, command, options)),

package/dist/resources/platform/dyno/list-extended.d.ts

@@ -1,5 +1,6 @@
 import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
 import type { Dyno } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
 /**
  * Operational detail the platform attaches to each dyno only when the
  * `?extended=true` query is used with the `version=3.sdk` Accept
@@ -46,5 +47,10 @@ export type ListExtendedOptions = {
  *
  * Unlike the routes client, this does not auto-paginate — it issues a
  * single GET, matching the historical CLI behavior.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the bare client.
+ * Standalone callers omit it, and the client falls back to the pre-threading
+ * bare construction.
  */
-export declare function listExtended(appIdentity: string, options?: ListExtendedOptions): Promise<DynoExtended[]>;
+export declare function listExtended(appIdentity: string, options?: ListExtendedOptions, ctx?: Pick<ResourceCtx, 'makeClient'>): Promise<DynoExtended[]>;

package/dist/resources/platform/dyno/list-extended.js

@@ -1,4 +1,4 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
+import { makeCtxClient } from '../../../core/extend-resource.js';
 const ACCEPT_EXTENDED = 'application/vnd.heroku+json; version=3.sdk';
 /**
  * List an app's dynos with the extended operational detail block.
@@ -12,10 +12,15 @@ const ACCEPT_EXTENDED = 'application/vnd.heroku+json; version=3.sdk';
  *
  * Unlike the routes client, this does not auto-paginate — it issues a
  * single GET, matching the historical CLI behavior.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the bare client.
+ * Standalone callers omit it, and the client falls back to the pre-threading
+ * bare construction.
  */
-export async function listExtended(appIdentity, options = {}) {
+export async function listExtended(appIdentity, options = {}, ctx = {}) {
     options.signal?.throwIfAborted();
-    const apiClient = new HerokuApiClient({
+    const apiClient = makeCtxClient(ctx, 'platform', {
         ...options.clientOptions,
         service: 'platform',
     });

package/dist/resources/platform/dyno/run.d.ts

@@ -73,4 +73,4 @@ export type RunDynoOptions = {
  * open their own interactive session; the SDK does not establish the
  * session, spawn ssh, or manage TTY state.
  */
-export declare function runDyno(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, command: string, options?: RunDynoOptions): Promise<Dyno>;
+export declare function runDyno(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, appIdentity: string, command: string, options?: RunDynoOptions): Promise<Dyno>;

package/dist/resources/platform/dyno/run.js

@@ -1,4 +1,5 @@
-import { HerokuApiClient, HerokuApiError } from '@heroku/heroku-fetch';
+import { HerokuApiError } from '@heroku/heroku-fetch';
+import { makeCtxClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 const DEFAULT_RUN_RETRIES = 2;
 const ACCEPT_RUN_INSIDE = 'application/vnd.heroku+json; version=3.sdk';
@@ -59,7 +60,7 @@ export async function runDyno(ctx, appIdentity, command, options = {}) {
 }
 async function postRun(ctx, appIdentity, body, options) {
     if (options.dyno) {
-        const apiClient = new HerokuApiClient({
+        const apiClient = makeCtxClient(ctx, 'platform', {
             ...options.clientOptions,
             service: 'platform',
         });

package/dist/resources/platform/log-session/index.d.ts

@@ -95,7 +95,7 @@ export type StreamLogsOptions = {
  *   - non-2xx response from the logplex URL
  *   - errors thrown by `logSession.create` (auth, app-not-found, etc.)
  */
-export declare function streamLogs(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, options?: StreamLogsOptions): AsyncGenerator<string, void, unknown>;
+export declare function streamLogs(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, appIdentity: string, options?: StreamLogsOptions): AsyncGenerator<string, void, unknown>;
 export declare const logSessionExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "logSession", {
     parseHerokuLogLine: typeof parseHerokuLogLine;
     streamLogs: (appIdentity: string, options?: StreamLogsOptions) => AsyncGenerator<string, void, unknown>;

package/dist/resources/platform/log-session/index.js

@@ -1,6 +1,5 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
-import { extendResource } from '../../../core/extend-resource.js';
+import { extendResource, makeCustomHostClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 import { getGeneration } from '../app/index.js';
 import { parseHerokuLogLine } from './parser.js';
@@ -68,15 +67,12 @@ export async function* streamLogs(ctx, appIdentity, options = {}) {
         try {
             // Logplex URLs hit a region-specific stream host (e.g.
             // virginia.sessions.logs.heroku.com). The token is embedded in
-            // the URL, so we use a custom-service client with no auth and
-            // a per-call baseUrl; this also picks up heroku-fetch's
-            // env-var proxy support.
+            // the URL, so we use a custom-host client with no auth and a
+            // per-call baseUrl, inheriting only the SDK's identity and
+            // cancellation; this also picks up heroku-fetch's env-var proxy
+            // support.
             const parsed = new URL(session.logplex_url);
-            const logplexClient = new HerokuApiClient({
-                baseUrl: parsed.origin,
-                service: 'custom',
-                token: '',
-            });
+            const logplexClient = makeCustomHostClient(ctx, parsed.origin);
             // Fir's telemetry-proxy sends newline-delimited plain text by
             // default, but concatenates records with zero delimiter bytes —
             // splitting on '\n' yields nothing. Requesting SSE flips the

package/dist/resources/platform/pipeline/index.d.ts

@@ -1,5 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
 import type { Pipeline } from '@heroku/types/3.sdk';
-import { type HerokuApiClientOptions } from '@heroku/heroku-fetch';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 export type ResolvePipelineOptions = {
     clientOptions?: HerokuApiClientOptions;
@@ -47,7 +47,7 @@ export declare class PipelineAmbiguousError extends Error {
  *     that want to prompt the user should catch this and inspect
  *     `error.matches`.
  */
-export declare function resolvePipeline(ctx: Pick<ResourceCtx, 'platform'>, identity: string, options?: ResolvePipelineOptions): Promise<Pipeline>;
+export declare function resolvePipeline(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, identity: string, options?: ResolvePipelineOptions): Promise<Pipeline>;
 export declare const pipelineExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "pipeline", {
     resolve: (identity: string, options?: ResolvePipelineOptions) => Promise<Pipeline>;
 }>;

package/dist/resources/platform/pipeline/index.js

@@ -1,5 +1,4 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
-import { extendResource } from '../../../core/extend-resource.js';
+import { extendResource, makeCtxClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 export class PipelineNotFoundError extends Error {
     identity;
@@ -56,7 +55,7 @@ export async function resolvePipeline(ctx, identity, options = {}) {
         // Bind the signal so the lookup aborts in flight.
         return withSignal(ctx.platform, options.signal).pipeline.info(identity);
     }
-    const apiClient = new HerokuApiClient({
+    const apiClient = makeCtxClient(ctx, 'platform', {
         ...options.clientOptions,
         service: 'platform',
     });

package/dist/resources/platform/pipeline/promotion.d.ts

@@ -15,7 +15,7 @@ export type PromotePipelineResult = {
     promotion: PipelinePromotion;
     targets: PipelinePromotionTarget[];
 };
-export declare function promotePipeline(ctx: Pick<ResourceCtx, 'platform'>, body: PipelinePromotionCreateOpts, options?: PromotePipelineOptions): Promise<PromotePipelineResult>;
+export declare function promotePipeline(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, body: PipelinePromotionCreateOpts, options?: PromotePipelineOptions): Promise<PromotePipelineResult>;
 export declare const pipelinePromotionExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "pipelinePromotion", {
     promote: (body: PipelinePromotionCreateOpts, options?: PromotePipelineOptions) => Promise<PromotePipelineResult>;
 }>;

package/dist/resources/platform/pipeline/promotion.js

@@ -1,6 +1,5 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
-import { extendResource } from '../../../core/extend-resource.js';
+import { extendResource, makeCustomHostClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 import { isAbortError } from '../../../utils/is-abort-error.js';
 import { wait } from '../../../utils/wait.js';
@@ -20,7 +19,7 @@ export async function promotePipeline(ctx, body, options = {}) {
     debug('promote created promotion=%s intervalMs=%d timeoutMs=%s', promotion.id, intervalMs, timeoutMs ?? '<none>');
     const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
     const streamRunner = onReleaseStream
-        ? createReleaseStreamRunner(platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal)
+        ? createReleaseStreamRunner(ctx, platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal)
         : undefined;
     let poll = 0;
     while (true) {
@@ -48,7 +47,7 @@ export async function promotePipeline(ctx, body, options = {}) {
  * output stream and hands it to `onReleaseStream`. Subsequent calls are
  * no-ops; the stream is one-shot per promotion.
  */
-function createReleaseStreamRunner(platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal) {
+function createReleaseStreamRunner(ctx, platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal) {
     let handled = false;
     return async (targets) => {
         if (handled || targets.length !== 1)
@@ -64,24 +63,21 @@ function createReleaseStreamRunner(platform, onReleaseStream, releaseStreamMaxAt
             return;
         }
         debug('promote release-stream fetching url=%s maxAttempts=%d', release.output_stream_url, releaseStreamMaxAttempts);
-        const stream = await fetchReleaseOutput(release.output_stream_url, releaseStreamMaxAttempts, intervalMs, signal);
+        const stream = await fetchReleaseOutput(ctx, release.output_stream_url, releaseStreamMaxAttempts, intervalMs, signal);
         await onReleaseStream({ stream, target });
     };
 }
 export const pipelinePromotionExtensions = extendResource('platform', 'pipelinePromotion', ctx => ({
     promote: (body, options) => promotePipeline(ctx, body, options),
 }));
-async function fetchReleaseOutput(url, maxAttempts, intervalMs, signal) {
+async function fetchReleaseOutput(ctx, url, maxAttempts, intervalMs, signal) {
     const parsed = new URL(url);
     const path = `${parsed.pathname}${parsed.search}`;
     // The release output URL points at a third-party stream host (e.g. busl).
-    // Use a custom-service client so the platform prefixUrl and bearer token
-    // don't leak across origins.
-    const buslClient = new HerokuApiClient({
-        baseUrl: parsed.origin,
-        service: 'custom',
-        token: '',
-    });
+    // Use a custom-host client so the platform prefixUrl, bearer token, and
+    // other auth/routing options don't leak across origins, while still
+    // inheriting the SDK's identity (User-Agent) and cancellation signal.
+    const buslClient = makeCustomHostClient(ctx, parsed.origin);
     let attempt = 0;
     while (true) {
         signal?.throwIfAborted();

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "0.12.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+// Generated from package.json by scripts/write-version.mjs (build prebuild). Do not edit.
+export const SDK_VERSION = '0.12.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heroku/sdk",
-  "version": "0.11.2",
+  "version": "0.12.0",
   "description": "Heroku SDK",
   "author": "Heroku",
   "type": "module",
@@ -123,19 +123,24 @@
   },
   "scripts": {
     "clean": "rimraf dist",
+    "generate:version": "node scripts/write-version.mjs",
+    "prebuild": "npm run generate:version",
     "build": "npm run clean && tsc",
+    "prelint": "npm run generate:version",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
+    "pretest": "npm run generate:version",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage --coverage.reporter=text-summary --coverage.reporter=lcovonly",
+    "pretest:types": "npm run generate:version",
     "test:types": "tsc --noEmit -p tsconfig.type-tests.json",
     "prepare": "npm run build",
     "example": "tsx"
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "files": [
     "dist"
@@ -145,16 +150,16 @@
     "@types/debug": "^4.1.12",
     "@types/node": "^26.5.1",
     "@vitest/coverage-v8": "^4.1.8",
+    "@vitest/eslint-plugin": "^1.6.0",
     "eslint": "^9.39.4",
     "eslint-config-oclif": "^6.0.167",
-    "@vitest/eslint-plugin": "^1.6.0",
     "rimraf": "^6.1.3",
     "tsx": "^4.22.4",
     "typescript": "^6.0.2",
     "vitest": "^4.1.4"
   },
   "dependencies": {
-    "@heroku/heroku-fetch": "^0.2.0",
+    "@heroku/heroku-fetch": "^0.2.3",
     "@heroku/types": "^5.0.0",
     "debug": "^4.4.0"
   }