@camstack/types 1.2.430 → 1.2.432

package/dist/interfaces/config-ui.d.ts

@@ -996,6 +996,13 @@ export interface ConfigAccountSignInField extends ConfigFieldBase {
     readonly providerLabel: string;
     readonly beginAction: string;
     readonly completeAction: string;
+    /**
+     * Set when the hub captures the vendor redirect itself (the login runs through the hub's
+     * login proxy): the form asks this action while the login tab is open. It answers
+     * `{ pending: true }` until the sign-in finished, then the fields `completeAction` returns.
+     * The paste box stays as the fallback when the page does not finish.
+     */
+    readonly claimAction?: string;
     readonly signOutAction: string;
     /** Non-secret settings key holding the account label. */
     readonly accountKey: string;

package/dist/vendor-login-proxy/index.d.ts

@@ -0,0 +1,3 @@
+export { VendorLoginProxy, type LoginProxyAttemptSpec, type LoginProxyResponseView, type LoginProxyVerdict, type VendorLoginProxyOptions, } from './login-proxy.js';
+export { rewriteBody, rewriteLocation, rewriteReferer, rewriteSetCookie, type LoginProxyRoute, type LoginProxyScheme, type LoginProxyUpstream, } from './url-rewrite.js';
+export { VENDOR_LOGIN_PROXY_PREFIX } from './prefix.js';

package/dist/vendor-login-proxy/login-proxy.d.ts

@@ -0,0 +1,53 @@
+import type { DataPlaneHandler } from '../interfaces/addon-data-plane.js';
+import type { IScopedLogger } from '../interfaces/logging.js';
+import { type OauthLandingOutcome } from '../utils/oauth-landing.js';
+import { type LoginProxyUpstream } from './url-rewrite.js';
+/** What the terminal function sees of one upstream response. Never logged. */
+export interface LoginProxyResponseView {
+    readonly status: number;
+    /** The vendor URL that was requested. */
+    readonly url: string;
+    /** The raw `Location` the vendor sent (a custom app scheme is visible here), or null. */
+    readonly location: string | null;
+    readonly setCookies: readonly string[];
+    /** The body when it is small text (HTML/JSON/JS), else null. */
+    readonly bodyText: string | null;
+}
+export type LoginProxyVerdict<T> = {
+    readonly kind: 'continue';
+} | {
+    readonly kind: 'done';
+    readonly payload: T;
+};
+export interface LoginProxyAttemptSpec<T> {
+    /** The attempt id the addon already minted (a sign-in attempt id); the path capability. */
+    readonly attemptId: string;
+    readonly expiresAtMs: number;
+    readonly upstreams: readonly LoginProxyUpstream[];
+    /** Called for every upstream response of this attempt. */
+    readonly terminal: (view: LoginProxyResponseView) => LoginProxyVerdict<T> | Promise<LoginProxyVerdict<T>>;
+    /** Finish the sign-in with the payload; the outcome picks the result page the browser lands on. */
+    readonly onDone: (payload: T) => Promise<OauthLandingOutcome>;
+}
+export interface VendorLoginProxyOptions {
+    readonly addonId: string;
+    readonly logger: IScopedLogger;
+    readonly now?: () => number;
+    /** Injectable for tests; defaults to the platform `fetch`. */
+    readonly fetchFn?: typeof fetch;
+}
+export declare class VendorLoginProxy {
+    #private;
+    constructor(options: VendorLoginProxyOptions);
+    /** The `DataPlaneHandler` to pass to `ctx.dataPlane.serve({ prefix: VENDOR_LOGIN_PROXY_PREFIX, access: 'admin', … })`. */
+    readonly handler: DataPlaneHandler;
+    /** Register an attempt. A one-shot capability: refused hosts are rejected up front. */
+    open<T>(spec: LoginProxyAttemptSpec<T>): void;
+    close(attemptId: string): void;
+    isOpen(attemptId: string): boolean;
+    /**
+     * The hub-relative path that opens `vendorUrl` through the proxy for this attempt:
+     * the URL the browser is sent to. Null when the host is not in the attempt's list.
+     */
+    entryPath(attemptId: string, vendorUrl: string): string | null;
+}

package/dist/vendor-login-proxy/prefix.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The data-plane prefix every `VendorLoginProxy` is served under
+ * (`/addon/<addonId>/vendor-login/<attemptId>/<vendorHost>/…`).
+ *
+ * The hub consults an addon's data-plane prefixes BEFORE its HTTP routes, so a
+ * prefix equal to the first segment of a route the addon serves swallows that
+ * route. A sign-in addon serves `/login/start|status|commit|cancel`; the proxy
+ * therefore lives on a segment no addon route uses. One constant, so the entry
+ * path, the mount and the docs cannot drift apart.
+ */
+export declare const VENDOR_LOGIN_PROXY_PREFIX = "vendor-login";

package/dist/vendor-login-proxy/url-rewrite.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Pure rewriting for the vendor login proxy (D955).
+ *
+ * The browser talks to the hub under `<basePath>/<vendorHost>/<path>`; the vendor
+ * is reached on its real host. Everything here maps ONE way or the other and
+ * never touches the network, so the rules are testable without a socket.
+ *
+ * What is rewritten, and what is deliberately left alone:
+ *  - a vendor URL that STARTS a value (an attribute, a JSON string, a header)
+ *    becomes a proxy path;
+ *  - a vendor URL that is the VALUE of a query parameter (`?return_to=https://…`,
+ *    or its percent-encoded form) is left alone: the vendor reads it back as the
+ *    place to return to, and a proxy path there breaks its own redirect check.
+ */
+export type LoginProxyScheme = 'https' | 'http';
+export interface LoginProxyUpstream {
+    /** `host` or `host:port`, lower-case. The only hosts the proxy will ever dial. */
+    readonly host: string;
+    /** `http` is accepted for a loopback host only (a local helper, a test vendor). */
+    readonly scheme: LoginProxyScheme;
+}
+/** One attempt's view of the proxy: where it is mounted and which hosts it may reach. */
+export interface LoginProxyRoute {
+    /** `<forwarded prefix>/addon/<addonId>/<prefix>/<attemptId>` — no trailing slash. */
+    readonly basePath: string;
+    readonly upstreams: readonly LoginProxyUpstream[];
+}
+export interface ParsedProxyPath {
+    readonly attemptId: string;
+    readonly host: string;
+    /** Path after the host, always starting with `/`. */
+    readonly pathname: string;
+    /** `?…` or the empty string. */
+    readonly search: string;
+}
+export declare function hostWithoutPort(host: string): string;
+export declare function isLoopbackHost(host: string): boolean;
+/** An allow-list entry is valid when it is a bare host[:port] and `http` only targets loopback. */
+export declare function isValidUpstream(upstream: LoginProxyUpstream): boolean;
+export declare function findUpstream(route: LoginProxyRoute, host: string): LoginProxyUpstream | undefined;
+/** `<basePath>/<host><pathname><search>` — what the browser is sent to. */
+export declare function proxyPathFor(route: LoginProxyRoute, host: string, pathname: string, search?: string): string;
+/** Split `/<attemptId>/<host>/<rest…>[?query]` (the data-plane view of a request). */
+export declare function parseProxyPath(rawUrl: string): ParsedProxyPath | null;
+/** The vendor URL a proxied request targets, or null when the host would not stay `host`. */
+export declare function upstreamUrlFor(upstream: LoginProxyUpstream, parsed: ParsedProxyPath): URL | null;
+/** A Location (or any URL value) to a vendor host becomes a proxy path; anything else is unchanged. */
+export declare function rewriteLocation(location: string, currentUpstream: LoginProxyUpstream, route: LoginProxyRoute): string;
+export type BodyKind = 'html' | 'css' | 'other';
+/**
+ * Rewrite vendor URLs in a text body: absolute (`https://host/…`), protocol-relative
+ * (`//host/…`) and JSON-escaped (`https:\/\/host\/…`) when they start a value; and, in
+ * HTML/CSS, root-relative references (`href="/x"`, `url(/x)`) which would otherwise
+ * escape the proxy mount and land on the hub.
+ */
+export declare function rewriteBody(body: string, kind: BodyKind, currentUpstream: LoginProxyUpstream, route: LoginProxyRoute): string;
+/**
+ * A vendor `Set-Cookie` for the browser: no `Domain` (the cookie belongs to the hub
+ * origin), `Path` narrowed to this attempt's prefix, `Secure` kept (the hub is HTTPS).
+ */
+export declare function rewriteSetCookie(cookie: string, route: LoginProxyRoute): string;
+/**
+ * A browser `Referer` that points into this proxy, turned back into the vendor URL it
+ * stands for. A Referer that is not ours is dropped (null): it names the hub.
+ */
+export declare function rewriteReferer(referer: string, route: LoginProxyRoute): string | null;
+/** Cookies the browser holds for the hub itself must never reach a vendor. */
+export declare function filterForwardedCookies(cookieHeader: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.430",
+  "version": "1.2.432",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",