@nuxtseo/cli 0.1.0

package/dist/state/auth.d.ts

@@ -0,0 +1,45 @@
+import type { StatePaths } from './paths.js';
+import type { StateResult } from './result.js';
+export type CredentialSource = 'env' | 'keychain' | 'file';
+export type CredentialStorage = Exclude<CredentialSource, 'env'>;
+export interface KeyringEntry {
+    getPassword: () => string | null | Promise<string | null>;
+    setPassword: (password: string) => void | Promise<void>;
+    deletePassword: () => boolean | Promise<boolean>;
+}
+export type KeyringEntryConstructor = new (service: string, account: string) => KeyringEntry;
+export type KeyringLoader = () => Promise<KeyringEntryConstructor | null>;
+export interface AuthStateOptions {
+    paths?: StatePaths;
+    loadKeyring?: KeyringLoader;
+}
+export interface ResolveCredentialOptions extends AuthStateOptions {
+    env: Readonly<Record<string, string | undefined>>;
+}
+export interface ResolvedCredential {
+    token: string;
+    source: CredentialSource;
+}
+export interface CredentialStatus {
+    authenticated: boolean;
+    source?: CredentialSource;
+}
+export interface FileCredentialFallbackWarning {
+    _tag: 'FileCredentialFallback';
+    reason: 'unavailable' | 'write-failed';
+    path: string;
+    message: string;
+}
+export interface SavedCredential {
+    storage: CredentialStorage;
+    warning?: FileCredentialFallbackWarning;
+}
+export interface ClearedCredential {
+    removed: boolean;
+}
+export declare function loadOptionalKeyring(): Promise<KeyringEntryConstructor | null>;
+export declare function loadStoredCredential(options?: AuthStateOptions): Promise<StateResult<ResolvedCredential | null>>;
+export declare function resolveCredential(options: ResolveCredentialOptions): Promise<StateResult<ResolvedCredential | null>>;
+export declare function getCredentialStatus(options: ResolveCredentialOptions): Promise<StateResult<CredentialStatus>>;
+export declare function saveCredential(value: string, options?: AuthStateOptions): Promise<StateResult<SavedCredential>>;
+export declare function clearCredential(options?: AuthStateOptions): Promise<StateResult<ClearedCredential>>;

package/dist/state/auth.js

