@mx-space/cli 0.15.1 → 0.15.2

package/dist/src/services/Auth.js

@@ -1,402 +0,0 @@
-import { HttpClient, HttpClientRequest } from '@effect/platform';
-import { Context, Effect, Layer } from 'effect';
-import { AuthDenied, AuthExpired, AuthMissing, AuthProbe, Generic, NetworkDns, NetworkRefused, NetworkTimeout, } from '../domain/errors';
-import { Config } from './Config';
-export const SUPPORTED_API_VERSIONS = [3, 2];
-export class Auth extends Context.Tag('Auth')() {
-    /** Build the Auth Layer; depends on `Config` and `HttpClient`. */
-    static Default = Layer.effect(Auth, Effect.gen(function* () {
-        const http = yield* HttpClient.HttpClient;
-        const config = yield* Config;
-        return makeAuthService(http, config);
-    }));
-}
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-const TOKEN_EXPIRY_BUFFER_MS = 60_000;
-export const isExpiringSoon = (cred, bufferMs = TOKEN_EXPIRY_BUFFER_MS) => cred.expires_at < Date.now() + bufferMs;
-export const toCredentials = (resp) => ({
-    access_token: resp.access_token,
-    refresh_token: resp.refresh_token,
-    expires_at: Date.now() + resp.expires_in * 1000,
-    user: resp.user,
-});
-function mapTransportError(err, url) {
-    const cause = err;
-    const code = cause?.code ?? cause?.cause?.code;
-    if (cause?.name === 'AbortError' || code === 'ABORT_ERR') {
-        return new Generic({ message: 'request aborted', details: { url } });
-    }
-    if (code === 'ENOTFOUND' || code === 'EAI_AGAIN') {
-        let host = url;
-        try {
-            host = new URL(url).host;
-        }
-        catch { }
-        return new NetworkDns({
-            host,
-            message: 'dns lookup failed',
-            details: { url },
-        });
-    }
-    if (code === 'ECONNREFUSED') {
-        return new NetworkRefused({ url, message: 'connection refused' });
-    }
-    if (code === 'ETIMEDOUT' || code === 'UND_ERR_CONNECT_TIMEOUT') {
-        return new NetworkTimeout({ url, message: 'network request timed out' });
-    }
-    return new Generic({
-        message: cause?.message ?? `request failed: ${url}`,
-        details: { url, cause: code },
-    });
-}
-function jsonResponseBody(res) {
-    return res.json.pipe(Effect.catchAll(() => Effect.succeed(null)));
-}
-function makeAuthService(http, config) {
-    const sendJson = (url, method, body, headers) => Effect.gen(function* () {
-        let req = HttpClientRequest.make(method)(url, { headers });
-        if (body !== undefined && method !== 'GET') {
-            req = yield* HttpClientRequest.bodyJson(req, body).pipe(Effect.mapError((err) => new Generic({ message: 'failed to encode body', cause: err })));
-        }
-        return yield* http.execute(req).pipe(
-        // ResponseError is just a status filter — we don't apply filterStatusOk,
-        // so transport-level failures (RequestError) are what we map here.
-        Effect.catchTag('RequestError', (rerr) => Effect.fail(mapTransportError(rerr.cause ?? rerr, url))), Effect.catchTag('ResponseError', (rerr) => Effect.succeed(rerr.response)));
-    });
-    const probe = (apiUrl) => Effect.gen(function* () {
-        const candidates = [
-            ...SUPPORTED_API_VERSIONS.map((v) => ({
-                prefix: `/api/v${v}/auth`,
-                version: v,
-            })),
-            { prefix: '/auth', version: null },
-        ];
-        let lastTransport = null;
-        const attempted = [];
-        for (const cand of candidates) {
-            const probeUrl = `${apiUrl}${cand.prefix}/ok`;
-            const result = yield* sendJson(probeUrl, 'GET', undefined, {
-                accept: 'application/json',
-            }).pipe(Effect.either);
-            if (result._tag === 'Left') {
-                lastTransport = result.left;
-                continue;
-            }
-            const res = result.right;
-            attempted.push({ url: probeUrl, status: res.status });
-            if (res.status >= 200 && res.status < 300) {
-                const apiVersion = cand.version ?? SUPPORTED_API_VERSIONS[0];
-                const apiBase = cand.prefix === '/auth' ? apiUrl : `${apiUrl}/api/v${apiVersion}`;
-                const authBase = `${apiUrl}${cand.prefix}`;
-                return { apiUrl, apiBase, authBase, apiVersion };
-            }
-        }
-        if (lastTransport && lastTransport._tag !== 'Generic') {
-            return yield* Effect.fail(lastTransport);
-        }
-        const tried = attempted.length > 0
-            ? attempted.map((a) => `${a.url} → ${a.status}`).join(', ')
-            : 'no responses';
-        return yield* Effect.fail(new AuthProbe({
-            message: 'cannot detect auth endpoint',
-            hint: `tried: ${tried}. supply the site root (e.g. https://blog.example.com), not the API path. verify the server is reachable and runs a supported API version (${SUPPORTED_API_VERSIONS.join(', ')}).`,
-        }));
-    });
-    const requestDeviceCode = (authBase, clientId, scope = 'openid profile email') => Effect.gen(function* () {
-        const url = `${authBase}/device/code`;
-        const res = yield* sendJson(url, 'POST', { client_id: clientId, scope }, { 'content-type': 'application/json', accept: 'application/json' }).pipe(Effect.mapError((err) => {
-            if (err._tag === 'Generic')
-                return err;
-            // transport errors collapse into AuthDenied — matches legacy where
-            // network failure during device-code request surfaces as auth.denied.
-            return new AuthDenied({
-                message: 'device code request failed',
-                details: err,
-            });
-        }));
-        const body = yield* jsonResponseBody(res);
-        if (res.status >= 200 && res.status < 300) {
-            return body;
-        }
-        return yield* Effect.fail(new AuthDenied({
-            message: `device code request failed (${res.status})`,
-            details: body,
-        }));
-    });
-    const pollDeviceToken = (authBase, clientId, deviceCode, opts) => Effect.tryPromise({
-        try: async () => {
-            const url = `${authBase}/device/token`;
-            const deadline = Date.now() + opts.expiresInSec * 1000;
-            let intervalMs = Math.max(1, opts.intervalSec) * 1000;
-            while (Date.now() < deadline) {
-                if (opts.signal?.aborted) {
-                    throw new AuthDenied({ message: 'aborted by user' });
-                }
-                await sleep(intervalMs, opts.signal);
-                const res = await fetchJson(url, {
-                    method: 'POST',
-                    headers: {
-                        'content-type': 'application/json',
-                        accept: 'application/json',
-                    },
-                    body: JSON.stringify({
-                        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
-                        device_code: deviceCode,
-                        client_id: clientId,
-                    }),
-                    signal: opts.signal,
-                });
-                const body = res.body;
-                if (res.ok && body?.access_token) {
-                    return body;
-                }
-                const err = body?.error;
-                if (err === 'authorization_pending') {
-                    opts.onTick?.('pending');
-                    continue;
-                }
-                if (err === 'slow_down') {
-                    intervalMs += 5000;
-                    opts.onTick?.('slow_down');
-                    continue;
-                }
-                if (err === 'access_denied') {
-                    throw new AuthDenied({
-                        message: 'user denied the authorization request',
-                    });
-                }
-                if (err === 'expired_token') {
-                    throw new AuthExpired({
-                        message: 'device code expired before authorization completed',
-                        hint: 'run `mxs auth login` again',
-                    });
-                }
-                throw new AuthDenied({
-                    message: `device token request failed (${res.status})`,
-                    details: body,
-                });
-            }
-            throw new AuthExpired({
-                message: 'device authorization timed out',
-                hint: 'run `mxs auth login` again',
-            });
-        },
-        catch: (err) => {
-            if (err instanceof AuthDenied)
-                return err;
-            if (err instanceof AuthExpired)
-                return err;
-            return new Generic({
-                message: 'device token polling failed',
-                cause: err,
-            });
-        },
-    });
-    const refresh = (authBase, clientId, cred) => Effect.tryPromise({
-        try: async () => {
-            if (!cred.refresh_token) {
-                return refreshSessionToken(authBase, cred);
-            }
-            const res = await fetchJson(`${authBase}/token`, {
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json',
-                    accept: 'application/json',
-                },
-                body: JSON.stringify({
-                    grant_type: 'refresh_token',
-                    refresh_token: cred.refresh_token,
-                    client_id: clientId,
-                }),
-            });
-            if (!res.ok)
-                return null;
-            const body = res.body;
-            if (!body?.access_token)
-                return null;
-            return {
-                access_token: body.access_token,
-                refresh_token: body.refresh_token ?? cred.refresh_token,
-                expires_at: Date.now() + body.expires_in * 1000,
-                user: body.user ?? cred.user,
-            };
-        },
-        catch: (err) => new Generic({ message: 'refresh failed', cause: err }),
-    });
-    const ensureFresh = (resolved) => Effect.gen(function* () {
-        if (!resolved.profileName) {
-            return yield* Effect.fail(new AuthMissing({
-                message: 'not authenticated',
-                hint: 'run `mxs auth login`',
-            }));
-        }
-        const cred = yield* config.readProfileCredentials(resolved.profileName);
-        if (!cred) {
-            return yield* Effect.fail(new AuthMissing({
-                message: 'not authenticated',
-                hint: 'run `mxs auth login`',
-            }));
-        }
-        if (!isExpiringSoon(cred))
-            return cred;
-        const refreshed = yield* refresh(resolved.authBase, resolved.clientId, cred);
-        if (!refreshed)
-            return cred;
-        yield* config.writeProfileCredentials(resolved.profileName, refreshed);
-        return refreshed;
-    });
-    const login = () => Effect.fail(new Generic({
-        message: 'Auth.login is a Wave 2 surface; compose probe + requestDeviceCode + pollDeviceToken explicitly',
-    }));
-    const logout = (name) => Effect.gen(function* () {
-        const target = name ??
-            (yield* config.resolve().pipe(Effect.map((r) => r.profileName), Effect.catchAll(() => Effect.succeed(null))));
-        if (!target)
-            return;
-        yield* config.deleteProfileCredentials(target);
-    });
-    const whoami = Effect.gen(function* () {
-        const resolved = yield* config.resolve().pipe(Effect.mapError((err) => new Generic({
-            message: 'failed to resolve config',
-            cause: err,
-        })));
-        const fresh = yield* ensureFresh(resolved);
-        return {
-            id: fresh.user?.id,
-            email: fresh.user?.email,
-            name: fresh.user?.name,
-            expiresAt: fresh.expires_at,
-        };
-    });
-    const status = Effect.gen(function* () {
-        const resolved = yield* config.resolve().pipe(Effect.mapError((err) => new Generic({
-            message: 'failed to resolve config',
-            cause: err,
-        })));
-        if (!resolved.profileName) {
-            return {
-                authenticated: false,
-                apiUrl: resolved.apiUrl,
-                profile: null,
-            };
-        }
-        const cred = yield* config.readProfileCredentials(resolved.profileName);
-        if (!cred) {
-            return {
-                authenticated: false,
-                apiUrl: resolved.apiUrl,
-                profile: resolved.profileName,
-            };
-        }
-        return {
-            authenticated: true,
-            apiUrl: resolved.apiUrl,
-            profile: resolved.profileName,
-            expiresAt: cred.expires_at,
-            user: {
-                id: cred.user?.id,
-                email: cred.user?.email,
-                name: cred.user?.name,
-                expiresAt: cred.expires_at,
-            },
-        };
-    });
-    const enrichUser = (profileName, authBase, cred) => Effect.gen(function* () {
-        if (cred.user?.id || cred.user?.email || cred.user?.name)
-            return cred;
-        const fetched = yield* Effect.tryPromise({
-            try: () => fetchSessionUser(authBase, cred),
-            catch: () => null,
-        }).pipe(Effect.catchAll(() => Effect.succeed(null)));
-        if (!fetched)
-            return cred;
-        const updated = { ...cred, user: fetched };
-        yield* config.writeProfileCredentials(profileName, updated);
-        return updated;
-    });
-    return {
-        probe,
-        requestDeviceCode,
-        pollDeviceToken,
-        refresh,
-        login,
-        logout,
-        whoami,
-        status,
-        ensureFresh,
-        enrichUser,
-    };
-}
-async function fetchJson(url, init) {
-    const res = await globalThis.fetch(url, init);
-    let body;
-    try {
-        body = await res.json();
-    }
-    catch {
-        body = null;
-    }
-    return { ok: res.ok, status: res.status, headers: res.headers, body };
-}
-function sleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal?.aborted)
-            return reject(new Error('aborted'));
-        const timer = setTimeout(() => {
-            if (signal)
-                signal.removeEventListener('abort', onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(new Error('aborted'));
-        };
-        signal?.addEventListener('abort', onAbort, { once: true });
-    });
-}
-async function fetchSessionUser(authBase, cred) {
-    const res = await globalThis.fetch(`${authBase}/get-session`, {
-        method: 'GET',
-        headers: {
-            accept: 'application/json',
-            authorization: `Bearer ${cred.access_token}`,
-        },
-    });
-    if (!res.ok)
-        return null;
-    const body = (await res.json().catch(() => null));
-    return body?.user ?? null;
-}
-async function refreshSessionToken(authBase, cred) {
-    const res = await globalThis.fetch(`${authBase}/get-session`, {
-        method: 'GET',
-        headers: {
-            accept: 'application/json',
-            authorization: `Bearer ${cred.access_token}`,
-        },
-    });
-    if (!res.ok)
-        return null;
-    const body = (await res.json().catch(() => null));
-    const expiresAt = normalizeExpiresAt(body?.session?.expiresAt);
-    if (!expiresAt || expiresAt <= cred.expires_at)
-        return null;
-    return {
-        access_token: res.headers.get('set-auth-token') ?? cred.access_token,
-        refresh_token: cred.refresh_token,
-        expires_at: expiresAt,
-        user: body?.user ?? cred.user,
-    };
-}
-function normalizeExpiresAt(value) {
-    if (value === undefined)
-        return null;
-    const time = value instanceof Date
-        ? value.getTime()
-        : typeof value === 'number'
-            ? value
-            : new Date(value).getTime();
-    return Number.isFinite(time) ? time : null;
-}

