import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Redacted from "effect/Redacted"; import * as Schema from "effect/Schema"; import path from "pathe"; import { writeFileAtomic } from "../Util/AtomicFile.ts"; import { profileCommandHint } from "../Util/interactive.ts"; import { AuthError } from "./AuthProvider.ts"; import { profileCredentialsDirPath } from "./Paths.ts"; import { validateProfileName } from "./Profile.ts"; export const credentialsFilePath = (profile: string, provider: string) => path.join(profileCredentialsDirPath(profile), `${provider}.json`); /** * Service exposing per-profile credential file helpers. All methods have * `R = never` — the {@link FileSystem.FileSystem} requirement is captured * by {@link CredentialsStoreLive} when the layer is built. * * Reads and writes go through the provider's declared credential schema, so * a hand-edited or corrupted secrets file surfaces as a typed `AuthError` * (with a reconfigure hint) instead of propagating malformed data into API * calls. */ export interface CredentialsStoreService { readonly read: ( profile: string, provider: string, schema: Schema.Codec, ) => Effect.Effect; readonly write: ( profile: string, provider: string, schema: Schema.Codec, credentials: A, ) => Effect.Effect; readonly delete: (profile: string, provider: string) => Effect.Effect; /** * Recursively remove the `~/.alchemy/credentials/{profile}` directory * containing all per-provider secrets for `profile`. No-op if it doesn't exist. */ readonly deleteProfile: (profile: string) => Effect.Effect; /** * The same store rooted at `dirFor(profile)` instead of * `~/.alchemy/credentials/{profile}` — for caches kept beside a profile * rather than with its credentials. */ readonly scoped: (dirFor: (profile: string) => string) => CredentialsStoreService; } export class CredentialsStore extends Context.Service()( "Alchemy::CredentialsStore", ) {} export const CredentialsStoreLive = Layer.effect( CredentialsStore, Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; const make = (dirFor: (profile: string) => string): CredentialsStoreService => { const validateCredentialPath = validateCredentialPathIn(dirFor); const read = (profile: string, provider: string, schema: Schema.Codec) => Effect.gen(function* () { const filePath = yield* validateCredentialPath(profile, provider); const data = yield* fs.readFileString(filePath).pipe( Effect.catchReason("PlatformError", "NotFound", () => Effect.undefined), Effect.mapError((cause) => AuthError.make({ message: `Could not read credentials at '${filePath}'.`, cause, }), ), ); if (data === undefined) return undefined; const json = yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Unknown))(data).pipe( Effect.mapError((cause) => AuthError.make({ message: `Stored credentials at '${filePath}' contain invalid JSON.`, cause, }), ), ); const command = yield* profileCommandHint( `alchemy profile edit --profile ${profile} --reconfigure ${provider}`, ); return yield* Schema.decodeUnknownEffect(schema)(json).pipe( Effect.mapError((cause) => AuthError.make({ message: `Stored credentials at '${filePath}' do not match the expected shape. ` + `Run \`${command}\` to replace them.`, cause, }), ), ); }); const write = ( profile: string, provider: string, schema: Schema.Codec, credentials: A, ) => Effect.gen(function* () { const filePath = yield* validateCredentialPath(profile, provider); const encoded = yield* Schema.encodeEffect(schema)(credentials).pipe( Effect.mapError((cause) => AuthError.make({ message: `Credentials for '${provider}' do not match the declared schema.`, cause, }), ), ); yield* Effect.gen(function* () { const directory = path.dirname(filePath); yield* fs.makeDirectory(directory, { recursive: true }); yield* fs.chmod(directory, 0o700); yield* writeFileAtomic(fs, filePath, JSON.stringify(encoded, null, 2), 0o600); }).pipe( Effect.mapError((cause) => AuthError.make({ message: `Could not write credentials at '${filePath}'.`, cause, }), ), ); }); const remove_ = (profile: string, provider: string): Effect.Effect => validateCredentialPath(profile, provider).pipe( Effect.flatMap((filePath) => fs.remove(filePath).pipe( Effect.catchReason("PlatformError", "NotFound", () => Effect.void), Effect.mapError((cause) => AuthError.make({ message: `Could not delete credentials at '${filePath}'.`, cause, }), ), ), ), ); const deleteProfile = (profile: string) => Effect.gen(function* () { yield* validateProfileName(profile).pipe( Effect.mapError((cause) => AuthError.make({ message: cause.message, cause })), ); yield* fs.remove(dirFor(profile), { recursive: true }).pipe( Effect.catchReason("PlatformError", "NotFound", () => Effect.void), Effect.mapError((cause) => AuthError.make({ message: `Could not delete credentials for profile '${profile}'.`, cause, }), ), ); }); return { read, write, delete: remove_, deleteProfile, scoped: make, } satisfies CredentialsStoreService; }; return make(profileCredentialsDirPath); }), ); const CREDENTIAL_KEY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/; const validateCredentialPathIn = (dirFor: (profile: string) => string) => (profile: string, provider: string) => Effect.gen(function* () { yield* validateProfileName(profile).pipe( Effect.mapError((cause) => AuthError.make({ message: cause.message, cause })), ); if (!CREDENTIAL_KEY_PATTERN.test(provider)) { return yield* AuthError.make({ message: `Invalid credential key '${provider}'.`, }); } return path.join(dirFor(profile), `${provider}.json`); }); export function displayRedacted(r: Redacted.Redacted, visibleChars = 4): string { const raw = Redacted.value(r); if (raw.length <= visibleChars) return "****"; return `${raw.slice(0, visibleChars)}****`; }