@@ -0,0 +1,232 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { invalidState, readStateJson, removeStateFile, writeStateJson } from './files.js';
+import { defaultStatePaths } from './paths.js';
+import { err, ok } from './result.js';
+const AUTH_SCHEMA_VERSION = 1;
+const KEYRING_SERVICE = 'nuxtseo';
+const KEYRING_ACCOUNT = 'team-api-token';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseToken(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function parseAuthMarker(value, paths) {
+    if (!isRecord(value))
+        return invalidState(paths, 'auth', 'expected a JSON object.');
+    if (value.version !== AUTH_SCHEMA_VERSION)
+        return invalidState(paths, 'auth', `expected version ${AUTH_SCHEMA_VERSION}.`);
+    if (value.storage === 'keychain') {
+        const unknownKey = Object.keys(value).find(key => key !== 'version' && key !== 'storage');
+        return unknownKey
+            ? invalidState(paths, 'auth', `unknown field ${JSON.stringify(unknownKey)}.`)
+            : ok({ version: AUTH_SCHEMA_VERSION, storage: 'keychain' });
+    }
+    if (value.storage === 'file') {
+        const unknownKey = Object.keys(value).find(key => key !== 'version' && key !== 'storage' && key !== 'token');
+        if (unknownKey)
+            return invalidState(paths, 'auth', `unknown field ${JSON.stringify(unknownKey)}.`);
+        const token = parseToken(value.token);
+        return token
+            ? ok({ version: AUTH_SCHEMA_VERSION, storage: 'file', token })
+            : invalidState(paths, 'auth', 'file credentials require a non-empty token.');
+    }
+    return invalidState(paths, 'auth', 'storage must be "keychain" or "file".');
+}
+async function readAuthMarker(paths) {
+    const content = await readStateJson(paths, 'auth');
+    if (content._tag === 'Err')
+        return content;
+    if (content.value === null)
+        return ok(null);
+    return parseAuthMarker(content.value, paths);
+}
+export async function loadOptionalKeyring() {
+    // This package is optional because native keychain support is not available on
+    // every platform. A static import would prevent the documented file fallback.
+    const moduleName = '@napi-rs/keyring';
+    const loaded = await import(__rewriteRelativeImportExtension(moduleName)).catch(() => {
+        // Missing native support is expected and selects secure file storage.
+        return null;
+    });
+    if (!loaded || typeof loaded.Entry !== 'function')
+        return null;
+    return loaded.Entry;
+}
+function keyringFailure(operation, paths, cause) {
+    return err({
+        _tag: 'KeychainFailure',
+        operation,
+        path: paths.authFile,
+        message: `Could not ${operation} the NuxtSEO credential in the OS keychain. Local auth state is recorded at ${paths.authFile}.`,
+        cause,
+    });
+}
+async function resolveKeyring(options, paths) {
+    const Keyring = await (options.loadKeyring ?? loadOptionalKeyring)().catch(cause => cause);
+    if (typeof Keyring !== 'function') {
+        return err({
+            _tag: 'KeychainUnavailable',
+            path: paths.authFile,
+            message: `OS keychain support is unavailable. Local auth state is recorded at ${paths.authFile}.`,
+            ...(Keyring === null ? {} : { cause: Keyring }),
+        });
+    }
+    return ok(Keyring);
+}
+export async function loadStoredCredential(options = {}) {
+    const paths = options.paths ?? defaultStatePaths();
+    const marker = await readAuthMarker(paths);
+    if (marker._tag === 'Err')
+        return marker;
+    if (marker.value === null)
+        return ok(null);
+    if (marker.value.storage === 'file')
+        return ok({ token: marker.value.token, source: 'file' });
+    const keyring = await resolveKeyring(options, paths);
+    if (keyring._tag === 'Err')
+        return keyring;
+    const Entry = keyring.value;
+    const read = await Promise.resolve()
+        .then(() => new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT).getPassword())
+        .then(value => ok(value))
+        .catch(cause => keyringFailure('read', paths, cause));
+    if (read._tag === 'Err')
+        return read;
+    const parsedToken = parseToken(read.value);
+    return parsedToken
+        ? ok({ token: parsedToken, source: 'keychain' })
+        : err({
+            _tag: 'KeychainFailure',
+            operation: 'read',
+            path: paths.authFile,
+            message: `The OS keychain credential referenced by ${paths.authFile} is missing. Run nuxtseo login to replace it.`,
+        });
+}
+export async function resolveCredential(options) {
+    const environmentToken = options.env.NUXTSEO_TOKEN;
+    if (environmentToken !== undefined) {
+        const token = parseToken(environmentToken);
+        return token
+            ? ok({ token, source: 'env' })
+            : err({
+                _tag: 'InvalidCredential',
+                source: 'environment',
+                message: 'NUXTSEO_TOKEN is set but empty.',
+            });
+    }
+    return loadStoredCredential(options);
+}
+export async function getCredentialStatus(options) {
+    const environmentToken = options.env.NUXTSEO_TOKEN;
+    if (environmentToken !== undefined) {
+        return parseToken(environmentToken)
+            ? ok({ authenticated: true, source: 'env' })
+            : err({
+                _tag: 'InvalidCredential',
+                source: 'environment',
+                message: 'NUXTSEO_TOKEN is set but empty.',
+            });
+    }
+    const credential = await loadStoredCredential(options);
+    if (credential._tag === 'Err')
+        return credential;
+    return credential.value
+        ? ok({ authenticated: true, source: credential.value.source })
+        : ok({ authenticated: false });
+}
+export async function saveCredential(value, options = {}) {
+    const token = parseToken(value);
+    if (!token) {
+        return err({
+            _tag: 'InvalidCredential',
+            source: 'input',
+            message: 'The NuxtSEO API token cannot be empty.',
+        });
+    }
+    const paths = options.paths ?? defaultStatePaths();
+    const existing = await readAuthMarker(paths);
+    if (existing._tag === 'Err')
+        return existing;
+    const keyring = await resolveKeyring(options, paths);
+    let fallbackReason = 'unavailable';
+    if (keyring._tag === 'Ok') {
+        const Entry = keyring.value;
+        const stored = await Promise.resolve()
+            .then(() => {
+            const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
+            return Promise.resolve(entry.setPassword(token)).then(() => entry);
+        })
+            .then(entry => ok(entry))
+            .catch(cause => keyringFailure('write', paths, cause));
+        if (stored._tag === 'Ok') {
+            const marker = await writeStateJson(paths, 'auth', {
+                version: AUTH_SCHEMA_VERSION,
+                storage: 'keychain',
+            });
+            if (marker._tag === 'Ok')
+                return ok({ storage: 'keychain' });
+            // The marker is required to find this keychain entry later. Removing the
+            // just-written secret is best-effort while preserving the filesystem error.
+            await Promise.resolve(stored.value.deletePassword()).catch(() => false);
+            return marker;
+        }
+        fallbackReason = 'write-failed';
+    }
+    const written = await writeStateJson(paths, 'auth', {
+        version: AUTH_SCHEMA_VERSION,
+        storage: 'file',
+        token,
+    });
+    if (written._tag === 'Err')
+        return written;
+    return ok({
+        storage: 'file',
+        warning: {
+            _tag: 'FileCredentialFallback',
+            reason: fallbackReason,
+            path: paths.authFile,
+            message: `${fallbackReason === 'unavailable' ? 'OS keychain support is unavailable' : 'The OS keychain could not store the credential'}. The token was stored in ${paths.authFile} with mode 0600.`,
+        },
+    });
+}
+export async function clearCredential(options = {}) {
+    const paths = options.paths ?? defaultStatePaths();
+    const marker = await readAuthMarker(paths);
+    if (marker._tag === 'Err')
+        return marker;
+    if (marker.value === null)
+        return ok({ removed: false });
+    if (marker.value.storage === 'keychain') {
+        const keyring = await resolveKeyring(options, paths);
+        if (keyring._tag === 'Err')
+            return keyring;
+        const Entry = keyring.value;
+        const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
+        const existing = await Promise.resolve()
+            .then(() => entry.getPassword())
+            .then(value => ok(value))
+            .catch(cause => keyringFailure('read', paths, cause));
+        if (existing._tag === 'Err')
+            return existing;
+        if (parseToken(existing.value)) {
+            const removed = await Promise.resolve()
+                .then(() => entry.deletePassword())
+                .then(() => ok(undefined))
+                .catch(cause => keyringFailure('delete', paths, cause));
+            if (removed._tag === 'Err')
+                return removed;
+        }
+    }
+    const removedMarker = await removeStateFile(paths, 'auth');
+    return removedMarker._tag === 'Err'
+        ? removedMarker
+        : ok({ removed: removedMarker.value });
+}

