@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/services/Auth.js

@@ -0,0 +1,402 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,95 @@
+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 {};