package/dist/src/services/Backup.d.ts

@@ -1,8 +0,0 @@
-import { Context, Layer } from 'effect';
-export interface BackupService {
-}
-declare const Backup_base: Context.TagClass<Backup, "Backup", BackupService>;
-export declare class Backup extends Backup_base {
-    static Default: Layer.Layer<Backup>;
-}
-export {};

package/dist/src/services/Backup.js

@@ -1,4 +0,0 @@
-import { Context, Effect, Layer } from 'effect';
-export class Backup extends Context.Tag('Backup')() {
-    static Default = Layer.effect(Backup, Effect.die('Backup service is a v2 placeholder'));
-}

package/dist/src/services/Cache.d.ts

@@ -1,8 +0,0 @@
-import { Context, Layer } from 'effect';
-export interface CacheService {
-}
-declare const Cache_base: Context.TagClass<Cache, "Cache", CacheService>;
-export declare class Cache extends Cache_base {
-    static Default: Layer.Layer<Cache>;
-}
-export {};

package/dist/src/services/Cache.js

@@ -1,4 +0,0 @@
-import { Context, Effect, Layer } from 'effect';
-export class Cache extends Context.Tag('Cache')() {
-    static Default = Layer.effect(Cache, Effect.die('Cache service is a v3 placeholder'));
-}