package/dist/state/config.d.ts

@@ -0,0 +1,39 @@
+import type { StatePaths } from './paths.js';
+import type { StateResult } from './result.js';
+export declare const PRODUCTION_API_URL = "https://nuxtseo.com";
+export interface NuxtSeoConfig {
+    apiUrl?: string;
+    siteId?: string;
+}
+export type ApiUrlSource = 'argument' | 'environment' | 'config' | 'default';
+export interface ResolvedApiUrl {
+    apiUrl: string;
+    source: ApiUrlSource;
+}
+export type SiteIdSource = 'argument' | 'environment' | 'config';
+export interface ResolvedSiteId {
+    siteId: string;
+    source: SiteIdSource;
+}
+export interface InvalidSiteIdError {
+    _tag: 'InvalidSiteId';
+    source: Exclude<SiteIdSource, 'config'>;
+    message: string;
+}
+export interface ConfigStateOptions {
+    paths?: StatePaths;
+}
+export interface ResolveApiUrlOptions extends ConfigStateOptions {
+    apiUrl?: string;
+    env: Readonly<Record<string, string | undefined>>;
+}
+export interface ResolveSiteIdOptions {
+    siteId?: string;
+    env: Readonly<Record<string, string | undefined>>;
+    config: NuxtSeoConfig;
+}
+export declare function readConfig(options?: ConfigStateOptions): Promise<StateResult<NuxtSeoConfig>>;
+export declare function writeConfig(config: NuxtSeoConfig, options?: ConfigStateOptions): Promise<StateResult<NuxtSeoConfig>>;
+export declare function updateConfig(patch: Partial<NuxtSeoConfig>, options?: ConfigStateOptions): Promise<StateResult<NuxtSeoConfig>>;
+export declare function resolveApiUrl(options: ResolveApiUrlOptions): Promise<StateResult<ResolvedApiUrl>>;
+export declare function resolveSiteId(options: ResolveSiteIdOptions): StateResult<ResolvedSiteId | null, InvalidSiteIdError>;

