@4ge/cli 0.1.0

package/dist/core/auth/api-client.js

@@ -0,0 +1,156 @@
+import { client } from '../../generated/api/client.gen.js';
+import { getApiBaseUrl } from './config.js';
+import { ensureFreshToken } from './token-refresh.js';
+import { ConnectivityError } from './errors.js';
+export { ConnectivityError } from './errors.js';
+/**
+ * Check if an error is an authentication-related error.
+ * Works with error objects returned by the API client when throwOnError is false.
+ */
+export function isAuthError(error) {
+    return error?.code === 'TOKEN_EXPIRED' || error?.code === 'INVALID_API_KEY';
+}
+/**
+ * Get actionable guidance for an authentication error.
+ * Returns null if the error is not an auth error.
+ */
+export function getAuthErrorHint(error) {
+    if (error?.code === 'TOKEN_EXPIRED') {
+        return "Run '4ge auth login' to re-authenticate";
+    }
+    if (error?.code === 'INVALID_API_KEY') {
+        return 'Check your 4GE_API_KEY environment variable';
+    }
+    return null;
+}
+/**
+ * Check if the API server is reachable.
+ * Performs a lightweight HEAD request with a 5-second timeout.
+ */
+export async function checkConnectivity(baseUrl) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
+    try {
+        await fetch(baseUrl, {
+            method: 'HEAD',
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        let message = `Cannot connect to the API server at ${baseUrl}. Please check that the server is running and accessible.`;
+        if (error.name === 'AbortError') {
+            message = `Connection to API server at ${baseUrl} timed out after 5 seconds.`;
+        }
+        throw new ConnectivityError(baseUrl, message);
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Create an authenticated API client wrapper.
+ * This wraps the generated API client from src/generated/api/
+ * and injects authentication headers automatically.
+ *
+ * Headers added:
+ * - Authorization: Bearer <api_key> (PAT or OAuth access token)
+ * - X-Client-Type: 4ge-agent (when isJsonMode is true)
+ *
+ * Interceptors added:
+ * - Request: injects Authorization + X-Client-Type headers
+ * - Response: intercepts 401s and attempts token refresh + retry (once)
+ * - Error: attaches structured auth error info (code + hint) for 401s
+ *
+ * NOTE: This implementation currently uses a singleton client.
+ * Interceptors are cleared and re-added to ensure the correct credentials
+ * are used for the current call. This is safe for CLI usage patterns.
+ */
+export function createApiClient(opts) {
+    const { credential, isJsonMode, baseUrl = getApiBaseUrl() } = opts;
+    client.setConfig({
+        baseUrl,
+    });
+    // Clear existing interceptors to avoid duplication if called multiple times
+    client.interceptors.request.clear();
+    client.interceptors.response.clear();
+    client.interceptors.error.clear();
+    client.interceptors.request.use((request) => {
+        request.headers.set('Authorization', `Bearer ${credential.api_key}`);
+        if (isJsonMode) {
+            request.headers.set('X-Client-Type', '4ge-agent');
+        }
+        return request;
+    });
+    // Response interceptor: handle 401 with token refresh + retry (once)
+    client.interceptors.response.use(async (response, request, options) => {
+        if (response.status !== 401) {
+            return response;
+        }
+        // Already retried once — don't retry again to prevent infinite loops
+        if (request.headers.has('X-Auth-Retry')) {
+            return response;
+        }
+        // PAT auth (environment source) cannot be refreshed
+        if (credential.source === 'environment') {
+            return response;
+        }
+        // No refresh token available — can't refresh
+        if (!credential.refresh_token) {
+            return response;
+        }
+        try {
+            const freshCredential = await ensureFreshToken();
+            // Only retry if refresh produced a new access token
+            if (freshCredential && freshCredential.api_key !== credential.api_key) {
+                const retryHeaders = new Headers(request.headers);
+                retryHeaders.set('Authorization', `Bearer ${freshCredential.api_key}`);
+                retryHeaders.set('X-Auth-Retry', '1');
+                const _fetch = options.fetch ?? globalThis.fetch;
+                const retryBody = options.serializedBody || undefined;
+                const retryRequest = new Request(request.url, {
+                    method: request.method,
+                    headers: retryHeaders,
+                    body: retryBody,
+                    redirect: request.redirect,
+                    credentials: request.credentials,
+                });
+                return await _fetch(retryRequest);
+            }
+        }
+        catch (err) {
+            // Refresh failed. If the server is unreachable, ensureFreshToken throws
+            // a ConnectivityError — re-throw it so callers can distinguish a dead
+            // server (CONNECTION_ERROR) from a dead token (TOKEN_EXPIRED). The
+            // error interceptor preserves it instead of forcing TOKEN_EXPIRED.
+            if (err instanceof ConnectivityError) {
+                throw err;
+            }
+            // Other refresh failures (rejected refresh token) fall through to the
+            // original 401, which the error interceptor labels TOKEN_EXPIRED.
+        }
+        return response;
+    });
+    // Error interceptor: attach structured auth error info for 401s
+    client.interceptors.error.use((error, response, _request, _options) => {
+        // A ConnectivityError re-thrown from the 401-retry path means the server
+        // is unreachable — preserve its code so callers don't mistake it for a
+        // session-expiry (the 401 response is still attached, which would
+        // otherwise force TOKEN_EXPIRED below).
+        if (error instanceof ConnectivityError) {
+            return error;
+        }
+        if (response?.status === 401) {
+            const isPatAuth = credential.source === 'environment' || !credential.refresh_token;
+            const authError = {
+                ...(typeof error === 'object' && error !== null ? error : { message: String(error) }),
+                code: isPatAuth ? 'INVALID_API_KEY' : 'TOKEN_EXPIRED',
+                hint: isPatAuth
+                    ? 'Check your 4GE_API_KEY environment variable'
+                    : "Run '4ge auth login' to re-authenticate",
+            };
+            return authError;
+        }
+        return error;
+    });
+    return client;
+}

package/dist/core/auth/config.js

@@ -0,0 +1,3 @@
+export function getApiBaseUrl() {
+    return process.env['4GE_API_URL'] || process.env['CORE_API_URL'] || 'https://app.4ge.dev';
+}

package/dist/core/auth/credentials.js

@@ -0,0 +1,143 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+// Zod schema for credentials file
+const ProfileCredentialSchema = z.object({
+    // PAT authentication
+    api_key: z.string().min(1).optional(),
+    // OAuth / email authentication
+    access_token: z.string().min(1).optional(),
+    refresh_token: z.string().min(1).optional(),
+    expires_at: z.number().optional(),
+    user: z.object({
+        id: z.string(),
+        email: z.string(),
+    }).optional(),
+}).refine((data) => data.api_key || data.access_token, { message: 'Profile must have either api_key or access_token' });
+export const CredentialsFileSchema = z.object({
+    default: ProfileCredentialSchema.optional(),
+    profiles: z.record(z.string(), ProfileCredentialSchema).default({}),
+    active_profile: z.string().default('default'),
+});
+// Paths
+export function getGlobalCredentialsPath() {
+    return join(homedir(), '.4ge', 'credentials.json');
+}
+export function getLocalCredentialsPath() {
+    return join(process.cwd(), '.4ge', 'credentials.json');
+}
+// Read credentials file (returns null if doesn't exist or invalid)
+export async function readCredentialsFile(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        const result = CredentialsFileSchema.safeParse(JSON.parse(content));
+        return result.success ? result.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Write credentials file (creates directory if needed)
+export async function writeCredentialsFile(filePath, data) {
+    const dir = dirname(filePath);
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(filePath, JSON.stringify(data, null, 2), { encoding: 'utf-8', mode: 0o600 });
+}
+// Save a credential to a specific location and profile
+export async function saveCredential(opts) {
+    const hasToken = opts.apiKey || opts.accessToken;
+    if (!hasToken) {
+        throw new Error('Either apiKey or accessToken must be provided');
+    }
+    const filePath = opts.local ? getLocalCredentialsPath() : getGlobalCredentialsPath();
+    const existing = (await readCredentialsFile(filePath)) ?? {
+        profiles: {},
+        active_profile: 'default',
+    };
+    const profile = opts.profile ?? 'default';
+    const profileData = {};
+    if (opts.apiKey)
+        profileData.api_key = opts.apiKey;
+    if (opts.accessToken)
+        profileData.access_token = opts.accessToken;
+    if (opts.refreshToken)
+        profileData.refresh_token = opts.refreshToken;
+    if (opts.expiresAt !== undefined)
+        profileData.expires_at = opts.expiresAt;
+    if (opts.user)
+        profileData.user = opts.user;
+    if (profile === 'default') {
+        existing.default = profileData;
+    }
+    else {
+        existing.profiles[profile] = profileData;
+    }
+    await writeCredentialsFile(filePath, existing);
+}
+// Clear a credential from a specific location
+export async function clearCredential(opts) {
+    const filePath = opts.local ? getLocalCredentialsPath() : getGlobalCredentialsPath();
+    const existing = await readCredentialsFile(filePath);
+    if (!existing)
+        return;
+    const profileToClear = opts.profile ?? existing.active_profile;
+    if (profileToClear === 'default') {
+        delete existing.default;
+    }
+    else {
+        delete existing.profiles[profileToClear];
+    }
+    if (existing.active_profile === profileToClear) {
+        existing.active_profile = 'default';
+    }
+    await writeCredentialsFile(filePath, existing);
+}
+// List all profiles in the global credentials file
+export async function listProfiles() {
+    const filePath = getGlobalCredentialsPath();
+    const data = (await readCredentialsFile(filePath)) ?? {
+        profiles: {},
+        active_profile: 'default',
+    };
+    const profiles = [];
+    if (data.default?.api_key || data.default?.access_token) {
+        profiles.push({ name: 'default', is_active: data.active_profile === 'default' });
+    }
+    profiles.push(...Object.keys(data.profiles).map((name) => ({
+        name,
+        is_active: data.active_profile === name,
+    })));
+    return {
+        profiles,
+        active_profile: data.active_profile,
+    };
+}
+// Set the active profile in global credentials
+export async function setActiveProfile(name) {
+    const filePath = getGlobalCredentialsPath();
+    const existing = await readCredentialsFile(filePath);
+    if (!existing) {
+        throw new Error('No credentials file found. Please login first.');
+    }
+    if (name !== 'default' && !existing.profiles[name]) {
+        throw new Error(`Profile "${name}" not found.`);
+    }
+    existing.active_profile = name;
+    await writeCredentialsFile(filePath, existing);
+}
+// Delete a named profile from global credentials
+export async function deleteProfile(name) {
+    if (name === 'default') {
+        throw new Error('Cannot delete the default profile.');
+    }
+    const filePath = getGlobalCredentialsPath();
+    const existing = await readCredentialsFile(filePath);
+    if (!existing)
+        return;
+    delete existing.profiles[name];
+    if (existing.active_profile === name) {
+        existing.active_profile = 'default';
+    }
+    await writeCredentialsFile(filePath, existing);
+}

package/dist/core/auth/email-auth.js

@@ -0,0 +1,30 @@
+import { cliAuthEmailLogin } from '../../generated/api/sdk.gen.js';
+/**
+ * Authenticate with email and password via the Core API.
+ * Uses the generated SDK function cliAuthEmailLogin.
+ */
+export async function authenticateWithEmail(opts) {
+    const { email, password, baseUrl } = opts;
+    // Build the client options - we don't need auth for this endpoint (security: [])
+    const clientOptions = {};
+    if (baseUrl) {
+        // We need to set the baseUrl on the client before calling
+        // This will be handled by the caller setting up the client
+    }
+    const { data, error } = await cliAuthEmailLogin({
+        body: { email, password },
+        ...(baseUrl ? { baseUrl } : {}),
+    });
+    if (error) {
+        const errorMsg = error instanceof Error ? error.message
+            : (typeof error === 'object' && error !== null && 'message' in error) ? String(error.message)
+                : String(error);
+        throw new Error(`Email authentication failed: ${errorMsg}`);
+    }
+    // Extract the inner data payload from the SDK envelope
+    const payload = data?.data;
+    if (!payload?.access_token) {
+        throw new Error('Email authentication failed: invalid response from server');
+    }
+    return payload;
+}

package/dist/core/auth/errors.js

@@ -0,0 +1,20 @@
+/**
+ * ConnectivityError — raised when the 4ge Core API server is unreachable
+ * (network failure, DNS, timeout, abort, or non-JSON response).
+ *
+ * Kept in its own module so that low-level auth helpers (e.g. token-refresh)
+ * can throw ConnectivityError without importing the full api-client (which
+ * would create a circular dependency: api-client imports ensureFreshToken
+ * from token-refresh).
+ *
+ * `code` is always 'CONNECTION_ERROR' for machine-readable consumers.
+ */
+export class ConnectivityError extends Error {
+    url;
+    code = 'CONNECTION_ERROR';
+    constructor(url, message) {
+        super(message);
+        this.url = url;
+        this.name = 'ConnectivityError';
+    }
+}

package/dist/core/auth/index.js

@@ -0,0 +1,6 @@
+export * from './credentials.js';
+export * from './resolution.js';
+export * from './errors.js';
+export * from './api-client.js';
+export * from './token-refresh.js';
+export * from './config.js';

package/dist/core/auth/realtime.js

@@ -0,0 +1,82 @@
+import { createClient } from '@supabase/supabase-js';
+/**
+ * Subscribe to a Supabase Realtime broadcast channel to receive OAuth tokens.
+ * Channel pattern: oauth:${state}
+ * Event: 'tokens'
+ *
+ * Returns a promise that resolves with the tokens when the broadcast event is received,
+ * or rejects on timeout.
+ */
+export async function subscribeForTokens(opts) {
+    const { supabaseUrl, supabaseAnonKey, state, timeoutMs = 5 * 60 * 1000 } = opts;
+    const supabase = createClient(supabaseUrl, supabaseAnonKey);
+    const channel = supabase.channel(`oauth:${state}`);
+    let timeoutHandle = null;
+    let resolveFunc = null;
+    let rejectFunc = null;
+    const tokensPromise = new Promise((resolve, reject) => {
+        resolveFunc = resolve;
+        rejectFunc = reject;
+        // Set timeout for handshake
+        timeoutHandle = setTimeout(() => {
+            cleanup();
+            reject(new Error('OAuth handshake timed out after 5 minutes. Please try again.'));
+        }, timeoutMs);
+    });
+    const cleanup = () => {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+            timeoutHandle = null;
+        }
+        supabase.removeChannel(channel);
+    };
+    // Subscribe to the broadcast channel and listen for 'tokens' event
+    channel.on('broadcast', { event: 'tokens' }, (payload) => {
+        const tokens = payload.payload;
+        // Validate the tokens have all required fields (securely receive)
+        if (!tokens?.access_token ||
+            !tokens?.refresh_token ||
+            typeof tokens?.expires_at !== 'number' ||
+            typeof tokens?.expires_in !== 'number' ||
+            !tokens?.user?.id ||
+            !tokens?.user?.email) {
+            return; // Ignore invalid payloads
+        }
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+            timeoutHandle = null;
+        }
+        resolveFunc(tokens);
+    });
+    // Subscribe and wait for connection
+    await new Promise((resolve, reject) => {
+        channel.subscribe((status, err) => {
+            if (status === 'SUBSCRIBED') {
+                resolve();
+            }
+            else if (status === 'CHANNEL_ERROR' || status === 'TIMED_OUT') {
+                cleanup();
+                reject(new Error(`Realtime subscription failed: ${status}${err ? ` - ${err.message}` : ''}`));
+            }
+        });
+    });
+    return {
+        tokens: await tokensPromise,
+        cleanup,
+    };
+}
+/**
+ * Get the Supabase URL and anon key from environment variables.
+ * Throws if either is missing.
+ */
+export function getSupabaseConfig() {
+    const supabaseUrl = process.env.SUPABASE_URL;
+    const supabaseAnonKey = process.env.SUPABASE_ANON_KEY;
+    if (!supabaseUrl) {
+        throw new Error('SUPABASE_URL environment variable is required for OAuth login. Set it in your .env file or environment.');
+    }
+    if (!supabaseAnonKey) {
+        throw new Error('SUPABASE_ANON_KEY environment variable is required for OAuth login. Set it in your .env file or environment.');
+    }
+    return { supabaseUrl, supabaseAnonKey };
+}

package/dist/core/auth/resolution.js

@@ -0,0 +1,63 @@
+import { getGlobalCredentialsPath, getLocalCredentialsPath, readCredentialsFile } from './credentials.js';
+/**
+ * Resolve credentials in priority order:
+ * 1. 4GE_API_KEY environment variable → { source: 'environment' }
+ * 2. ./.4ge/credentials.json (local) → { source: 'local' }
+ * 3. ~/.4ge/credentials.json active profile → { source: 'global', profile: '...' }
+ *
+ * Returns null if no credentials found.
+ */
+export async function resolveCredential() {
+    // 1. Environment variable
+    const envKey = process.env['4GE_API_KEY'];
+    if (envKey && envKey.length > 0) {
+        return {
+            api_key: envKey,
+            source: 'environment',
+            profile: 'default',
+        };
+    }
+    // 2. Local credentials
+    const localData = await readCredentialsFile(getLocalCredentialsPath());
+    if (localData) {
+        const { active_profile } = localData;
+        const profile = active_profile === 'default'
+            ? localData.default
+            : localData.profiles[active_profile];
+        if (profile) {
+            const api_key = profile.access_token || profile.api_key;
+            if (api_key && api_key.length > 0) {
+                return {
+                    api_key,
+                    source: 'local',
+                    profile: active_profile,
+                    refresh_token: profile.refresh_token,
+                    expires_at: profile.expires_at,
+                    user: profile.user,
+                };
+            }
+        }
+    }
+    // 3. Global credentials
+    const globalData = await readCredentialsFile(getGlobalCredentialsPath());
+    if (globalData) {
+        const { active_profile } = globalData;
+        const profile = active_profile === 'default'
+            ? globalData.default
+            : globalData.profiles[active_profile];
+        if (profile) {
+            const api_key = profile.access_token || profile.api_key;
+            if (api_key && api_key.length > 0) {
+                return {
+                    api_key,
+                    source: 'global',
+                    profile: active_profile,
+                    refresh_token: profile.refresh_token,
+                    expires_at: profile.expires_at,
+                    user: profile.user,
+                };
+            }
+        }
+    }
+    return null;
+}

package/dist/core/auth/state.js

@@ -0,0 +1,9 @@
+import { randomBytes } from 'node:crypto';
+/**
+ * Generate a cryptographically secure state token for OAuth Realtime flow.
+ * Used as the channel identifier (oauth:${state}) and CSRF protection.
+ * @param bytes - Number of random bytes (default 32 = 64 hex chars)
+ */
+export function generateState(bytes = 32) {
+    return randomBytes(bytes).toString('hex');
+}

package/dist/core/auth/token-refresh.js

@@ -0,0 +1,100 @@
+import { resolveCredential } from './resolution.js';
+import { saveCredential } from './credentials.js';
+import { getApiBaseUrl } from './config.js';
+import { ConnectivityError } from './errors.js';
+/**
+ * Ensures the current credential has a fresh access token.
+ * If the token is expired or expiring soon, it performs a refresh.
+ *
+ * Returns the fresh credential.
+ */
+export async function ensureFreshToken() {
+    const credential = await resolveCredential();
+    if (!credential || (!credential.api_key && !credential.refresh_token)) {
+        return null;
+    }
+    // Environment-sourced credentials should never be refreshed or persisted
+    if (credential.source === 'environment') {
+        return credential;
+    }
+    // Skip refresh for PAT-based auth (no refresh_token)
+    if (!credential.refresh_token) {
+        return credential;
+    }
+    // Check if token is expired or expiring soon
+    const now = Math.floor(Date.now() / 1000);
+    const isFresh = credential.expires_at && credential.expires_at > (now + 30);
+    if (isFresh) {
+        return credential;
+    }
+    // Token is expired or expiring soon — refresh it.
+    //
+    // Two failure modes must be distinguished:
+    //   1. Network/connectivity failure (server unreachable, DNS, timeout):
+    //      the fetch throws (TypeError) or aborts. Classify as CONNECTION_ERROR
+    //      so callers can tell the user "the server is down" rather than
+    //      "your session expired".
+    //   2. Session genuinely expired: the server is reachable and explicitly
+    //      rejects the refresh token (401 / error envelope). Classify as
+    //      SESSION_EXPIRED so the user is prompted to re-authenticate.
+    const baseUrl = getApiBaseUrl();
+    const refreshUrl = `${baseUrl}/api/cli/v1/auth/token/refresh`;
+    let response;
+    try {
+        response = await fetch(refreshUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ refresh_token: credential.refresh_token }),
+        });
+    }
+    catch (networkError) {
+        // fetch threw — server unreachable / DNS / timeout / abort.
+        // This is NOT a session-expiry; do not conflate them. Reuse the
+        // canonical ConnectivityError class so instanceof checks and code
+        // consumers stay consistent across the auth module.
+        throw new ConnectivityError(refreshUrl, `Cannot connect to the API server to refresh the token: ${networkError.message}. ` +
+            `Check that the server is running and reachable at ${baseUrl}.`);
+    }
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch (parseError) {
+        // Server responded but body wasn't JSON — treat as a connectivity/server error,
+        // not session expiry.
+        throw new ConnectivityError(refreshUrl, `Token refresh endpoint returned a non-JSON response (status ${response.status}): ${parseError.message}.`);
+    }
+    if (result.error || !result.data) {
+        // Server is reachable and explicitly rejected the refresh token.
+        throw new Error(`Session expired. Please re-authenticate: run '4ge auth login'\n` +
+            `Details: ${result.error?.message || 'Refresh token is invalid or expired'}`);
+    }
+    try {
+        // Update the credential and persist it
+        await saveCredential({
+            accessToken: result.data.access_token,
+            refreshToken: result.data.refresh_token,
+            expiresAt: result.data.expires_at,
+            user: result.data.user || credential.user,
+            profile: credential.profile,
+            local: credential.source === 'local',
+        });
+        return {
+            ...credential,
+            api_key: result.data.access_token,
+            refresh_token: result.data.refresh_token,
+            expires_at: result.data.expires_at,
+            user: result.data.user || credential.user,
+        };
+    }
+    catch (error) {
+        // Re-throw errors we've already classified (ConnectivityError or the
+        // "Session expired" Error above) without wrapping them — their message
+        // and code must be preserved for callers to act on.
+        if (error instanceof ConnectivityError || error.message?.includes('Session expired')) {
+            throw error;
+        }
+        // Unexpected error (e.g. saveCredential failure) — surface it.
+        throw new Error(`Failed to refresh token: ${error.message}`);
+    }
+}

