import * as Effect from "effect/Effect"; import * as Option from "effect/Option"; import * as Redacted from "effect/Redacted"; import { AuthError } from "../Auth/AuthProvider.ts"; import { CredentialsStore } from "../Auth/Credentials.ts"; import { inspectProvider, type ProviderConnection } from "../Auth/Inspect.ts"; import { withProfileCredentialsLock } from "../Auth/Lock.ts"; import { ProfileStore, reloadProviderConfig } from "../Auth/Profile.ts"; import { emit } from "../Events.ts"; import type { Interaction } from "../Interaction.ts"; import { collectAuthProviders } from "./AuthRegistry.ts"; import { DEFAULT_ENTRYPOINT, type Target } from "./Entrypoint.ts"; import { AlchemistInvalidInput, AlchemistNotFound } from "./Errors.ts"; /** Which project/profile pair a provider-scoped operation resolves against. */ export interface ProviderContext extends Target { readonly profile: string; } export interface ProfileSummary { readonly name: string; readonly active: boolean; readonly providers: ReadonlyArray<{ readonly name: string; readonly method: string; }>; } export type { ProviderConnection } from "../Auth/Inspect.ts"; export interface ProfileSnapshot { readonly name: string; readonly active: boolean; readonly providers: ReadonlyArray; } export interface ConfigureField { readonly name: string; readonly label: string; readonly secret: boolean; readonly required: boolean; readonly description?: string; readonly placeholder?: string; } export interface ConfigureMethod { readonly method: string; readonly label: string; readonly fields: ReadonlyArray; } export interface AuthProviderDescriptor { readonly name: string; readonly connected: boolean; readonly configureMethods: ReadonlyArray; readonly supportsRefresh: boolean; readonly supportsLogout: boolean; } export interface ConfigureInput extends ProviderContext { readonly provider: string; readonly action: "add" | "reconfigure"; readonly method?: string; readonly values?: Readonly>>; } /** * Every auth provider reachable from the given project: the built-ins plus * whatever the user's stack module registers. */ const registry = (input: ProviderContext) => collectAuthProviders({ main: input.entrypoint ?? DEFAULT_ENTRYPOINT, envFile: Option.fromNullishOr(input.envFile), profile: input.profile, }); /** The effective profile and how it was selected. */ export const current = Effect.fn("Alchemist.profile.current")(function* () { return yield* (yield* ProfileStore).current; }); /** Every profile with its connected providers, active profile first. */ export const list = Effect.fn("Alchemist.profile.list")(function* () { const profiles = yield* ProfileStore; const [manifest, selected] = yield* Effect.all([profiles.readManifest, profiles.current]); return Object.entries(manifest.profiles) .sort(([a], [b]) => (a === "default" ? -1 : b === "default" ? 1 : a.localeCompare(b))) .map(([name, profile]): ProfileSummary => ({ name, active: name === selected.name, providers: Object.entries(profile.providers) .sort(([a], [b]) => a.localeCompare(b)) .map(([name, config]) => ({ name, method: config.method ?? "unknown", })), })); }); /** One profile with the live status of each connected provider. */ export const get = Effect.fn("Alchemist.profile.get")(function* (input: { readonly name: string; readonly includeProviderStatus?: boolean; readonly entrypoint?: string; readonly envFile?: string; }) { const includeProviderStatus = input.includeProviderStatus ?? true; const profiles = yield* ProfileStore; const [profile, selected] = yield* Effect.all([ profiles.getProfile(input.name), profiles.current, ]); if (profile === undefined) { return yield* new AlchemistNotFound({ kind: "profile", id: input.name }); } // Skipping the status probe is what makes `profile list` fast: it // reaches no provider APIs, so every connection reads as connected. const registered = includeProviderStatus ? yield* registry({ profile: input.name, entrypoint: input.entrypoint, envFile: input.envFile, }) : {}; const entries = Object.entries(profile.providers).sort(([a], [b]) => a.localeCompare(b)); return { name: input.name, active: selected.name === input.name, providers: yield* Effect.forEach( entries, ([provider, config]): Effect.Effect => includeProviderStatus ? inspectProvider(input.name, provider, config, registered, (updated) => profiles.setProviderConfig(input.name, provider, updated).pipe( Effect.mapError((cause) => AuthError.make({ message: `Could not persist repaired ${provider} credentials for profile '${input.name}'.`, cause, }), ), ), ).pipe(Effect.provideService(ProfileStore, profiles)) : Effect.succeed({ name: provider, method: config.method ?? "unknown", status: "connected", details: [], }), ), } satisfies ProfileSnapshot; }); export const create = Effect.fn("Alchemist.profile.create")(function* (input: { readonly name: string; }) { yield* (yield* ProfileStore).createProfile(input.name); return yield* get({ name: input.name }); }); export const rename = Effect.fn("Alchemist.profile.rename")(function* (input: { readonly name: string; readonly newName: string; }) { yield* (yield* ProfileStore).renameProfile(input.name, input.newName); return yield* get({ name: input.newName }); }); /** Delete a profile and every credential stored for it. */ export const deleteProfile = Effect.fn("Alchemist.profile.delete")(function* (input: { readonly name: string; }) { const profiles = yield* ProfileStore; const credentials = yield* CredentialsStore; return yield* withProfileCredentialsLock( input.name, Effect.gen(function* () { const deleted = yield* profiles.deleteProfile(input.name); if (!deleted) { return yield* new AlchemistNotFound({ kind: "profile", id: input.name }); } yield* credentials.deleteProfile(input.name); return { name: input.name, credentialsDeleted: true } as const; }), ); }); /** Every registered auth provider and how it can be configured. */ export const providers = Effect.fn("Alchemist.profile.providers")(function* (input: { readonly profile?: string; readonly entrypoint?: string; readonly envFile?: string; }) { const profiles = yield* ProfileStore; const profile = input.profile ?? (yield* profiles.current).name; const stored = yield* profiles.ensureProfile(profile); const registered = yield* registry({ ...input, profile }); return Object.values(registered) .sort((a, b) => a.name.localeCompare(b.name)) .map((provider): AuthProviderDescriptor => ({ name: provider.name, connected: provider.name in stored.providers, configureMethods: (provider.configureMethods ?? []).map((method) => ({ method: method.method, label: method.method, fields: method.fields.map((field) => ({ name: field.name, label: field.label, secret: field.secret ?? false, required: !(field.optional ?? false), description: field.description, placeholder: field.placeholder, })), })), supportsRefresh: true, supportsLogout: true, })); }); /** The configure methods (and fields) one provider accepts. */ export const configureForm = Effect.fn("Alchemist.profile.configureForm")(function* (input: { readonly profile: string; readonly provider: string; readonly method?: string; }) { const registered = yield* providers({ profile: input.profile }); const provider = registered.find(({ name }) => name === input.provider); if (provider === undefined) { return yield* new AlchemistNotFound({ kind: "provider", id: input.provider }); } return input.method === undefined ? provider.configureMethods : provider.configureMethods.filter(({ method }) => method === input.method); }); /** * Connect or reconfigure a provider in a profile. Reported through * the `provider.configure.started` event; interactive providers drive * their own prompts. */ export const configure = Effect.fn("Alchemist.profile.configure")(function* ( input: ConfigureInput, ) { yield* emit({ type: "provider.configure.started", provider: input.provider, }); const profiles = yield* ProfileStore; const stored = yield* profiles.ensureProfile(input.profile); const provider = (yield* registry(input))[input.provider]; if (provider === undefined) { return yield* new AlchemistInvalidInput({ field: "provider", message: `Auth provider '${input.provider}' is not registered. Install the package that provides it.`, }); } const connected = input.provider in stored.providers; if ((input.action === "add" && connected) || (input.action === "reconfigure" && !connected)) { return yield* new AlchemistInvalidInput({ field: "provider", message: `Provider '${input.provider}' is ${connected ? "already" : "not"} connected.`, }); } const config = input.method !== undefined && input.values !== undefined && provider.configureWith !== undefined ? yield* provider.configureWith(input.profile, { method: input.method, values: Object.fromEntries( Object.entries(input.values).map(([key, value]) => [key, Redacted.value(value)]), ), }) : yield* provider.configure( input.profile, connected ? yield* provider .decodeConfig(input.profile, stored.providers[input.provider]!) .pipe(Effect.orElseSucceed(() => undefined)) : undefined, ); yield* profiles.setProviderConfig(input.profile, input.provider, config); yield* emit({ type: "provider.configure.completed", provider: input.provider, }); return yield* get({ name: input.profile, entrypoint: input.entrypoint, envFile: input.envFile, }); }); /** Log a provider out and disconnect it from the profile. */ export const removeProvider = Effect.fn("Alchemist.profile.removeProvider")(function* ( input: ProviderContext & { readonly provider: string; readonly logout?: boolean; }, ) { const profiles = yield* ProfileStore; const stored = yield* profiles.ensureProfile(input.profile); const config = stored.providers[input.provider]; if (config === undefined) { return yield* new AlchemistNotFound({ kind: "provider", id: input.provider }); } const provider = (yield* registry(input))[input.provider]; let logout: "completed" | "skipped-invalid-config" | "unavailable" = "unavailable"; if (provider !== undefined) { const decoded = yield* provider.decodeConfig(input.profile, config).pipe(Effect.option); if (Option.isSome(decoded)) { if (input.logout ?? true) yield* provider.logout(input.profile, decoded.value); logout = "completed"; } else logout = "skipped-invalid-config"; } yield* profiles.deleteProviderConfig(input.profile, input.provider); return { profile: input.profile, provider: input.provider, logout }; }); /** * Re-run login for connected providers without reconfiguring them. Each * provider is reported as the `provider.refresh.started` event. */ export const refresh = Effect.fn("Alchemist.profile.refresh")(function* ( input: ProviderContext & { readonly providers?: ReadonlyArray; }, ) { const profiles = yield* ProfileStore; const stored = yield* profiles.ensureProfile(input.profile); const registered = yield* registry(input); const connected = Object.keys(stored.providers).sort(); const requested: Array = []; for (const requestedName of input.providers ?? []) { // `--provider aws` resolves to the connected `AWS`. const name = connected.find((name) => name.toLowerCase() === requestedName.toLowerCase()); if (name === undefined || registered[name] === undefined) { const available = connected.filter((name) => registered[name] !== undefined); return yield* new AlchemistInvalidInput({ field: "providers", message: `Provider '${requestedName}' is not connected to profile '${input.profile}'. ` + (available.length === 0 ? "No providers are connected." : `Connected providers: ${available.join(", ")}.`), }); } if (!requested.includes(name)) requested.push(name); } if (requested.length === 0) requested.push(...connected); for (const name of requested) { const config = stored.providers[name]; const provider = registered[name]; if (config === undefined || provider === undefined) { return yield* new AlchemistInvalidInput({ field: "providers", message: `Provider '${name}' is not connected or registered.`, }); } yield* emit({ type: "provider.refresh.started", provider: name }); const refreshed = yield* provider.login( input.profile, yield* provider.decodeConfig(input.profile, config), (updated) => profiles.setProviderConfig(input.profile, name, updated).pipe( Effect.mapError((cause) => AuthError.make({ message: `Could not persist refreshed ${name} credentials for profile '${input.profile}'.`, cause, }), ), ), reloadProviderConfig(profiles, provider, input.profile), ); if (refreshed !== undefined) { yield* profiles.setProviderConfig(input.profile, name, refreshed); } yield* emit({ type: "provider.refresh.completed", provider: name }); } return yield* get({ name: input.profile, entrypoint: input.entrypoint, envFile: input.envFile, }); });