package/dist/state/config.js

@@ -0,0 +1,145 @@
+import { invalidState, readStateJson, writeStateJson } from './files.js';
+import { defaultStatePaths } from './paths.js';
+import { err, ok } from './result.js';
+export const PRODUCTION_API_URL = 'https://nuxtseo.com';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeApiUrl(value) {
+    const input = value.trim();
+    if (!input)
+        return null;
+    const parsed = URL.parse(input);
+    if (!parsed || (parsed.protocol !== 'http:' && parsed.protocol !== 'https:'))
+        return null;
+    if (parsed.username || parsed.password || parsed.search || parsed.hash)
+        return null;
+    return parsed.toString().replace(/\/+$/, '');
+}
+function parseConfig(value, paths) {
+    if (!isRecord(value))
+        return invalidState(paths, 'config', 'expected a JSON object.');
+    const unknownKey = Object.keys(value).find(key => key !== 'apiUrl' && key !== 'siteId');
+    if (unknownKey)
+        return invalidState(paths, 'config', `unknown field ${JSON.stringify(unknownKey)}.`);
+    const config = {};
+    if (value.apiUrl !== undefined) {
+        if (typeof value.apiUrl !== 'string')
+            return invalidState(paths, 'config', 'apiUrl must be a string.');
+        const apiUrl = normalizeApiUrl(value.apiUrl);
+        if (!apiUrl)
+            return invalidState(paths, 'config', 'apiUrl must be an HTTP or HTTPS URL without credentials, a query, or a fragment.');
+        config.apiUrl = apiUrl;
+    }
+    if (value.siteId !== undefined) {
+        if (typeof value.siteId !== 'string' || !value.siteId.trim())
+            return invalidState(paths, 'config', 'siteId must be a non-empty string.');
+        config.siteId = value.siteId.trim();
+    }
+    return ok(config);
+}
+function parseConfigInput(config) {
+    const parsed = {};
+    if (config.apiUrl !== undefined) {
+        const apiUrl = normalizeApiUrl(config.apiUrl);
+        if (!apiUrl) {
+            return err({
+                _tag: 'InvalidConfig',
+                message: 'apiUrl must be an HTTP or HTTPS URL without credentials, a query, or a fragment.',
+            });
+        }
+        parsed.apiUrl = apiUrl;
+    }
+    if (config.siteId !== undefined) {
+        if (typeof config.siteId !== 'string' || !config.siteId.trim())
+            return err({ _tag: 'InvalidConfig', message: 'siteId must be a non-empty string.' });
+        parsed.siteId = config.siteId.trim();
+    }
+    return ok(parsed);
+}
+export async function readConfig(options = {}) {
+    const paths = options.paths ?? defaultStatePaths();
+    const content = await readStateJson(paths, 'config');
+    if (content._tag === 'Err')
+        return content;
+    return content.value === null ? ok({}) : parseConfig(content.value, paths);
+}
+export async function writeConfig(config, options = {}) {
+    const parsed = parseConfigInput(config);
+    if (parsed._tag === 'Err')
+        return parsed;
+    const current = await readConfig(options);
+    if (current._tag === 'Err')
+        return current;
+    return persistConfig(parsed.value, options);
+}
+async function persistConfig(config, options) {
+    const paths = options.paths ?? defaultStatePaths();
+    const written = await writeStateJson(paths, 'config', config);
+    return written._tag === 'Err' ? written : ok(config);
+}
+export async function updateConfig(patch, options = {}) {
+    const current = await readConfig(options);
+    if (current._tag === 'Err')
+        return current;
+    const next = parseConfigInput({ ...current.value, ...patch });
+    if (next._tag === 'Err')
+        return next;
+    return persistConfig(next.value, options);
+}
+export async function resolveApiUrl(options) {
+    const argumentValue = options.apiUrl;
+    if (argumentValue !== undefined) {
+        const apiUrl = normalizeApiUrl(argumentValue);
+        return apiUrl
+            ? ok({ apiUrl, source: 'argument' })
+            : err({
+                _tag: 'InvalidApiUrl',
+                source: 'argument',
+                message: '--api-url must be an HTTP or HTTPS URL without credentials, a query, or a fragment.',
+            });
+    }
+    const environmentValue = options.env.NUXTSEO_API_URL;
+    if (environmentValue !== undefined) {
+        const apiUrl = normalizeApiUrl(environmentValue);
+        return apiUrl
+            ? ok({ apiUrl, source: 'environment' })
+            : err({
+                _tag: 'InvalidApiUrl',
+                source: 'environment',
+                message: 'NUXTSEO_API_URL must be an HTTP or HTTPS URL without credentials, a query, or a fragment.',
+            });
+    }
+    const config = await readConfig(options);
+    if (config._tag === 'Err')
+        return config;
+    return config.value.apiUrl
+        ? ok({ apiUrl: config.value.apiUrl, source: 'config' })
+        : ok({ apiUrl: PRODUCTION_API_URL, source: 'default' });
+}
+export function resolveSiteId(options) {
+    if (options.siteId !== undefined) {
+        const siteId = options.siteId.trim();
+        return siteId
+            ? ok({ siteId, source: 'argument' })
+            : err({
+                _tag: 'InvalidSiteId',
+                source: 'argument',
+                message: '--site cannot be empty.',
+            });
+    }
+    const environmentSiteId = options.env.NUXTSEO_SITE_ID;
+    if (environmentSiteId !== undefined) {
+        const siteId = environmentSiteId.trim();
+        return siteId
+            ? ok({ siteId, source: 'environment' })
+            : err({
+                _tag: 'InvalidSiteId',
+                source: 'environment',
+                message: 'NUXTSEO_SITE_ID is set but empty.',
+            });
+    }
+    return options.config.siteId
+        ? ok({ siteId: options.config.siteId, source: 'config' })
+        : ok(null);
+}