package/dist/src/services/Comment.d.ts

@@ -1,48 +0,0 @@
-import { Context, Effect, Layer } from 'effect';
-import type { ApiError } from './Api';
-import { Api } from './Api';
-export type CommentStateName = 'unread' | 'read' | 'junk';
-export declare const COMMENT_STATE_NAMES: readonly CommentStateName[];
-export declare const stateNameToCode: (s: CommentStateName) => number;
-export declare const stateCodeToName: (n: number) => CommentStateName | undefined;
-export interface CommentListOptions {
-    readonly page?: number;
-    readonly size?: number;
-    readonly state?: CommentStateName;
-    readonly all?: boolean;
-}
-export interface CommentListResponse {
-    readonly data: ReadonlyArray<unknown>;
-    readonly pagination?: Record<string, unknown>;
-    readonly readers?: Record<string, unknown>;
-}
-export interface CommentBatchFilter {
-    readonly currentState?: CommentStateName;
-}
-export interface CommentReplyInput {
-    readonly text: string;
-    readonly isWhispers?: boolean;
-}
-export interface CommentService {
-    readonly list: (opts: CommentListOptions) => Effect.Effect<CommentListResponse, ApiError>;
-    readonly get: (id: string) => Effect.Effect<unknown, ApiError>;
-    /** Reply to a comment as the owner. Routes through `/comments/owner-reply/:id`. */
-    readonly reply: (parentId: string, body: CommentReplyInput) => Effect.Effect<unknown, ApiError>;
-    /** Mark one or more comments as read (state=1). Routes through batch endpoint. */
-    readonly approve: (ids: ReadonlyArray<string>) => Effect.Effect<void, ApiError>;
-    /** Mark one or more comments as junk (state=2). Routes through batch endpoint. */
-    readonly reject: (ids: ReadonlyArray<string>) => Effect.Effect<void, ApiError>;
-    /** Soft-delete one or more comments. Routes through batch endpoint. */
-    readonly delete: (ids: ReadonlyArray<string>) => Effect.Effect<void, ApiError>;
-    /** Approve all comments matching `filter` (optional currentState). */
-    readonly approveAll: (filter: CommentBatchFilter) => Effect.Effect<void, ApiError>;
-    /** Reject all comments matching `filter` (optional currentState). */
-    readonly rejectAll: (filter: CommentBatchFilter) => Effect.Effect<void, ApiError>;
-    /** Soft-delete all comments matching `filter` (optional currentState). */
-    readonly deleteAll: (filter: CommentBatchFilter) => Effect.Effect<void, ApiError>;
-}
-declare const Comment_base: Context.TagClass<Comment, "Comment", CommentService>;
-export declare class Comment extends Comment_base {
-    static Default: Layer.Layer<Comment, never, Api>;
-}
-export {};

