@nuxtseo/sdk 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,99 @@
+import type { OperationInput, OperationOutput, PublicV1ErrorCode, PublicV1OperationDefinition, PublicV1ProtocolLike } from '@nuxtseo/protocol/v1/core';
+import type { PublicApiTransport, TransportFailure } from './transport.js';
+export interface RateLimitMetadata {
+    policy: string;
+    limit?: number;
+    windowSeconds?: number;
+    remaining?: number;
+    resetAfterSeconds?: number;
+}
+export interface RetryMetadata {
+    afterMilliseconds: number;
+}
+export interface LifecycleMetadata {
+    deprecatedAt?: string;
+    sunsetAt?: string;
+}
+export interface PublicResponseMetadata {
+    requestId?: string;
+    version?: string;
+    operationId?: string;
+    rateLimit?: RateLimitMetadata;
+    retry?: RetryMetadata;
+    lifecycle?: LifecycleMetadata;
+}
+export type PublicSdkResult<TValue, TError> = {
+    _tag: 'Ok';
+    value: TValue;
+    metadata?: PublicResponseMetadata;
+} | {
+    _tag: 'Err';
+    error: TError;
+};
+export interface RequestFailure {
+    _tag: 'RequestFailure';
+    operationId: string;
+    location: 'body' | 'headers' | 'input' | 'params' | 'query';
+    issues: readonly unknown[];
+}
+export interface ApiFailure {
+    _tag: 'ApiFailure';
+    operationId: string;
+    code: PublicV1ErrorCode;
+    message: string;
+    status: number;
+    requestId: string;
+    retryable: boolean;
+    details: Readonly<Record<string, unknown>>;
+    response: PublicApiErrorResponse;
+    metadata: PublicResponseMetadata;
+}
+export interface PublicApiErrorResponse {
+    error: {
+        code: PublicV1ErrorCode;
+        message: string;
+        requestId: string;
+        retryable: boolean;
+        details: Readonly<Record<string, unknown>>;
+    };
+}
+export interface ContractFailure {
+    _tag: 'ContractFailure';
+    operationId: string;
+    status: number;
+    requestId?: string;
+    message: string;
+    issues: readonly unknown[];
+    metadata: PublicResponseMetadata;
+}
+export type SdkFailure = RequestFailure | ApiFailure | ContractFailure | TransportFailure;
+export interface ExecuteOptions {
+    requestId?: string;
+    signal?: AbortSignal;
+}
+export type OperationExecuteOptions<TOperation extends PublicV1OperationDefinition> = ExecuteOptions & (TOperation['policy']['idempotency'] extends {
+    _tag: 'required';
+} ? {
+    idempotencyKey: string;
+} : {
+    idempotencyKey?: never;
+});
+export interface RetryOptions {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+}
+export interface CreateSdkClientOptions<TProtocol extends PublicV1ProtocolLike> {
+    protocol: TProtocol;
+    transport: PublicApiTransport;
+    retry?: RetryOptions;
+}
+export interface SdkClient {
+    execute: <const TOperation extends PublicV1OperationDefinition>(operation: TOperation, input: OperationInput<TOperation>, options?: OperationExecuteOptions<TOperation>) => Promise<PublicSdkResult<OperationOutput<TOperation>, SdkFailure>>;
+}
+export type DomainClient<TOperations extends Readonly<Record<string, PublicV1OperationDefinition>>> = {
+    [TKey in keyof TOperations]: (input: OperationInput<TOperations[TKey]>, options?: OperationExecuteOptions<TOperations[TKey]>) => Promise<PublicSdkResult<OperationOutput<TOperations[TKey]>, SdkFailure>>;
+};
+export declare function createSdkClient<const TProtocol extends PublicV1ProtocolLike>(options: CreateSdkClientOptions<TProtocol>): SdkClient;
+export declare function createDomainClient<const TOperations extends Readonly<Record<string, PublicV1OperationDefinition>>>(client: SdkClient, operations: TOperations): DomainClient<TOperations>;

package/dist/client.js