package/dist/state/files.d.ts

@@ -0,0 +1,6 @@
+import type { StatePaths } from './paths.js';
+import type { StateKind, StateResult } from './result.js';
+export declare function readStateJson(paths: StatePaths, kind: StateKind): Promise<StateResult<unknown | null>>;
+export declare function invalidState(paths: StatePaths, kind: StateKind, detail: string, cause?: unknown): StateResult<never>;
+export declare function writeStateJson(paths: StatePaths, kind: StateKind, value: unknown): Promise<StateResult<void>>;
+export declare function removeStateFile(paths: StatePaths, kind: StateKind): Promise<StateResult<boolean>>;

package/dist/state/files.js

@@ -0,0 +1,125 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { err, ok } from './result.js';
+function errorCode(cause) {
+    if (typeof cause !== 'object' || cause === null || !('code' in cause))
+        return undefined;
+    return typeof cause.code === 'string' ? cause.code : undefined;
+}
+function isMissing(cause) {
+    return errorCode(cause) === 'ENOENT';
+}
+function isReadOnly(cause) {
+    const code = errorCode(cause);
+    return code === 'EACCES' || code === 'EPERM' || code === 'EROFS';
+}
+function statePath(paths, kind) {
+    return kind === 'auth' ? paths.authFile : paths.configFile;
+}
+function corruptState(kind, path, detail, cause) {
+    const common = {
+        path,
+        message: `Could not parse NuxtSEO ${kind} state at ${path}: ${detail}`,
+        ...(cause === undefined ? {} : { cause }),
+    };
+    return kind === 'auth'
+        ? { _tag: 'CorruptAuth', ...common }
+        : { _tag: 'CorruptConfig', ...common };
+}
+export async function readStateJson(paths, kind) {
+    const path = statePath(paths, kind);
+    const content = await readFile(path, 'utf8').catch(cause => cause);
+    if (content instanceof Error || typeof content !== 'string') {
+        if (isMissing(content))
+            return ok(null);
+        return err({
+            _tag: 'StateFilesystemError',
+            kind,
+            operation: 'read',
+            path,
+            message: `Could not read NuxtSEO ${kind} state at ${path}.`,
+            cause: content,
+        });
+    }
+    if (!content.trim())
+        return err(corruptState(kind, path, 'the file is empty.'));
+    const parsed = await Promise.resolve()
+        .then(() => JSON.parse(content))
+        .then(value => ok(value))
+        .catch(cause => invalidState(paths, kind, 'the file does not contain valid JSON.', cause));
+    return parsed;
+}
+export function invalidState(paths, kind, detail, cause) {
+    return err(corruptState(kind, statePath(paths, kind), detail, cause));
+}
+export async function writeStateJson(paths, kind, value) {
+    const path = statePath(paths, kind);
+    const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    let temporaryCreated = false;
+    const written = await Promise.resolve()
+        .then(async () => {
+        await mkdir(paths.directory, { recursive: true, mode: 0o700 });
+        await chmod(paths.directory, 0o700);
+        await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, {
+            encoding: 'utf8',
+            flag: 'wx',
+            mode: 0o600,
+        });
+        temporaryCreated = true;
+        await chmod(temporaryPath, 0o600);
+        await rename(temporaryPath, path);
+    })
+        .then(() => ok(undefined))
+        .catch(cause => err(isReadOnly(cause)
+        ? {
+            _tag: 'ReadOnlyFilesystem',
+            kind,
+            operation: 'write',
+            path,
+            message: `Could not write NuxtSEO ${kind} state at ${path}: the filesystem is read-only or permission was denied.`,
+            cause,
+        }
+        : {
+            _tag: 'StateFilesystemError',
+            kind,
+            operation: 'write',
+            path,
+            message: `Could not write NuxtSEO ${kind} state at ${path}.`,
+            cause,
+        }));
+    if (written._tag === 'Err' && temporaryCreated) {
+        // The destination remains untouched. Failure to remove this unique temp file
+        // does not hide the original actionable write error.
+        await rm(temporaryPath, { force: true }).catch(() => {
+            // A unique temp file is inert. Preserve the original actionable error.
+            return undefined;
+        });
+    }
+    return written;
+}
+export async function removeStateFile(paths, kind) {
+    const path = statePath(paths, kind);
+    return rm(path)
+        .then(() => ok(true))
+        .catch((cause) => {
+        if (isMissing(cause))
+            return ok(false);
+        return err(isReadOnly(cause)
+            ? {
+                _tag: 'ReadOnlyFilesystem',
+                kind,
+                operation: 'delete',
+                path,
+                message: `Could not remove NuxtSEO ${kind} state at ${path}: the filesystem is read-only or permission was denied.`,
+                cause,
+            }
+            : {
+                _tag: 'StateFilesystemError',
+                kind,
+                operation: 'delete',
+                path,
+                message: `Could not remove NuxtSEO ${kind} state at ${path}.`,
+                cause,
+            });
+    });
+}