package/dist/core/config/defaults.js

@@ -0,0 +1,31 @@
+/**
+ * Resolve the roadmap query value for a hierarchy pull (plan:pull + the
+ * recursive tree path of epic/story/feature:pull).
+ *
+ * Precedence: explicit `--roadmap` flag > `config.hierarchy.default_roadmap_filter`
+ * > omit the filter entirely (pull every roadmap status).
+ *
+ * Returns the roadmap literal to send, or `undefined` to omit the filter.
+ */
+export function resolveRoadmapFilter(flagValue, config) {
+    if (flagValue)
+        return flagValue;
+    const configured = config?.hierarchy?.default_roadmap_filter;
+    if (configured && configured !== 'all')
+        return configured;
+    return undefined;
+}
+/**
+ * Resolve whether a hierarchy pull should descend into the tree.
+ *
+ * Precedence: explicit `--recursive`/`--no-recursive` flag >
+ * `config.hierarchy.recursive_pull` > `false`.
+ *
+ * `flagValue` is `undefined` when neither `--recursive` nor `--no-recursive`
+ * was passed (oclif boolean with `allowNo` and no default).
+ */
+export function resolveRecursive(flagValue, config) {
+    if (flagValue !== undefined)
+        return flagValue;
+    return config?.hierarchy?.recursive_pull ?? false;
+}

package/dist/core/config/index.js

@@ -0,0 +1,3 @@
+export * from './schema.js';
+export * from './parser.js';
+export * from './defaults.js';