package/dist/src/services/Comment.js

@@ -1,102 +0,0 @@
-import { Context, Effect, Layer } from 'effect';
-import { Api } from './Api';
-export const COMMENT_STATE_NAMES = [
-    'unread',
-    'read',
-    'junk',
-];
-const stateToCode = {
-    unread: 0,
-    read: 1,
-    junk: 2,
-};
-const codeToState = {
-    0: 'unread',
-    1: 'read',
-    2: 'junk',
-};
-export const stateNameToCode = (s) => stateToCode[s];
-export const stateCodeToName = (n) => codeToState[n];
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-const mergeListResponses = (responses) => {
-    const data = [];
-    const readers = {};
-    let total = 0;
-    for (const r of responses) {
-        if (Array.isArray(r.data))
-            data.push(...r.data);
-        if (r.readers)
-            Object.assign(readers, r.readers);
-        const t = r.pagination && typeof r.pagination.total === 'number'
-            ? r.pagination.total
-            : 0;
-        total += t;
-    }
-    return {
-        data,
-        pagination: { total, size: data.length, page: 1, totalPages: 1 },
-        readers,
-    };
-};
-const makeService = (api) => {
-    const requestList = (state, page, size) => api.request('/comments', {
-        query: { page, size, state: stateNameToCode(state) },
-    });
-    const patchBatchState = (body) => Effect.asVoid(api.request('/comments/batch/state', {
-        method: 'PATCH',
-        body,
-    }));
-    const deleteBatch = (body) => Effect.asVoid(api.request('/comments/batch', {
-        method: 'DELETE',
-        body,
-    }));
-    return {
-        list: (opts) => {
-            if (opts.all) {
-                return Effect.all(COMMENT_STATE_NAMES.map((s) => requestList(s, opts.page, opts.size)), { concurrency: 3 }).pipe(Effect.map(mergeListResponses));
-            }
-            return requestList(opts.state ?? 'unread', opts.page, opts.size);
-        },
-        get: (id) => api.request(`/comments/${id}`),
-        reply: (parentId, body) => api.request(`/comments/owner-reply/${parentId}`, {
-            method: 'POST',
-            body: {
-                text: body.text,
-                ...(body.isWhispers !== undefined
-                    ? { isWhispers: body.isWhispers }
-                    : {}),
-            },
-        }),
-        approve: (ids) => patchBatchState({ ids: [...ids], state: stateToCode.read }),
-        reject: (ids) => patchBatchState({ ids: [...ids], state: stateToCode.junk }),
-        delete: (ids) => deleteBatch({ ids: [...ids] }),
-        approveAll: (filter) => patchBatchState({
-            all: true,
-            state: stateToCode.read,
-            currentState: filter.currentState !== undefined
-                ? stateNameToCode(filter.currentState)
-                : undefined,
-        }),
-        rejectAll: (filter) => patchBatchState({
-            all: true,
-            state: stateToCode.junk,
-            currentState: filter.currentState !== undefined
-                ? stateNameToCode(filter.currentState)
-                : undefined,
-        }),
-        deleteAll: (filter) => deleteBatch({
-            all: true,
-            state: filter.currentState !== undefined
-                ? stateNameToCode(filter.currentState)
-                : undefined,
-        }),
-    };
-};
-export class Comment extends Context.Tag('Comment')() {
-    static Default = Layer.effect(Comment, Effect.gen(function* () {
-        const api = yield* Api;
-        return makeService(api);
-    }));
-}