package/dist/state/index.d.ts

@@ -0,0 +1,4 @@
+export * from './auth.js';
+export * from './config.js';
+export * from './paths.js';
+export * from './result.js';

package/dist/state/index.js

@@ -0,0 +1,4 @@
+export * from './auth.js';
+export * from './config.js';
+export * from './paths.js';
+export * from './result.js';

package/dist/state/paths.d.ts

@@ -0,0 +1,10 @@
+export declare const STATE_DIRECTORY_NAME = ".nuxtseo";
+export declare const AUTH_FILENAME = "auth.json";
+export declare const CONFIG_FILENAME = "config.json";
+export interface StatePaths {
+    directory: string;
+    authFile: string;
+    configFile: string;
+}
+export declare function createStatePaths(homeDirectory: string): StatePaths;
+export declare function defaultStatePaths(): StatePaths;

package/dist/state/paths.js

@@ -0,0 +1,16 @@
+import { homedir } from 'node:os';
+import { join } from 'pathe';
+export const STATE_DIRECTORY_NAME = '.nuxtseo';
+export const AUTH_FILENAME = 'auth.json';
+export const CONFIG_FILENAME = 'config.json';
+export function createStatePaths(homeDirectory) {
+    const directory = join(homeDirectory, STATE_DIRECTORY_NAME);
+    return {
+        directory,
+        authFile: join(directory, AUTH_FILENAME),
+        configFile: join(directory, CONFIG_FILENAME),
+    };
+}
+export function defaultStatePaths() {
+    return createStatePaths(homedir());
+}