@nuxtseo/cli 0.1.0

package/dist/failures.js

@@ -0,0 +1,132 @@
+export const EXIT_CODE = {
+    success: 0,
+    invalidInput: 2,
+    authentication: 3,
+    authorization: 4,
+    conflict: 5,
+    retryable: 6,
+    infrastructure: 7,
+    notFound: 8,
+    interrupted: 130,
+};
+export function ok(value) {
+    return { _tag: 'Ok', value };
+}
+function defaultFailureCode(exitCode) {
+    switch (exitCode) {
+        case EXIT_CODE.invalidInput:
+            return 'invalid_cli_input';
+        case EXIT_CODE.authentication:
+            return 'authentication_required';
+        case EXIT_CODE.authorization:
+            return 'authorization_required';
+        case EXIT_CODE.conflict:
+            return 'conflict';
+        case EXIT_CODE.retryable:
+            return 'retryable_failure';
+        case EXIT_CODE.notFound:
+            return 'not_found';
+        case EXIT_CODE.interrupted:
+            return 'interrupted';
+        default:
+            return 'infrastructure_failure';
+    }
+}
+export function fail(exitCode, message, cause, code = defaultFailureCode(exitCode)) {
+    return { _tag: 'Err', error: { _tag: 'CliFailure', code, exitCode, message, cause } };
+}
+function apiExitCode(code, retryable) {
+    switch (code) {
+        case 'invalid_request':
+            return EXIT_CODE.invalidInput;
+        case 'unauthorized':
+        case 'auth_expired':
+            return EXIT_CODE.authentication;
+        case 'forbidden':
+        case 'entitlement_required':
+            return EXIT_CODE.authorization;
+        case 'conflict':
+        case 'site_ambiguous':
+        case 'stale_evidence':
+            return EXIT_CODE.conflict;
+        case 'rate_limited':
+        case 'quota_exhausted':
+        case 'provider_unavailable':
+            return EXIT_CODE.retryable;
+        case 'not_found':
+            return EXIT_CODE.notFound;
+        case 'contract_violation':
+        case 'internal_error':
+            return EXIT_CODE.infrastructure;
+        default:
+            return retryable ? EXIT_CODE.retryable : EXIT_CODE.infrastructure;
+    }
+}
+function metadataLines(error) {
+    const metadata = error.metadata;
+    const rate = metadata.rateLimit;
+    const details = Object.keys(error.details).length > 0 ? JSON.stringify(error.details) : undefined;
+    return [
+        `Request ID: ${error.requestId}`,
+        metadata.retry ? `Retry after: ${metadata.retry.afterMilliseconds}ms` : undefined,
+        rate
+            ? `Rate: ${rate.policy}, ${rate.remaining ?? '?'} remaining, limit ${rate.limit ?? '?'}, window ${rate.windowSeconds ?? '?'}s, resets in ${rate.resetAfterSeconds ?? '?'}s`
+            : undefined,
+        details ? `Details: ${details}` : undefined,
+    ].filter((line) => line !== undefined);
+}
+export function fromSdkFailure(error) {
+    switch (error._tag) {
+        case 'RequestFailure':
+            return fail(EXIT_CODE.invalidInput, `${error.operationId}: invalid ${error.location}. ${error.issues.map(String).join('; ')}`);
+        case 'ApiFailure':
+            return {
+                _tag: 'Err',
+                error: {
+                    _tag: 'CliFailure',
+                    code: error.code,
+                    exitCode: apiExitCode(error.code, error.retryable),
+                    message: [
+                        `${error.code}: ${error.message}`,
+                        ...metadataLines(error),
+                        error.code === 'unauthorized' || error.code === 'auth_expired'
+                            ? 'Replace NUXTSEO_TOKEN, or run `nuxtseo login` when using a stored credential.'
+                            : undefined,
+                    ].filter((line) => line !== undefined).join('\n'),
+                    protocolResponse: error.response,
+                },
+            };
+        case 'ContractFailure':
+            return fail(EXIT_CODE.infrastructure, [`contract_violation: ${error.message}`, error.requestId ? `Request ID: ${error.requestId}` : undefined]
+                .filter((line) => line !== undefined)
+                .join('\n'), undefined, 'contract_violation');
+        case 'TransportFailure': {
+            const timedOut = error.reason === 'aborted'
+                && error.cause instanceof DOMException
+                && error.cause.name === 'TimeoutError';
+            return fail(timedOut
+                ? EXIT_CODE.retryable
+                : error.reason === 'credential'
+                    ? EXIT_CODE.authentication
+                    : error.reason === 'aborted'
+                        ? EXIT_CODE.interrupted
+                        : EXIT_CODE.infrastructure, timedOut ? `request_timeout: ${error.message}` : `${error.reason}: ${error.message}`, error.cause, timedOut
+                ? 'request_timeout'
+                : error.reason === 'credential'
+                    ? 'authentication_required'
+                    : error.reason === 'aborted'
+                        ? 'interrupted'
+                        : 'transport_failure');
+        }
+    }
+}
+export function unexpectedFailure(cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    return {
+        _tag: 'CliFailure',
+        code: 'unexpected',
+        exitCode: EXIT_CODE.infrastructure,
+        message: `unexpected: ${message}`,
+        cause,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { runCli } from './cli.js';
+export { EXIT_CODE } from './failures.js';
+export type { CliFailure, CliFailureCode, CliResult, ExitCode, LocalFailureCode } from './failures.js';
+export type { CliRuntime } from './runtime.js';
+export { VERSION } from './version.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { runCli } from './cli.js';
+export { EXIT_CODE } from './failures.js';
+export { VERSION } from './version.js';

package/dist/pairing.d.ts

@@ -0,0 +1,13 @@
+import type { CliPairingApproved, CliPairingStartResponse, PairingClient } from '@nuxtseo/sdk';
+import type { CliResult } from './failures.js';
+import type { CliRuntime } from './runtime.js';
+export declare const CLIENT_NAME = "nuxtseo-cli";
+export declare function createCliPairingClient(apiUrl: string): PairingClient;
+export declare function startPairing(client: PairingClient, runtime: CliRuntime): Promise<CliResult<CliPairingStartResponse>>;
+/**
+ * Poll until the user decides, the pairing expires, or the user interrupts.
+ *
+ * The loop owns the pairing deadline (ten minutes, from the server), so a login
+ * is never cut short by the per-request `--timeout-ms`.
+ */
+export declare function awaitPairingApproval(client: PairingClient, runtime: CliRuntime, pairing: CliPairingStartResponse): Promise<CliResult<CliPairingApproved>>;

package/dist/pairing.js

@@ -0,0 +1,100 @@
+import { hostname } from 'node:os';
+import { CLI_PAIRING_POLL_INTERVAL_MS, createPairingClient } from '@nuxtseo/sdk';
+import { EXIT_CODE, fail, ok } from './failures.js';
+import { VERSION } from './version.js';
+/**
+ * Per-poll request deadline.
+ *
+ * `runtime.requestSignal` is NOT usable here: it is built once at startup as
+ * `AbortSignal.any([runtime.signal, AbortSignal.timeout(globals.timeoutMs)])`,
+ * so a poll loop bound to it would die after the default 30s. Each poll gets a
+ * short deadline of its own, and the pairing deadline is tracked in the loop.
+ */
+const POLL_REQUEST_TIMEOUT_MS = 8_000;
+export const CLIENT_NAME = 'nuxtseo-cli';
+export function createCliPairingClient(apiUrl) {
+    return createPairingClient({ baseUrl: apiUrl });
+}
+function describeFailure(error) {
+    if (error.reason === 'aborted')
+        return fail(EXIT_CODE.interrupted, 'interrupted: Login cancelled.');
+    if (error.reason === 'contract')
+        return fail(EXIT_CODE.infrastructure, `contract_violation: ${error.message}`, undefined, 'contract_violation');
+    if (error.reason === 'status' && error.status === 429)
+        return fail(EXIT_CODE.retryable, `rate_limited: ${error.message}`, undefined, 'retryable_failure');
+    return fail(EXIT_CODE.infrastructure, `transport_failure: ${error.message}`, undefined, 'transport_failure');
+}
+export async function startPairing(client, runtime) {
+    const started = await client.start({
+        clientName: CLIENT_NAME,
+        clientVersion: VERSION,
+        hostname: safeHostname(),
+    }, { signal: runtime.requestSignal });
+    return started._tag === 'Err' ? describeFailure(started.error) : ok(started.value);
+}
+function safeHostname() {
+    try {
+        const name = hostname().trim();
+        return name ? name.slice(0, 120) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sleep(milliseconds, signal) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(finish, milliseconds);
+        signal.addEventListener('abort', finish, { once: true });
+        function finish() {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', finish);
+            resolve();
+        }
+    });
+}
+/**
+ * Poll until the user decides, the pairing expires, or the user interrupts.
+ *
+ * The loop owns the pairing deadline (ten minutes, from the server), so a login
+ * is never cut short by the per-request `--timeout-ms`.
+ */
+export async function awaitPairingApproval(client, runtime, pairing) {
+    const deadline = Date.parse(pairing.expiresAt);
+    let waitMs = pairing.pollIntervalMs || CLI_PAIRING_POLL_INTERVAL_MS;
+    while (!runtime.signal.aborted && Date.now() < deadline) {
+        await sleep(waitMs, runtime.signal);
+        if (runtime.signal.aborted)
+            break;
+        const polled = await client.poll({ pairingId: pairing.pairingId, pollSecret: pairing.pollSecret }, { signal: AbortSignal.any([runtime.signal, AbortSignal.timeout(POLL_REQUEST_TIMEOUT_MS)]) });
+        if (polled._tag === 'Err') {
+            // A single slow or dropped poll is not a failed login. Keep waiting until
+            // the pairing deadline, and only surface a failure that cannot resolve.
+            if (polled.error.reason === 'network' || polled.error.reason === 'aborted') {
+                if (runtime.signal.aborted)
+                    break;
+                continue;
+            }
+            return describeFailure(polled.error);
+        }
+        const result = polled.value;
+        switch (result.status) {
+            case 'approved':
+                return ok(result);
+            case 'denied':
+                return fail(EXIT_CODE.authentication, 'authentication_required: The pairing request was denied in the browser.');
+            case 'claimed':
+                return fail(EXIT_CODE.conflict, 'conflict: This pairing request was already used. Run `nuxtseo login` again.');
+            case 'expired':
+                return fail(EXIT_CODE.retryable, 'request_timeout: The pairing request expired. Run `nuxtseo login` again.', undefined, 'request_timeout');
+            case 'slow_down':
+                waitMs = result.retryAfterMs;
+                continue;
+            case 'pending':
+                waitMs = pairing.pollIntervalMs || CLI_PAIRING_POLL_INTERVAL_MS;
+                continue;
+        }
+    }
+    if (runtime.signal.aborted)
+        return fail(EXIT_CODE.interrupted, 'interrupted: Login cancelled.');
+    return fail(EXIT_CODE.retryable, 'request_timeout: The pairing request expired before it was approved.', undefined, 'request_timeout');
+}

package/dist/parse.d.ts

@@ -0,0 +1,23 @@
+import type { CliResult } from './failures.js';
+export interface GlobalOptions {
+    apiUrl?: string;
+    siteId?: string;
+    json: boolean;
+    noInput: boolean;
+    timeoutMs: number;
+    yes: boolean;
+}
+export interface ParsedGlobalOptions {
+    args: string[];
+    options: GlobalOptions;
+}
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+export declare function extractGlobalOptions(rawArgs: readonly string[]): CliResult<ParsedGlobalOptions>;
+export declare function parseHttpUrl(input: string, label: string): CliResult<string>;
+export declare function parseAbsolutePageUrl(input: string): CliResult<string>;
+export declare function parseInteger(input: string | undefined, options: {
+    name: string;
+    minimum: number;
+    maximum?: number;
+    defaultValue: number;
+}): CliResult<number>;

package/dist/parse.js

@@ -0,0 +1,126 @@
+import { EXIT_CODE, fail, ok } from './failures.js';
+export const DEFAULT_TIMEOUT_MS = 30_000;
+function optionValue(args, index, name) {
+    const argument = args[index];
+    const inline = argument.startsWith(`${name}=`) ? argument.slice(name.length + 1) : undefined;
+    const value = inline ?? args[index + 1];
+    if (!value || value.startsWith('-'))
+        return fail(EXIT_CODE.invalidInput, `${name} requires a value.`);
+    return ok({ consumed: inline === undefined ? 2 : 1, value });
+}
+export function extractGlobalOptions(rawArgs) {
+    const options = {
+        json: false,
+        noInput: false,
+        timeoutMs: DEFAULT_TIMEOUT_MS,
+        yes: false,
+    };
+    const args = [];
+    const seen = new Set();
+    for (let index = 0; index < rawArgs.length;) {
+        const argument = rawArgs[index];
+        if (argument === '--json') {
+            options.json = true;
+            index++;
+            continue;
+        }
+        if (argument.startsWith('--json='))
+            return fail(EXIT_CODE.invalidInput, '--json does not accept a value.');
+        if (argument === '--no-input') {
+            options.noInput = true;
+            index++;
+            continue;
+        }
+        if (argument.startsWith('--no-input='))
+            return fail(EXIT_CODE.invalidInput, '--no-input does not accept a value.');
+        if (argument === '--yes' || argument === '-y') {
+            options.yes = true;
+            index++;
+            continue;
+        }
+        if (argument.startsWith('--yes=') || argument.startsWith('-y='))
+            return fail(EXIT_CODE.invalidInput, '--yes does not accept a value.');
+        if (argument === '--api-url' || argument.startsWith('--api-url=')) {
+            if (seen.has('apiUrl'))
+                return fail(EXIT_CODE.invalidInput, '--api-url may be provided once.');
+            const parsed = optionValue(rawArgs, index, '--api-url');
+            if (parsed._tag === 'Err')
+                return parsed;
+            const url = parseHttpUrl(parsed.value.value, 'API URL');
+            if (url._tag === 'Err')
+                return url;
+            options.apiUrl = url.value;
+            seen.add('apiUrl');
+            index += parsed.value.consumed;
+            continue;
+        }
+        if (argument === '--site' || argument.startsWith('--site=')) {
+            if (seen.has('siteId'))
+                return fail(EXIT_CODE.invalidInput, '--site may be provided once.');
+            const parsed = optionValue(rawArgs, index, '--site');
+            if (parsed._tag === 'Err')
+                return parsed;
+            const siteId = parsed.value.value.trim();
+            if (!siteId)
+                return fail(EXIT_CODE.invalidInput, '--site cannot be empty.');
+            options.siteId = siteId;
+            seen.add('siteId');
+            index += parsed.value.consumed;
+            continue;
+        }
+        if (argument === '--timeout-ms' || argument.startsWith('--timeout-ms=')) {
+            if (seen.has('timeoutMs'))
+                return fail(EXIT_CODE.invalidInput, '--timeout-ms may be provided once.');
+            const value = optionValue(rawArgs, index, '--timeout-ms');
+            if (value._tag === 'Err')
+                return value;
+            const timeout = parseInteger(value.value.value, {
+                name: '--timeout-ms',
+                minimum: 1,
+                maximum: 300_000,
+                defaultValue: DEFAULT_TIMEOUT_MS,
+            });
+            if (timeout._tag === 'Err')
+                return timeout;
+            options.timeoutMs = timeout.value;
+            seen.add('timeoutMs');
+            index += value.value.consumed;
+            continue;
+        }
+        args.push(argument);
+        index++;
+    }
+    return ok({ args, options });
+}
+export function parseHttpUrl(input, label) {
+    const trimmed = input.trim();
+    if (!URL.canParse(trimmed))
+        return fail(EXIT_CODE.invalidInput, `${label} must be an absolute URL.`);
+    const url = new URL(trimmed);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        return fail(EXIT_CODE.invalidInput, `${label} must use http or https.`);
+    if (url.username || url.password)
+        return fail(EXIT_CODE.invalidInput, `${label} must not contain credentials.`);
+    return ok(url.href);
+}
+export function parseAbsolutePageUrl(input) {
+    const parsed = parseHttpUrl(input, 'Page URL');
+    if (parsed._tag === 'Err')
+        return parsed;
+    const url = new URL(parsed.value);
+    if (url.hash)
+        url.hash = '';
+    return ok(url.href);
+}
+export function parseInteger(input, options) {
+    if (input === undefined)
+        return ok(options.defaultValue);
+    if (!/^\d+$/.test(input))
+        return fail(EXIT_CODE.invalidInput, `${options.name} must be an integer.`);
+    const parsed = Number(input);
+    if (!Number.isSafeInteger(parsed) || parsed < options.minimum || (options.maximum !== undefined && parsed > options.maximum)) {
+        const range = options.maximum === undefined ? `at least ${options.minimum}` : `between ${options.minimum} and ${options.maximum}`;
+        return fail(EXIT_CODE.invalidInput, `${options.name} must be ${range}.`);
+    }
+    return ok(parsed);
+}

package/dist/render.d.ts

@@ -0,0 +1,17 @@
+import type { AccountUsageResponse, SitesListResponse } from '@nuxtseo/protocol/v1';
+import type { ActionList, ActionResolve, ActionShow } from '@nuxtseo/protocol/v1/actions';
+import type { Mentions, RecoverableBacklinks } from '@nuxtseo/protocol/v1/backlinks';
+import type { SearchStatusData } from '@nuxtseo/protocol/v1/gsc';
+import type { PageInspect, PageScan } from '@nuxtseo/protocol/v1/pages';
+import type { SitePerformanceOverview } from '@nuxtseo/protocol/v1/performance';
+export declare function renderSites(response: SitesListResponse, selectedSiteId?: string): string;
+export declare function renderUsage(response: AccountUsageResponse): string;
+export declare function renderActions(data: ActionList): string;
+export declare function renderAction(data: ActionShow): string;
+export declare function renderActionResolution(data: ActionResolve): string;
+export declare function renderPageInspection(data: PageInspect): string;
+export declare function renderPageScan(data: PageScan): string;
+export declare function renderPerformance(data: SitePerformanceOverview): string;
+export declare function renderSearchStatus(data: SearchStatusData): string;
+export declare function renderRecoverableBacklinks(data: RecoverableBacklinks): string;
+export declare function renderMentions(data: Mentions): string;

package/dist/render.js

@@ -0,0 +1,156 @@
+function value(value) {
+    if (value === null || value === undefined || value === '')
+        return 'none';
+    if (typeof value === 'boolean')
+        return value ? 'yes' : 'no';
+    return String(value);
+}
+function fields(rows) {
+    const width = Math.max(...rows.map(([label]) => label.length));
+    return rows.map(([label, rowValue]) => `${label.padEnd(width)}  ${value(rowValue)}`).join('\n');
+}
+function siteLabel(site) {
+    return site.name ?? site.url ?? site.id;
+}
+export function renderSites(response, selectedSiteId) {
+    if (response.data.sites.length === 0)
+        return 'No Sites are accessible to this token.';
+    return [
+        `Sites (${response.data.sites.length})`,
+        ...response.data.sites.map((site) => {
+            const selected = site.id === selectedSiteId ? '*' : ' ';
+            const state = `${site.searchConsole.status}, ${site.monitoring.status}`;
+            return `${selected} ${siteLabel(site)}\n  ${site.id}\n  ${site.url ?? 'URL unavailable'}\n  ${state}`;
+        }),
+    ].join('\n');
+}
+export function renderUsage(response) {
+    const meters = response.data.meters.length === 0
+        ? ['No usage meters.']
+        : response.data.meters.map((meter) => {
+            const allowance = meter.limit === null ? `${meter.used} ${meter.unit}` : `${meter.used}/${meter.limit} ${meter.unit}`;
+            const state = meter.blocked ? 'blocked' : meter.overCap ? 'over cap' : 'available';
+            return `${meter.label}: ${allowance}, ${state}${meter.resetsAt ? `, resets ${meter.resetsAt}` : ''}`;
+        });
+    return [`Plan: ${response.data.plan}`, ...meters].join('\n');
+}
+export function renderActions(data) {
+    if (data.actions.length === 0)
+        return 'No next actions.';
+    return [
+        `Next actions (${data.page.total})`,
+        ...data.actions.map(action => [
+            `${action.id}  ${action.diagnosis}`,
+            `  ${action.status}, effort ${action.effort}, ${action.affectedPages ?? 'unknown'} affected pages`,
+        ].join('\n')),
+        data.page.hasMore ? `More actions available after offset ${data.page.offset + data.page.limit}.` : '',
+    ].filter(Boolean).join('\n');
+}
+export function renderAction(data) {
+    return [
+        fields([
+            ['Action', data.id],
+            ['Status', data.status],
+            ['Diagnosis', data.diagnosis],
+            ['Do', data.action],
+            ['Finding', data.findingType],
+            ['As of', data.asOf],
+        ]),
+        `Evidence groups: ${data.evidenceGroups.length}`,
+    ].join('\n');
+}
+export function renderActionResolution(data) {
+    return fields([
+        ['Action', data.actionId],
+        ['Status', data.status],
+        ['Verification', data.verification],
+    ]);
+}
+export function renderPageInspection(data) {
+    const observations = data.observations.rows.map(row => `${row.severity}  ${row.issueType}  ${row.pathWithQuery}`);
+    const lighthouse = data.performance.lighthouse
+        ? fields([
+            ['Performance', data.performance.lighthouse.performance],
+            ['Accessibility', data.performance.lighthouse.accessibility],
+            ['Best practices', data.performance.lighthouse.bestPractices],
+            ['SEO', data.performance.lighthouse.seo],
+        ])
+        : 'No Lighthouse scan.';
+    return [
+        data.page.url,
+        `Observations: ${data.observations.total}`,
+        ...observations,
+        lighthouse,
+        `Tracked keywords: ${data.search.keywords.length}`,
+    ].join('\n');
+}
+export function renderPageScan(data) {
+    return [
+        `Page scan ${data.status}`,
+        `Page: ${data.pageId}${data.pageCreated ? ' (newly monitored)' : ''}`,
+        ...data.scans.map(scan => `${scan.strategy}: ${scan.scanId}`),
+    ].join('\n');
+}
+export function renderPerformance(data) {
+    if (!data.health)
+        return `No stored performance overview. Monitored routes: ${data.routes.length}.`;
+    return fields([
+        ['Scanned pages', data.health.scannedPageCount],
+        ['Last scan', data.health.lastScanAt],
+        ['Performance median', data.health.perf.median],
+        ['Performance worst', data.health.perf.worst],
+        ['Accessibility median', data.health.a11y.median],
+        ['SEO median', data.health.seo.median],
+        ['LCP median', data.health.lcp.median],
+        ['TBT median', data.health.tbt.median],
+        ['CLS median', data.health.cls.median],
+    ]);
+}
+export function renderSearchStatus(data) {
+    return fields([
+        ['Site', data.site],
+        ['Connected', data.connected],
+        ['Sync status', data.syncStatus],
+        ['Progress', `${data.progress.percent}%`],
+        ['Last sync', data.lastSyncAt],
+        ['Data available', data.hasData],
+        ['Coverage', `${data.daysSynced}/${data.daysAvailable} days`],
+    ]);
+}
+export function renderRecoverableBacklinks(data) {
+    if (data.items.length === 0)
+        return 'No recoverable Backlinks. Every stored inbound link resolves.';
+    const shown = `${data.offset + 1}-${data.offset + data.items.length} of ${data.total}`;
+    return [
+        `Recoverable Backlinks (${shown})`,
+        ...data.items.map(item => [
+            `${item.destinationStatus ?? 'unknown'}  ${item.destinationUrl}`,
+            `  from ${item.referringUrl}`,
+            `  ${fields([
+                ['domain', item.referringDomain],
+                ['anchor', item.anchor],
+                ['rank', item.domainRank],
+                ['dofollow', item.dofollow],
+                ['last seen', item.lastSeenAt],
+            ]).split('\n').join('\n  ')}`,
+        ].join('\n')),
+    ].join('\n');
+}
+export function renderMentions(data) {
+    if (data.items.length === 0)
+        return 'No Mentions.';
+    return [
+        `Mentions (${data.items.length})`,
+        ...data.items.map(item => [
+            `${item.source}  ${item.title ?? item.url}`,
+            `  ${item.url}`,
+            `  ${fields([
+                ['author', item.authorHandle ?? item.author],
+                ['rank', item.domainRank],
+                ['engagement', item.engagement],
+                ['sentiment', item.sentiment],
+                ['published', item.publishedAt],
+            ]).split('\n').join('\n  ')}`,
+        ].join('\n')),
+    ].join('\n');
+}

package/dist/runtime.d.ts

@@ -0,0 +1,18 @@
+import type { Readable, Writable } from 'node:stream';
+import type { StatePaths } from './state/index.js';
+export interface CliRuntime {
+    env: Readonly<Record<string, string | undefined>>;
+    paths: StatePaths;
+    input: Readable;
+    output: Writable;
+    error: Writable;
+    inputIsTTY: boolean;
+    interactive: boolean;
+    signal: AbortSignal;
+    requestSignal: AbortSignal;
+    readStdin: () => Promise<string>;
+}
+export declare function writeOutput(runtime: CliRuntime, text: string): void;
+export declare function writeDiagnostic(runtime: CliRuntime, text: string): void;
+export declare function writeProtocolResponse(runtime: CliRuntime, response: unknown): void;
+export declare function writeCliResponse(runtime: CliRuntime, response: unknown): void;

package/dist/runtime.js

@@ -0,0 +1,12 @@
+export function writeOutput(runtime, text) {
+    runtime.output.write(text.endsWith('\n') ? text : `${text}\n`);
+}
+export function writeDiagnostic(runtime, text) {
+    runtime.error.write(text.endsWith('\n') ? text : `${text}\n`);
+}
+export function writeProtocolResponse(runtime, response) {
+    writeOutput(runtime, JSON.stringify(response));
+}
+export function writeCliResponse(runtime, response) {
+    writeOutput(runtime, JSON.stringify(response));
+}

package/dist/site.d.ts

@@ -0,0 +1,5 @@
+import type { ApiContext } from './api.js';
+import type { CliResult } from './failures.js';
+import type { GlobalOptions } from './parse.js';
+import type { CliRuntime } from './runtime.js';
+export declare function resolveSite(api: ApiContext, runtime: CliRuntime, globals: GlobalOptions): Promise<CliResult<string>>;

package/dist/site.js

@@ -0,0 +1,48 @@
+import * as prompts from '@clack/prompts';
+import { fromStateError } from './api.js';
+import { EXIT_CODE, fail, fromSdkFailure, ok } from './failures.js';
+import { resolveSiteId, updateConfig } from './state/index.js';
+function label(site) {
+    return site.name ?? site.url ?? site.id;
+}
+export async function resolveSite(api, runtime, globals) {
+    const requested = resolveSiteId({
+        siteId: globals.siteId,
+        env: runtime.env,
+        config: api.config,
+    });
+    if (requested._tag === 'Err')
+        return fail(EXIT_CODE.invalidInput, `${requested.error._tag}: ${requested.error.message}`);
+    if (requested.value)
+        return ok(requested.value.siteId);
+    const listed = await api.client.sites.list({}, { signal: runtime.requestSignal });
+    if (listed._tag === 'Err')
+        return fromSdkFailure(listed.error);
+    const sites = listed.value.data.sites;
+    if (sites.length === 0) {
+        return fail(EXIT_CODE.notFound, 'site_empty: This token has no accessible Sites. Add a Site in the dashboard, then run `nuxtseo sites list`.', undefined, 'site_empty');
+    }
+    if (sites.length === 1)
+        return ok(sites[0].id);
+    if (!runtime.interactive) {
+        return fail(EXIT_CODE.conflict, 'site_ambiguous: Multiple Sites are accessible. Run `nuxtseo sites use <site-id>`, pass `--site <site-id>`, or set NUXTSEO_SITE_ID.', undefined, 'site_ambiguous');
+    }
+    const selectedId = await prompts.select({
+        message: 'Select a Site',
+        options: sites.map(site => ({
+            value: site.id,
+            label: label(site),
+            hint: site.url ?? site.id,
+        })),
+        input: runtime.input,
+        output: runtime.error,
+        signal: runtime.signal,
+    });
+    if (prompts.isCancel(selectedId))
+        return fail(EXIT_CODE.interrupted, 'interrupted: Site selection cancelled.');
+    const selected = sites.find(site => site.id === selectedId);
+    const persisted = await updateConfig({ siteId: selected.id }, { paths: runtime.paths });
+    if (persisted._tag === 'Err')
+        return fromStateError(persisted.error);
+    return ok(selected.id);
+}