package/dist/src/services/Config.d.ts

@@ -1,95 +0,0 @@
-import { FileSystem, Path } from '@effect/platform';
-import { Context, Effect, Layer } from 'effect';
-import type { ConfigMigrationFailed } from '../domain/errors';
-import { ConfigMissingApiUrl, Generic, ProfileNotFound } from '../domain/errors';
-export interface ConfigShape {
-    readonly api_url?: string;
-    readonly api_version?: number;
-    readonly production?: boolean;
-}
-export interface CredentialsShape {
-    readonly access_token: string;
-    readonly refresh_token?: string;
-    readonly expires_at: number;
-    readonly user?: {
-        readonly id?: string;
-        readonly email?: string;
-        readonly name?: string;
-    };
-}
-export interface ResolvedConfig {
-    readonly apiUrl: string;
-    readonly apiBase: string;
-    readonly authBase: string;
-    readonly apiVersion: number;
-    readonly clientId: string;
-    readonly token?: string;
-    readonly apiKey?: string;
-    readonly configPath: string;
-    readonly credentialsPath: string;
-    readonly profileName: string | null;
-    readonly isProduction: boolean;
-    readonly profileExplicit: boolean;
-    readonly urlOverridden: boolean;
-}
-export interface StoreOverrides {
-    readonly apiUrl?: string;
-    readonly token?: string;
-    readonly apiKey?: string;
-    readonly profile?: string;
-}
-export declare const DEFAULT_CLIENT_ID = "mxs-cli";
-export declare const LEGACY_CONFIG_FIELDS: readonly ["api_base", "auth_base", "client_id"];
-export declare const LOCAL_DEV_ENV = "MXS_CLI_LOCAL_DEV";
-export declare const LOCAL_DEV_API_URL_ENV = "MXS_CLI_LOCAL_DEV_API_URL";
-export declare const LOCAL_DEV_PROFILE_NAME = "local-dev";
-export declare const LOCAL_DEV_API_URL_DEFAULT = "http://localhost:2333";
-export interface LocalDevProfileInput {
-    readonly profileOverride?: string;
-    readonly envProfile?: string;
-    readonly apiUrlOverride?: string;
-    readonly envApiUrl?: string;
-    readonly currentProfile?: string | null;
-}
-export declare const isLocalDevEnabled: () => boolean;
-export declare const getLocalDevApiUrl: () => string;
-export declare const shouldUseLocalDev: (input: LocalDevProfileInput) => boolean;
-export declare const stripLegacyConfigFields: (cfg: Record<string, unknown>) => ConfigShape;
-export interface ParsedApiUrl {
-    readonly baseUrl: string;
-    readonly apiVersion?: number;
-}
-export declare const parseApiUrl: (input: string) => Effect.Effect<ParsedApiUrl, ConfigMissingApiUrl>;
-export declare const normalizeApiUrl: (input: string) => Effect.Effect<string, ConfigMissingApiUrl>;
-export interface ConfigService {
-    readonly getConfigDir: Effect.Effect<string>;
-    readonly getProfilesDir: Effect.Effect<string>;
-    readonly getProfileDir: (name: string) => Effect.Effect<string>;
-    readonly getProfileConfigPath: (name: string) => Effect.Effect<string>;
-    readonly getProfileCredentialsPath: (name: string) => Effect.Effect<string>;
-    readonly getCurrentPath: Effect.Effect<string>;
-    readonly getLegacyConfigPath: Effect.Effect<string>;
-    readonly getLegacyCredentialsPath: Effect.Effect<string>;
-    readonly readProfileConfig: (name: string) => Effect.Effect<ConfigShape, ProfileNotFound | Generic>;
-    readonly writeProfileConfig: (name: string, cfg: ConfigShape) => Effect.Effect<void, Generic>;
-    readonly updateProfileConfig: (name: string, update: (prev: ConfigShape) => ConfigShape) => Effect.Effect<ConfigShape, ProfileNotFound | Generic>;
-    readonly readProfileCredentials: (name: string) => Effect.Effect<CredentialsShape | null, Generic>;
-    readonly writeProfileCredentials: (name: string, creds: CredentialsShape) => Effect.Effect<void, Generic>;
-    readonly deleteProfileCredentials: (name: string) => Effect.Effect<void, Generic>;
-    readonly readLegacyConfig: Effect.Effect<ConfigShape, Generic>;
-    readonly readLegacyConfigRaw: Effect.Effect<Record<string, unknown> | null, Generic>;
-    readonly readLegacyCredentialsRaw: Effect.Effect<Record<string, unknown> | null, Generic>;
-    readonly deleteLegacyConfig: Effect.Effect<void, Generic>;
-    readonly deleteLegacyCredentials: Effect.Effect<void, Generic>;
-    readonly readCurrent: Effect.Effect<string | null, Generic>;
-    readonly writeCurrent: (name: string) => Effect.Effect<void, Generic>;
-    readonly listProfileDirs: Effect.Effect<readonly string[], Generic>;
-    readonly profileExists: (name: string) => Effect.Effect<boolean, Generic>;
-    readonly removeProfileDir: (name: string) => Effect.Effect<void, Generic>;
-    readonly resolve: (overrides?: StoreOverrides) => Effect.Effect<ResolvedConfig, ConfigMissingApiUrl | ProfileNotFound | ConfigMigrationFailed | Generic>;
-}
-declare const Config_base: Context.TagClass<Config, "Config", ConfigService>;
-export declare class Config extends Config_base {
-    static Default: Layer.Layer<Config, never, FileSystem.FileSystem | Path.Path>;
-}
-export {};