@@ -0,0 +1,308 @@
+import { buildOperationPath, listOperations, PUBLIC_V1_ERROR_STATUS, PUBLIC_V1_RESPONSE_HEADERS } from '@nuxtseo/protocol/v1/core';
+function ok(value) {
+    return { _tag: 'Ok', value };
+}
+function err(error) {
+    return { _tag: 'Err', error };
+}
+function defaultSleep(milliseconds, signal) {
+    if (signal?.aborted)
+        return Promise.reject(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+    return new Promise((resolve, reject) => {
+        const handle = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, milliseconds);
+        function onAbort() {
+            clearTimeout(handle);
+            reject(signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function resolveRetryOptions(options) {
+    const maxAttempts = options?.maxAttempts ?? 3;
+    const baseDelayMs = options?.baseDelayMs ?? 100;
+    const maxDelayMs = options?.maxDelayMs ?? 2_000;
+    if (!Number.isInteger(maxAttempts) || maxAttempts < 1)
+        throw new TypeError('retry.maxAttempts must be a positive integer.');
+    if (baseDelayMs < 0 || maxDelayMs < baseDelayMs)
+        throw new TypeError('retry delays must be nonnegative and maxDelayMs must be at least baseDelayMs.');
+    return { maxAttempts, baseDelayMs, maxDelayMs, sleep: options?.sleep ?? defaultSleep };
+}
+function requestFailure(operation, location, issues) {
+    return err({ _tag: 'RequestFailure', operationId: operation.id, location, issues });
+}
+function parseLocation(operation, location, input) {
+    const schema = operation.request[location];
+    const supplied = Object.hasOwn(input, location) && input[location] !== undefined;
+    if (schema === null) {
+        return supplied
+            ? requestFailure(operation, location, [`${location} is not accepted by this operation.`])
+            : ok(undefined);
+    }
+    const value = supplied ? input[location] : location === 'body' ? undefined : {};
+    const parsed = schema.safeParse(value);
+    return parsed.success
+        ? ok(parsed.data)
+        : requestFailure(operation, location, parsed.error.issues);
+}
+function prepareRequest(operation, input) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input))
+        return requestFailure(operation, 'input', ['input must be an object.']);
+    const source = input;
+    const accepted = new Set(['params', 'query', 'headers', 'body']);
+    const extra = Object.keys(source).filter(key => !accepted.has(key));
+    if (extra.length > 0)
+        return requestFailure(operation, 'input', [`Unknown input keys: ${extra.join(', ')}`]);
+    const params = parseLocation(operation, 'params', source);
+    if (params._tag === 'Err')
+        return params;
+    const query = parseLocation(operation, 'query', source);
+    if (query._tag === 'Err')
+        return query;
+    const headers = parseLocation(operation, 'headers', source);
+    if (headers._tag === 'Err')
+        return headers;
+    const body = parseLocation(operation, 'body', source);
+    if (body._tag === 'Err')
+        return body;
+    return ok({
+        path: buildOperationPath(operation, params.value),
+        query: (query.value ?? {}),
+        headers: new Headers((headers.value ?? {})),
+        body: body.value,
+    });
+}
+function appendQuery(path, query) {
+    const search = new URLSearchParams();
+    for (const key of Object.keys(query).sort()) {
+        const value = query[key];
+        const values = Array.isArray(value) ? value : [value];
+        for (const item of values) {
+            if (item === undefined)
+                continue;
+            if (item === null) {
+                search.append(key, '');
+                continue;
+            }
+            if (typeof item === 'object') {
+                search.append(key, JSON.stringify(item));
+                continue;
+            }
+            search.append(key, String(item));
+        }
+    }
+    const serialized = search.toString();
+    return serialized ? `${path}?${serialized}` : path;
+}
+function makeTransportRequest(operation, prepared, options) {
+    const headers = new Headers(prepared.headers);
+    headers.set('accept', 'application/json');
+    if (options.requestId)
+        headers.set('x-request-id', options.requestId);
+    if (options.idempotencyKey)
+        headers.set('idempotency-key', options.idempotencyKey);
+    const body = prepared.body === undefined ? undefined : JSON.stringify(prepared.body);
+    if (body !== undefined)
+        headers.set('content-type', 'application/json');
+    return {
+        operationId: operation.id,
+        method: operation.method,
+        path: appendQuery(prepared.path, prepared.query),
+        headers,
+        body,
+        signal: options.signal,
+    };
+}
+function parseRetryAfter(value) {
+    if (value === null)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.ceil(seconds * 1_000);
+    const date = Date.parse(value);
+    return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
+}
+function integerParameter(value, name) {
+    const match = value.match(new RegExp(`(?:^|;)${name}=(\\d+)(?:;|$)`));
+    if (!match)
+        return undefined;
+    const parsed = Number(match[1]);
+    return Number.isSafeInteger(parsed) ? parsed : undefined;
+}
+function parseRateLimitMetadata(headers) {
+    const policyValue = headers.get(PUBLIC_V1_RESPONSE_HEADERS.rateLimitPolicy);
+    const rateValue = headers.get(PUBLIC_V1_RESPONSE_HEADERS.rateLimit);
+    const value = rateValue ?? policyValue;
+    if (!value)
+        return undefined;
+    const policy = value.match(/^"([^"]+)"/)?.[1];
+    if (!policy)
+        return undefined;
+    return {
+        policy,
+        ...(policyValue && integerParameter(policyValue, 'q') !== undefined ? { limit: integerParameter(policyValue, 'q') } : {}),
+        ...(policyValue && integerParameter(policyValue, 'w') !== undefined ? { windowSeconds: integerParameter(policyValue, 'w') } : {}),
+        ...(rateValue && integerParameter(rateValue, 'r') !== undefined ? { remaining: integerParameter(rateValue, 'r') } : {}),
+        ...(rateValue && integerParameter(rateValue, 't') !== undefined ? { resetAfterSeconds: integerParameter(rateValue, 't') } : {}),
+    };
+}
+function parseDeprecation(value) {
+    const match = value?.match(/^@(\d+)$/);
+    if (!match)
+        return undefined;
+    const milliseconds = Number(match[1]) * 1_000;
+    return Number.isSafeInteger(milliseconds) ? new Date(milliseconds).toISOString() : undefined;
+}
+function responseMetadata(response) {
+    const retryAfter = parseRetryAfter(response.headers.get(PUBLIC_V1_RESPONSE_HEADERS.retryAfter));
+    const deprecatedAt = parseDeprecation(response.headers.get(PUBLIC_V1_RESPONSE_HEADERS.deprecation));
+    const sunset = response.headers.get(PUBLIC_V1_RESPONSE_HEADERS.sunset);
+    const sunsetAt = sunset && !Number.isNaN(Date.parse(sunset)) ? new Date(sunset).toISOString() : undefined;
+    const lifecycle = deprecatedAt || sunsetAt ? { deprecatedAt, sunsetAt } : undefined;
+    return {
+        requestId: response.headers.get(PUBLIC_V1_RESPONSE_HEADERS.requestId) ?? undefined,
+        version: response.headers.get(PUBLIC_V1_RESPONSE_HEADERS.version) ?? undefined,
+        operationId: response.headers.get(PUBLIC_V1_RESPONSE_HEADERS.operation) ?? undefined,
+        rateLimit: parseRateLimitMetadata(response.headers),
+        retry: retryAfter === undefined ? undefined : { afterMilliseconds: retryAfter },
+        lifecycle,
+    };
+}
+function retryDelay(attempt, retryAfter, options) {
+    const exponential = Math.min(options.maxDelayMs, options.baseDelayMs * 2 ** Math.max(0, attempt - 1));
+    return Math.max(exponential, parseRetryAfter(retryAfter) ?? 0);
+}
+function waitForRetry(milliseconds, signal, options) {
+    return options.sleep(milliseconds, signal)
+        .then(() => ok(undefined))
+        .catch(cause => err({
+        _tag: 'TransportFailure',
+        reason: 'aborted',
+        message: 'Request aborted while waiting to retry.',
+        retryable: false,
+        cause,
+    }));
+}
+function readJson(response) {
+    return response.text()
+        .then((text) => {
+        if (!text)
+            return ok(null);
+        return Promise.resolve()
+            .then(() => ok(JSON.parse(text)))
+            .catch(cause => err([cause]));
+    });
+}
+function contractFailure(operation, response, message, issues) {
+    return err({
+        _tag: 'ContractFailure',
+        operationId: operation.id,
+        status: response.status,
+        requestId: response.headers.get('x-request-id') ?? undefined,
+        message,
+        issues,
+        metadata: responseMetadata(response),
+    });
+}
+function responseContract(operation, status) {
+    return operation.responses[status];
+}
+export function createSdkClient(options) {
+    const retry = resolveRetryOptions(options.retry);
+    const registered = new Map();
+    for (const { operation } of listOperations(options.protocol)) {
+        const descriptor = operation;
+        registered.set(descriptor.id, descriptor);
+    }
+    async function execute(operation, input, executeOptions) {
+        const known = registered.get(operation.id);
+        if (!known || known.method !== operation.method || known.path !== operation.path) {
+            return requestFailure(operation, 'input', [`${operation.id} is not registered in this client protocol.`]);
+        }
+        const resolvedExecuteOptions = (executeOptions ?? {});
+        if (operation.policy.idempotency._tag === 'required' && !resolvedExecuteOptions.idempotencyKey) {
+            return requestFailure(operation, 'headers', ['Idempotency-Key is required by this operation.']);
+        }
+        if (operation.policy.idempotency._tag === 'none' && resolvedExecuteOptions.idempotencyKey) {
+            return requestFailure(operation, 'headers', ['Idempotency-Key is not accepted by this operation.']);
+        }
+        const prepared = prepareRequest(operation, input);
+        if (prepared._tag === 'Err')
+            return prepared;
+        const request = makeTransportRequest(operation, prepared.value, resolvedExecuteOptions);
+        const canRetry = operation.semantics.retry === 'idempotent';
+        for (let attempt = 1; attempt <= retry.maxAttempts; attempt++) {
+            if (resolvedExecuteOptions.signal?.aborted) {
+                return err({
+                    _tag: 'TransportFailure',
+                    reason: 'aborted',
+                    message: `${operation.id}: request aborted.`,
+                    retryable: false,
+                    cause: resolvedExecuteOptions.signal.reason,
+                });
+            }
+            const transported = await options.transport.send(request);
+            if (transported._tag === 'Err') {
+                if (canRetry && transported.error.retryable && attempt < retry.maxAttempts) {
+                    const waited = await waitForRetry(retryDelay(attempt, null, retry), resolvedExecuteOptions.signal, retry);
+                    if (waited._tag === 'Err')
+                        return waited;
+                    continue;
+                }
+                return err({ ...transported.error, retryable: canRetry && transported.error.retryable });
+            }
+            const response = transported.value;
+            const payload = await readJson(response);
+            if (payload._tag === 'Err')
+                return contractFailure(operation, response, `${operation.id}: response was not valid JSON.`, payload.error);
+            const success = responseContract(operation, response.status);
+            if (success) {
+                const parsed = success.client.safeParse(payload.value);
+                return parsed.success
+                    ? { _tag: 'Ok', value: parsed.data, metadata: responseMetadata(response) }
+                    : contractFailure(operation, response, `${operation.id}: response violated its client schema.`, parsed.error.issues);
+            }
+            if (response.ok)
+                return contractFailure(operation, response, `${operation.id}: undeclared success status ${response.status}.`, []);
+            const parsedError = operation.errorResponse.client.safeParse(payload.value);
+            if (!parsedError.success)
+                return contractFailure(operation, response, `${operation.id}: error response violated its schema.`, parsedError.error.issues);
+            const envelope = parsedError.data;
+            if (!operation.errors.includes(envelope.error.code))
+                return contractFailure(operation, response, `${operation.id}: undeclared error code ${envelope.error.code}.`, []);
+            if (PUBLIC_V1_ERROR_STATUS[envelope.error.code] !== response.status) {
+                return contractFailure(operation, response, `${operation.id}: error code ${envelope.error.code} cannot use status ${response.status}.`, []);
+            }
+            const failure = {
+                _tag: 'ApiFailure',
+                operationId: operation.id,
+                status: response.status,
+                ...envelope.error,
+                response: envelope,
+                metadata: responseMetadata(response),
+            };
+            if (canRetry && failure.retryable && attempt < retry.maxAttempts) {
+                const waited = await waitForRetry(retryDelay(attempt, response.headers.get('retry-after'), retry), resolvedExecuteOptions.signal, retry);
+                if (waited._tag === 'Err')
+                    return waited;
+                continue;
+            }
+            return err(failure);
+        }
+        return err({
+            _tag: 'TransportFailure',
+            reason: 'network',
+            message: `${operation.id}: retry budget exhausted.`,
+            retryable: false,
+        });
+    }
+    return { execute };
+}
+export function createDomainClient(client, operations) {
+    return Object.fromEntries(Object.entries(operations).map(([key, operation]) => [
+        key,
+        (input, options) => client.execute(operation, input, options),
+    ]));
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import type { DomainClient, RetryOptions, SdkClient } from './client.js';
+import type { PublicApiTransport } from './transport.js';
+import { accountV1Registry, actionsV1Registry, analyticsV1Registry, auditV1Registry, backlinksV1Registry, contentV1Registry, mentionsV1Registry, pagesV1Registry, performanceV1Registry, researchV1Registry, searchV1Registry, sitemapsV1Registry, sitesV1Registry } from '@nuxtseo/protocol/v1';
+export * from './client.js';
+export * from './pairing.js';
+export * from './transport.js';
+export interface CreatePublicV1ClientOptions {
+    transport: PublicApiTransport;
+    retry?: RetryOptions;
+}
+export interface PublicV1Client extends SdkClient {
+    account: DomainClient<typeof accountV1Registry.operations>;
+    actions: DomainClient<typeof actionsV1Registry.operations>;
+    analytics: DomainClient<typeof analyticsV1Registry.operations>;
+    audit: DomainClient<typeof auditV1Registry.operations>;
+    backlinks: DomainClient<typeof backlinksV1Registry.operations>;
+    content: DomainClient<typeof contentV1Registry.operations>;
+    mentions: DomainClient<typeof mentionsV1Registry.operations>;
+    pages: DomainClient<typeof pagesV1Registry.operations>;
+    performance: DomainClient<typeof performanceV1Registry.operations>;
+    research: DomainClient<typeof researchV1Registry.operations>;
+    search: DomainClient<typeof searchV1Registry.operations>;
+    sites: DomainClient<typeof sitesV1Registry.operations>;
+    sitemaps: DomainClient<typeof sitemapsV1Registry.operations>;
+}
+export declare function createPublicV1Client(options: CreatePublicV1ClientOptions): PublicV1Client;

package/dist/index.js

@@ -0,0 +1,28 @@
+import { accountV1Registry, actionsV1Registry, analyticsV1Registry, auditV1Registry, backlinksV1Registry, contentV1Registry, createPublicV1Protocol, mentionsV1Registry, pagesV1Registry, performanceV1Registry, researchV1Registry, searchV1Registry, sitemapsV1Registry, sitesV1Registry } from '@nuxtseo/protocol/v1';
+import { createDomainClient, createSdkClient } from './client.js';
+export * from './client.js';
+export * from './pairing.js';
+export * from './transport.js';
+export function createPublicV1Client(options) {
+    const core = createSdkClient({
+        protocol: createPublicV1Protocol(),
+        transport: options.transport,
+        retry: options.retry,
+    });
+    return {
+        execute: core.execute,
+        account: createDomainClient(core, accountV1Registry.operations),
+        actions: createDomainClient(core, actionsV1Registry.operations),
+        analytics: createDomainClient(core, analyticsV1Registry.operations),
+        audit: createDomainClient(core, auditV1Registry.operations),
+        backlinks: createDomainClient(core, backlinksV1Registry.operations),
+        content: createDomainClient(core, contentV1Registry.operations),
+        mentions: createDomainClient(core, mentionsV1Registry.operations),
+        pages: createDomainClient(core, pagesV1Registry.operations),
+        performance: createDomainClient(core, performanceV1Registry.operations),
+        research: createDomainClient(core, researchV1Registry.operations),
+        search: createDomainClient(core, searchV1Registry.operations),
+        sites: createDomainClient(core, sitesV1Registry.operations),
+        sitemaps: createDomainClient(core, sitemapsV1Registry.operations),
+    };
+}

package/dist/pairing.d.ts

@@ -0,0 +1,26 @@
+import type { CliPairingPollResponse, CliPairingStartRequest, CliPairingStartResponse } from '@nuxtseo/protocol/cli-pairing';
+import type { FetchImplementation, SdkResult } from './transport.js';
+export interface PairingClientOptions {
+    baseUrl: string;
+    fetch?: FetchImplementation;
+}
+export interface PairingFailure {
+    _tag: 'PairingFailure';
+    reason: 'aborted' | 'contract' | 'network' | 'status';
+    message: string;
+    status?: number;
+}
+export interface PairingClient {
+    start: (input: CliPairingStartRequest, options?: {
+        signal?: AbortSignal;
+    }) => Promise<SdkResult<CliPairingStartResponse, PairingFailure>>;
+    poll: (input: {
+        pairingId: string;
+        pollSecret: string;
+    }, options?: {
+        signal?: AbortSignal;
+    }) => Promise<SdkResult<CliPairingPollResponse, PairingFailure>>;
+}
+export type { CliPairingApproved, CliPairingPollResponse, CliPairingStartRequest, CliPairingStartResponse, CliPairingStatus, } from '@nuxtseo/protocol/cli-pairing';
+export { CLI_PAIRING_MAX_POLLS, CLI_PAIRING_POLL_INTERVAL_MS, CLI_PAIRING_TTL_MS, } from '@nuxtseo/protocol/cli-pairing';
+export declare function createPairingClient(options: PairingClientOptions): PairingClient;

package/dist/pairing.js

@@ -0,0 +1,52 @@
+// Browser pairing client for `nuxtseo login`.
+//
+// This deliberately sits outside `createSdkClient`. That client is driven by the
+// v1 protocol registry and assumes a bearer token on every request; pairing runs
+// before a token exists. The wire format still has one owner: the schemas come
+// from @nuxtseo/protocol/cli-pairing and the server routes validate the same
+// ones.
+import { CLI_PAIRING_POLL_PATH, CLI_PAIRING_START_PATH, cliPairingPollResponseSchema, cliPairingStartResponseSchema, } from '@nuxtseo/protocol/cli-pairing';
+function fail(reason, message, status) {
+    return { _tag: 'Err', error: { _tag: 'PairingFailure', reason, message, ...(status === undefined ? {} : { status }) } };
+}
+function resolveUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
+}
+async function request(options, path, body, parse, signal) {
+    const send = options.fetch ?? globalThis.fetch;
+    let response;
+    try {
+        response = await send(resolveUrl(options.baseUrl, path), {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+            signal,
+        });
+    }
+    catch (cause) {
+        const aborted = cause instanceof Error && (cause.name === 'AbortError' || cause.name === 'TimeoutError');
+        return fail(aborted ? 'aborted' : 'network', cause instanceof Error ? cause.message : String(cause));
+    }
+    if (!response.ok)
+        return fail('status', `Pairing request failed with status ${response.status}.`, response.status);
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch (cause) {
+        return fail('contract', `Pairing response was not JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+    try {
+        return { _tag: 'Ok', value: parse(payload) };
+    }
+    catch (cause) {
+        return fail('contract', `Pairing response did not match the contract: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
+export { CLI_PAIRING_MAX_POLLS, CLI_PAIRING_POLL_INTERVAL_MS, CLI_PAIRING_TTL_MS, } from '@nuxtseo/protocol/cli-pairing';
+export function createPairingClient(options) {
+    return {
+        start: (input, callOptions) => request(options, CLI_PAIRING_START_PATH, input, value => cliPairingStartResponseSchema.parse(value), callOptions?.signal),
+        poll: (input, callOptions) => request(options, CLI_PAIRING_POLL_PATH, input, value => cliPairingPollResponseSchema.parse(value), callOptions?.signal),
+    };
+}

package/dist/transport.d.ts

@@ -0,0 +1,42 @@
+import type { PublicV1Method } from '@nuxtseo/protocol/v1/core';
+export type SdkResult<TValue, TError> = {
+    _tag: 'Ok';
+    value: TValue;
+} | {
+    _tag: 'Err';
+    error: TError;
+};
+export interface TransportRequest {
+    operationId: string;
+    method: PublicV1Method;
+    path: string;
+    headers: Headers;
+    body?: string;
+    signal?: AbortSignal;
+}
+export interface TransportFailure {
+    _tag: 'TransportFailure';
+    reason: 'aborted' | 'credential' | 'headers' | 'network';
+    message: string;
+    retryable: boolean;
+    cause?: unknown;
+}
+export interface PublicApiTransport {
+    send: (request: TransportRequest) => Promise<SdkResult<Response, TransportFailure>>;
+}
+export type FetchImplementation = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export type HeadersResolver = HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+export type TokenResolver = string | (() => string | Promise<string>);
+export interface BrowserTransportOptions {
+    baseUrl?: string;
+    fetch?: FetchImplementation;
+    headers?: HeadersResolver;
+}
+export interface BearerTransportOptions {
+    baseUrl: string;
+    token: TokenResolver;
+    fetch?: FetchImplementation;
+    headers?: HeadersResolver;
+}
+export declare function createBrowserTransport(options?: BrowserTransportOptions): PublicApiTransport;
+export declare function createBearerTransport(options: BearerTransportOptions): PublicApiTransport;

package/dist/transport.js

@@ -0,0 +1,114 @@
+function ok(value) {
+    return { _tag: 'Ok', value };
+}
+function err(error) {
+    return { _tag: 'Err', error };
+}
+function resolveUrl(baseUrl, path) {
+    if (!baseUrl)
+        return path;
+    return `${baseUrl.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
+}
+async function resolveHeaders(resolver) {
+    if (!resolver)
+        return ok(new Headers());
+    return Promise.resolve(typeof resolver === 'function' ? resolver() : resolver)
+        .then(value => ok(new Headers(value)))
+        .catch(cause => err({
+        _tag: 'TransportFailure',
+        reason: 'headers',
+        message: 'Could not resolve request headers.',
+        retryable: false,
+        cause,
+    }));
+}
+async function resolveToken(resolver) {
+    return Promise.resolve(typeof resolver === 'function' ? resolver() : resolver)
+        .then((value) => {
+        if (typeof value !== 'string' || !value.trim()) {
+            return err({
+                _tag: 'TransportFailure',
+                reason: 'credential',
+                message: 'The NuxtSEO API token cannot be empty.',
+                retryable: false,
+            });
+        }
+        return ok(value.trim());
+    })
+        .catch(cause => err({
+        _tag: 'TransportFailure',
+        reason: 'credential',
+        message: 'Could not resolve the NuxtSEO API token.',
+        retryable: false,
+        cause,
+    }));
+}
+function mergeHeaders(base, request) {
+    const headers = new Headers(base);
+    request.forEach((value, key) => headers.set(key, value));
+    return headers;
+}
+function sendWithFetch(fetchImplementation, baseUrl, credentials, baseHeaders, request) {
+    return fetchImplementation(resolveUrl(baseUrl, request.path), {
+        method: request.method,
+        headers: mergeHeaders(baseHeaders, request.headers),
+        body: request.body,
+        signal: request.signal,
+        credentials,
+    })
+        .then(ok)
+        .catch((cause) => {
+        const aborted = request.signal?.aborted === true
+            || (typeof cause === 'object' && cause !== null && 'name' in cause && cause.name === 'AbortError');
+        return err({
+            _tag: 'TransportFailure',
+            reason: aborted ? 'aborted' : 'network',
+            message: `${request.operationId}: ${aborted ? 'request aborted' : 'network request failed'}.`,
+            retryable: !aborted,
+            cause,
+        });
+    });
+}
+export function createBrowserTransport(options = {}) {
+    const fetchImplementation = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImplementation !== 'function')
+        throw new TypeError('createBrowserTransport requires a fetch implementation in this runtime.');
+    return {
+        async send(request) {
+            const headers = await resolveHeaders(options.headers);
+            if (headers._tag === 'Err')
+                return headers;
+            headers.value.delete('authorization');
+            const requestHeaders = new Headers(request.headers);
+            requestHeaders.delete('authorization');
+            return sendWithFetch(fetchImplementation, options.baseUrl ?? '', 'include', headers.value, {
+                ...request,
+                headers: requestHeaders,
+            });
+        },
+    };
+}
+export function createBearerTransport(options) {
+    const fetchImplementation = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImplementation !== 'function')
+        throw new TypeError('createBearerTransport requires a fetch implementation in this runtime.');
+    return {
+        async send(request) {
+            const [headers, token] = await Promise.all([
+                resolveHeaders(options.headers),
+                resolveToken(options.token),
+            ]);
+            if (headers._tag === 'Err')
+                return headers;
+            if (token._tag === 'Err')
+                return token;
+            headers.value.set('authorization', `Bearer ${token.value}`);
+            const requestHeaders = new Headers(request.headers);
+            requestHeaders.delete('authorization');
+            return sendWithFetch(fetchImplementation, options.baseUrl, undefined, headers.value, {
+                ...request,
+                headers: requestHeaders,
+            });
+        },
+    };
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@nuxtseo/sdk",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Descriptor-driven client for the NuxtSEO public HTTP interface.",
+  "license": "MIT",
+  "homepage": "https://nuxtseo.com/pro/api",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harlan-zw/nuxtseo.com.git",
+    "directory": "packages/sdk"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./transport": {
+      "types": "./dist/transport.d.ts",
+      "import": "./dist/transport.js",
+      "default": "./dist/transport.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "@nuxtseo/protocol": "^0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "npm:typescript-native-bridge@6.0.3-bridge.10.tsgo.7.0.2",
+    "@nuxtseo/protocol": "0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "tsc --noEmit"
+  }
+}