import * as NetService from "@t3tools/shared/Net";
import {
OtlpHeadersFromString,
OtlpProtocol,
type SignalExport,
} from "@t3tools/shared/observability";
import * as OtelEnvironment from "@t3tools/shared/otelEnvironment";
import { parsePersistedServerObservabilitySettings } from "@t3tools/shared/serverSettings";
import { DesktopBackendBootstrap, PortSchema } from "@t3tools/contracts";
import * as Config from "effect/Config";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as LogLevel from "effect/LogLevel";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as Redacted from "effect/Redacted";
import * as References from "effect/References";
import * as Schema from "effect/Schema";
import * as SchemaIssue from "effect/SchemaIssue";
import * as SchemaTransformation from "effect/SchemaTransformation";
import { Argument, Flag } from "effect/cli";
import * as CliError from "effect/cli/CliError";
import { readBootstrapEnvelope } from "../bootstrap.ts";
import { resolveServiceLauncherMode } from "../cloud/serviceLauncherClient.ts";
import * as ServerConfig from "../config.ts";
import { expandHomePath, resolveBaseDir } from "../os-jank.ts";
import { isProcessAlive, readPersistedServerRuntimeState } from "../serverRuntimeState.ts";
const modeFlag = Flag.Literals("mode", ServerConfig.RuntimeMode.literals).pipe(
Flag.withDescription("Runtime mode. `desktop` keeps loopback defaults unless overridden."),
Flag.optional,
);
const portFlag = Flag.Int("port").pipe(
Flag.withSchema(PortSchema),
Flag.withDescription("Port for the HTTP/WebSocket server."),
Flag.optional,
);
const hostFlag = Flag.String("host").pipe(
Flag.withDescription("Host/interface to bind (for example 127.0.0.1, 0.0.0.0, or a Tailnet IP)."),
Flag.optional,
);
export const baseDirFlag = Flag.String("base-dir").pipe(
Flag.withDescription(
"Explicit T3 Code data directory; runtime state is stored under userdata (equivalent to T3CODE_HOME).",
),
Flag.optional,
);
const devUrlFlag = Flag.String("dev-url").pipe(
Flag.withSchema(Schema.URLFromString),
Flag.withDescription("Dev web URL to proxy/redirect to (equivalent to VITE_DEV_SERVER_URL)."),
Flag.optional,
);
const noBrowserFlag = Flag.Boolean("no-browser").pipe(
Flag.withDescription("Disable automatic browser opening."),
Flag.optional,
);
const bootstrapFdFlag = Flag.Int("bootstrap-fd").pipe(
Flag.withSchema(Schema.Int),
Flag.withDescription("Read one-time bootstrap secrets from the given file descriptor."),
Flag.optional,
);
const autoBootstrapProjectFromCwdFlag = Flag.Boolean("auto-bootstrap-project-from-cwd").pipe(
Flag.withDescription(
"Create a project for the current working directory on startup when missing.",
),
Flag.optional,
);
const logWebSocketEventsFlag = Flag.Boolean("log-websocket-events").pipe(
Flag.withDescription(
"Emit server-side logs for outbound WebSocket push traffic (equivalent to T3CODE_LOG_WS_EVENTS).",
),
Flag.withAlias("log-ws-events"),
Flag.optional,
);
const tailscaleServeFlag = Flag.Boolean("tailscale-serve").pipe(
Flag.withDescription(
"Configure Tailscale Serve to expose this backend over HTTPS on the Tailnet.",
),
Flag.optional,
);
const tailscaleServePortFlag = Flag.Int("tailscale-serve-port").pipe(
Flag.withSchema(PortSchema),
Flag.withDescription("HTTPS port for Tailscale Serve when --tailscale-serve is enabled."),
Flag.optional,
);
const lanFlag = Flag.Boolean("lan").pipe(
Flag.withDescription(
"Accept connections from your local network and tailnet, not only this machine (equivalent to T3CODE_LAN).",
),
Flag.optional,
);
export const traceFileConfig = Config.String("T3CODE_TRACE_FILE").pipe(
Config.option,
Config.map(Option.getOrUndefined),
);
export const traceMaxFilesConfig = Config.Int("T3CODE_TRACE_MAX_FILES").pipe(
Config.withDefault(10),
);
const EnvServerConfig = Config.all({
logLevel: Config.LogLevel("T3CODE_LOG_LEVEL").pipe(Config.withDefault("Info")),
traceMinLevel: Config.LogLevel("T3CODE_TRACE_MIN_LEVEL").pipe(Config.withDefault("Info")),
traceTimingEnabled: Config.Boolean("T3CODE_TRACE_TIMING_ENABLED").pipe(Config.withDefault(true)),
traceFile: traceFileConfig,
traceMaxBytes: Config.Int("T3CODE_TRACE_MAX_BYTES").pipe(Config.withDefault(10 * 1024 * 1024)),
traceMaxFiles: traceMaxFilesConfig,
traceBatchWindowMs: Config.Int("T3CODE_TRACE_BATCH_WINDOW_MS").pipe(Config.withDefault(1_000)),
otlpTracesUrl: Config.String("T3CODE_OTLP_TRACES_URL").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
otlpMetricsUrl: Config.String("T3CODE_OTLP_METRICS_URL").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
otlpLogsUrl: Config.String("T3CODE_OTLP_LOGS_URL").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
otlpExportIntervalMs: Config.Int("T3CODE_OTLP_EXPORT_INTERVAL_MS").pipe(
Config.withDefault(10_000),
),
otlpHeaders: Config.schema(OtlpHeadersFromString, "T3CODE_OTLP_HEADERS").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
otlpProtocol: Config.schema(OtlpProtocol, "T3CODE_OTLP_PROTOCOL").pipe(
Config.withDefault("http/json"),
),
mode: Config.schema(ServerConfig.RuntimeMode, "T3CODE_MODE").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
port: Config.Port("T3CODE_PORT").pipe(Config.option, Config.map(Option.getOrUndefined)),
host: Config.String("T3CODE_HOST").pipe(Config.option, Config.map(Option.getOrUndefined)),
t3Home: Config.String("T3CODE_HOME").pipe(Config.option, Config.map(Option.getOrUndefined)),
devUrl: Config.URL("VITE_DEV_SERVER_URL").pipe(Config.option, Config.map(Option.getOrUndefined)),
devAllowedOrigins: Config.String("T3CODE_DEV_ALLOWED_ORIGINS").pipe(
Config.withDefault(""),
Config.map((value) =>
value
.split(",")
.map((entry) => entry.trim())
.filter((entry) => entry.length > 0),
),
),
noBrowser: Config.Boolean("T3CODE_NO_BROWSER").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
bootstrapFd: Config.Int("T3CODE_BOOTSTRAP_FD").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
autoBootstrapProjectFromCwd: Config.Boolean("T3CODE_AUTO_BOOTSTRAP_PROJECT_FROM_CWD").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
logWebSocketEvents: Config.Boolean("T3CODE_LOG_WS_EVENTS").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
tailscaleServeEnabled: Config.Boolean("T3CODE_TAILSCALE_SERVE").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
tailscaleServePort: Config.Port("T3CODE_TAILSCALE_SERVE_PORT").pipe(
Config.option,
Config.map(Option.getOrUndefined),
),
lan: Config.Boolean("T3CODE_LAN").pipe(Config.option, Config.map(Option.getOrUndefined)),
});
const DevAuthTokenConfig = Config.Redacted("T3CODE_DEV_AUTH_TOKEN").pipe(
Config.map((token) => Redacted.make(Redacted.value(token).trim())),
Config.mapEffect((token) =>
Redacted.value(token).length === 0 || Redacted.value(token).length >= 32
? Effect.succeed(token)
: Effect.fail(
new Config.ConfigError(
new Schema.SchemaError(
new SchemaIssue.InvalidValue({
message: "T3CODE_DEV_AUTH_TOKEN must contain at least 32 characters.",
}),
),
),
),
),
Config.option,
Config.map(Option.filter((token) => Redacted.value(token).length > 0)),
Config.map(Option.getOrUndefined),
);
export interface CliServerFlags {
readonly mode: Option.Option<ServerConfig.RuntimeMode>;
readonly port: Option.Option<number>;
readonly host: Option.Option<string>;
readonly baseDir: Option.Option<string>;
readonly cwd: Option.Option<string>;
readonly devUrl: Option.Option<URL>;
readonly noBrowser: Option.Option<boolean>;
readonly bootstrapFd: Option.Option<number>;
readonly autoBootstrapProjectFromCwd: Option.Option<boolean>;
readonly logWebSocketEvents: Option.Option<boolean>;
readonly tailscaleServeEnabled: Option.Option<boolean>;
readonly tailscaleServePort: Option.Option<number>;
readonly lan: Option.Option<boolean>;
}
export interface CliAuthLocationFlags {
readonly baseDir: Option.Option<string>;
readonly devUrl?: Option.Option<URL>;
}
export const authLocationFlags = {
baseDir: baseDirFlag,
devUrl: devUrlFlag,
} as const;
export const projectLocationFlags = {
baseDir: baseDirFlag,
} as const;
export const sharedServerCommandFlags = {
mode: modeFlag,
port: portFlag,
host: hostFlag,
baseDir: baseDirFlag,
cwd: Argument.String("cwd").pipe(
Argument.withDescription(
"Working directory for provider sessions (defaults to the current directory).",
),
Argument.optional,
),
devUrl: devUrlFlag,
noBrowser: noBrowserFlag,
bootstrapFd: bootstrapFdFlag,
autoBootstrapProjectFromCwd: autoBootstrapProjectFromCwdFlag,
logWebSocketEvents: logWebSocketEventsFlag,
tailscaleServeEnabled: tailscaleServeFlag,
tailscaleServePort: tailscaleServePortFlag,
lan: lanFlag,
} as const;
const resolveOptionPrecedence = <Value>(
...values: ReadonlyArray<Option.Option<Value>>
): Option.Option<Value> => Option.firstSomeOf(values);
const loadPersistedObservabilitySettings = Effect.fn(function* (settingsPath: string) {
const fs = yield* FileSystem.FileSystem;
const exists = yield* fs.exists(settingsPath).pipe(Effect.orElseSucceed(() => false));
if (!exists) {
return { otlpTracesUrl: undefined, otlpMetricsUrl: undefined, otlpLogsUrl: undefined };
}
const raw = yield* fs.readFileString(settingsPath).pipe(Effect.orElseSucceed(() => ""));
return parsePersistedServerObservabilitySettings(raw);
});
export const resolveServerConfig = Effect.fn("config.resolveServerConfig")(function* (
flags: CliServerFlags,
cliLogLevel: Option.Option<LogLevel.LogLevel>,
options?: {
readonly startupPresentation?: ServerConfig.StartupPresentation;
readonly forceAutoBootstrapProjectFromCwd?: boolean;
readonly rejectRunningServer?: boolean;
readonly selectAutomaticPort?: (
preferred: number,
) => Effect.Effect<number, NetService.NetError | CliError.UserError>;
},
) {
const { findAvailablePort } = yield* NetService.NetService;
const selectAutomaticPort = options?.selectAutomaticPort ?? findAvailablePort;
const path = yield* Path.Path;
const fs = yield* FileSystem.FileSystem;
const env = yield* EnvServerConfig;
const normalizedFlags = {
mode: flags.mode ?? Option.none(),
port: flags.port ?? Option.none(),
host: flags.host ?? Option.none(),
baseDir: flags.baseDir ?? Option.none(),
cwd: flags.cwd ?? Option.none(),
devUrl: flags.devUrl ?? Option.none(),
noBrowser: flags.noBrowser ?? Option.none(),
bootstrapFd: flags.bootstrapFd ?? Option.none(),
autoBootstrapProjectFromCwd: flags.autoBootstrapProjectFromCwd ?? Option.none(),
logWebSocketEvents: flags.logWebSocketEvents ?? Option.none(),
tailscaleServeEnabled: flags.tailscaleServeEnabled ?? Option.none(),
tailscaleServePort: flags.tailscaleServePort ?? Option.none(),
lan: flags.lan ?? Option.none(),
} satisfies CliServerFlags;
const bootstrapFd = Option.getOrUndefined(normalizedFlags.bootstrapFd) ?? env.bootstrapFd;
const bootstrapEnvelope =
bootstrapFd !== undefined
? yield* readBootstrapEnvelope(DesktopBackendBootstrap, bootstrapFd)
: Option.none();
const bootstrap = Option.getOrUndefined(bootstrapEnvelope);
const mode: ServerConfig.RuntimeMode = Option.getOrElse(
resolveOptionPrecedence(
normalizedFlags.mode,
Option.fromUndefinedOr(env.mode),
Option.fromUndefinedOr(bootstrap?.mode),
),
() => "web",
);
const port = yield* Option.match(
resolveOptionPrecedence(
normalizedFlags.port,
Option.fromUndefinedOr(env.port),
Option.fromUndefinedOr(bootstrap?.port),
),
{
onSome: (value) => Effect.succeed(value),
onNone: () => {
if (mode === "desktop") {
return Effect.succeed(ServerConfig.DEFAULT_PORT);
}
return selectAutomaticPort(ServerConfig.DEFAULT_PORT);
},
},
);
const devUrl = Option.getOrElse(
resolveOptionPrecedence(normalizedFlags.devUrl, Option.fromUndefinedOr(env.devUrl)),
() => undefined,
);
const devAuthToken =
mode === "web" && devUrl !== undefined ? yield* DevAuthTokenConfig : undefined;
const explicitBaseDir = resolveOptionPrecedence(
normalizedFlags.baseDir,
Option.fromUndefinedOr(env.t3Home),
).pipe(Option.filter((value) => value.trim().length > 0));
const baseDir = yield* resolveBaseDir(
Option.getOrUndefined(
resolveOptionPrecedence(explicitBaseDir, Option.fromUndefinedOr(bootstrap?.t3Home)),
),
);
const rawCwd = Option.getOrElse(normalizedFlags.cwd, () => process.cwd());
const cwd = path.resolve(yield* expandHomePath(rawCwd.trim()));
const derivedPaths = yield* ServerConfig.deriveServerPaths(baseDir, devUrl, {
baseDirIsExplicit: Option.isSome(explicitBaseDir),
});
// An interactive CLI must not start over a discovered server. Lifetime locking
// and supervisor handoff are separate; this preflight cannot arbitrate two starts.
if (options?.rejectRunningServer && mode === "web") {
const runtime = yield* readPersistedServerRuntimeState(derivedPaths.serverRuntimeStatePath);
// A killed container can leave a record with the new server's own PID.
if (
Option.isSome(runtime) &&
runtime.value.pid > 0 &&
runtime.value.pid !== process.pid &&
isProcessAlive(runtime.value.pid)
) {
return yield* new CliError.UserError({
cause: `A T3 Code server is already running for ${baseDir} (pid ${runtime.value.pid}, ${runtime.value.origin}). Connect to that server, stop it before starting another, or use a different --base-dir.`,
});
}
}
yield* fs.makeDirectory(cwd, { recursive: true });
yield* ServerConfig.ensureServerDirectories(derivedPaths);
const persistedObservabilitySettings = yield* loadPersistedObservabilitySettings(
derivedPaths.settingsPath,
);
const serverTracePath = env.traceFile ?? derivedPaths.serverTracePath;
yield* fs.makeDirectory(path.dirname(serverTracePath), { recursive: true });
const startupPresentation = options?.startupPresentation ?? "browser";
const isHeadlessStartup = startupPresentation === "headless";
const noBrowser = Option.getOrElse(
resolveOptionPrecedence(
isHeadlessStartup ? Option.some(true) : Option.none(),
normalizedFlags.noBrowser,
Option.fromUndefinedOr(env.noBrowser),
Option.fromUndefinedOr(bootstrap?.noBrowser),
),
() => mode === "desktop",
);
const desktopBootstrapToken = bootstrap?.desktopBootstrapToken;
const desktopBootstrapSecret = bootstrap?.desktopBootstrapSecret;
const shellEnvironmentPrepared = bootstrap?.shellEnvironmentPrepared;
const desktopTelemetryFd = bootstrap?.desktopTelemetryFd;
const desktopTelemetryControlFd = bootstrap?.desktopTelemetryControlFd;
const desktopBrowserFd = bootstrap?.desktopBrowserFd;
const desktopBrowserControlFd = bootstrap?.desktopBrowserControlFd;
const resourceMonitorPath = bootstrap?.resourceMonitorPath;
const autoBootstrapProjectFromCwd = Option.getOrElse(
resolveOptionPrecedence(
Option.fromUndefinedOr(options?.forceAutoBootstrapProjectFromCwd),
isHeadlessStartup ? Option.some(false) : Option.none(),
normalizedFlags.autoBootstrapProjectFromCwd,
Option.fromUndefinedOr(env.autoBootstrapProjectFromCwd),
),
() => mode === "web",
);
const logWebSocketEvents = Option.getOrElse(
resolveOptionPrecedence(
normalizedFlags.logWebSocketEvents,
Option.fromUndefinedOr(env.logWebSocketEvents),
),
() => Boolean(devUrl),
);
const tailscaleServeEnabled = Option.getOrElse(
resolveOptionPrecedence(
normalizedFlags.tailscaleServeEnabled,
Option.fromUndefinedOr(env.tailscaleServeEnabled),
Option.fromUndefinedOr(bootstrap?.tailscaleServeEnabled),
),
() => false,
);
const tailscaleServePort = Option.getOrElse(
resolveOptionPrecedence(
normalizedFlags.tailscaleServePort,
Option.fromUndefinedOr(env.tailscaleServePort),
Option.fromUndefinedOr(bootstrap?.tailscaleServePort),
),
() => 443,
);
const staticDir = devUrl ? undefined : yield* ServerConfig.resolveStaticDir();
const explicitHost = resolveOptionPrecedence(
normalizedFlags.host,
Option.fromUndefinedOr(env.host),
Option.fromUndefinedOr(bootstrap?.host),
);
// Private networks only, so clients learn a LAN address and prefer it over
// T3 Connect. `t3 service install` writes T3CODE_LAN=false for a new
// service; one installed before T3CODE_LAN existed keeps listening.
const lan = resolveOptionPrecedence(normalizedFlags.lan, Option.fromUndefinedOr(env.lan));
const privateNetworkOnly =
Option.isNone(explicitHost) &&
mode === "web" &&
(Option.isSome(lan)
? lan.value
: yield* resolveServiceLauncherMode().pipe(
Effect.map((launcher) => launcher.managed),
Effect.orElseSucceed(() => false),
));
const host = Option.getOrElse(explicitHost, () =>
privateNetworkOnly ? "0.0.0.0" : mode === "desktop" ? "127.0.0.1" : undefined,
);
const logLevel = Option.getOrElse(cliLogLevel, () => env.logLevel);
const otel = yield* OtelEnvironment.load;
const signalExport: SignalExport = {
protocol: env.otlpProtocol,
headers: env.otlpHeaders,
exportIntervalMs: env.otlpExportIntervalMs,
};
const traces = OtelEnvironment.resolveSignalEndpoint(
otel,
"traces",
{ url: env.otlpTracesUrl, export: signalExport },
{
bootstrapUrl: bootstrap?.otlpTracesUrl,
settingsUrl: persistedObservabilitySettings.otlpTracesUrl,
},
);
const metrics = OtelEnvironment.resolveSignalEndpoint(
otel,
"metrics",
{ url: env.otlpMetricsUrl, export: signalExport },
{
bootstrapUrl: bootstrap?.otlpMetricsUrl,
settingsUrl: persistedObservabilitySettings.otlpMetricsUrl,
},
);
const logs = OtelEnvironment.resolveSignalEndpoint(
otel,
"logs",
{ url: env.otlpLogsUrl, export: signalExport },
{
bootstrapUrl: bootstrap?.otlpLogsUrl,
settingsUrl: persistedObservabilitySettings.otlpLogsUrl,
},
);
const config: ServerConfig.ServerConfig["Service"] = {
logLevel,
traceMinLevel: env.traceMinLevel,
traceTimingEnabled: env.traceTimingEnabled,
traceBatchWindowMs: env.traceBatchWindowMs,
traceMaxBytes: env.traceMaxBytes,
traceMaxFiles: env.traceMaxFiles,
otlpTracesUrl: traces?.url,
otlpMetricsUrl: metrics?.url,
otlpLogsUrl: logs?.url,
otlpTracesExport: traces?.export ?? signalExport,
otlpMetricsExport: metrics?.export ?? signalExport,
otlpLogsExport: logs?.export ?? signalExport,
...(traces !== undefined ? { otlpTracesSource: traces.source } : {}),
...(traces?.variable !== undefined ? { otlpTracesVariable: traces.variable } : {}),
...(metrics !== undefined ? { otlpMetricsSource: metrics.source } : {}),
...(metrics?.variable !== undefined ? { otlpMetricsVariable: metrics.variable } : {}),
...(logs !== undefined ? { otlpLogsSource: logs.source } : {}),
...(logs?.variable !== undefined ? { otlpLogsVariable: logs.variable } : {}),
otelEnvironment: otel,
mode,
port,
cwd,
baseDir,
...derivedPaths,
serverTracePath,
host,
...(privateNetworkOnly ? { privateNetworkOnly } : {}),
staticDir,
devUrl,
...(devAuthToken === undefined ? {} : { devAuthToken }),
devAllowedOrigins: env.devAllowedOrigins,
noBrowser,
startupPresentation,
desktopBootstrapToken,
...(desktopBootstrapSecret === undefined ? {} : { desktopBootstrapSecret }),
...(shellEnvironmentPrepared === undefined ? {} : { shellEnvironmentPrepared }),
desktopTelemetryFd,
desktopTelemetryControlFd,
desktopBrowserFd,
desktopBrowserControlFd,
resourceMonitorPath,
autoBootstrapProjectFromCwd,
logWebSocketEvents,
tailscaleServeEnabled,
tailscaleServePort,
};
return config;
});
export const resolveCliAuthConfig = (
flags: CliAuthLocationFlags,
cliLogLevel: Option.Option<LogLevel.LogLevel>,
options?: { readonly quietLogs?: boolean },
) => {
const resolved = resolveServerConfig(
{
mode: Option.none(),
port: Option.none(),
host: Option.none(),
baseDir: flags.baseDir,
cwd: Option.none(),
devUrl: flags.devUrl ?? Option.none(),
noBrowser: Option.none(),
bootstrapFd: Option.none(),
autoBootstrapProjectFromCwd: Option.none(),
logWebSocketEvents: Option.none(),
tailscaleServeEnabled: Option.none(),
tailscaleServePort: Option.none(),
lan: Option.none(),
},
cliLogLevel,
);
// Logs go to stdout, where --json and --token-only print, and resolving can
// log, for example when it sweeps abandoned attachment uploads.
return options?.quietLogs === true
? resolved.pipe(Effect.provideService(References.MinimumLogLevel, "Error"))
: resolved;
};
const DurationShorthandPattern = /^(?<value>\d+)(?<unit>ms|s|m|h|d|w)$/i;
const parseDurationInput = (value: string): Duration.Duration | null => {
const trimmed = value.trim();
if (trimmed.length === 0) return null;
const shorthand = DurationShorthandPattern.exec(trimmed);
const normalizedInput = shorthand?.groups
? (() => {
const amountText = shorthand.groups.value;
const unitText = shorthand.groups.unit;
if (typeof amountText !== "string" || typeof unitText !== "string") {
return null;
}
const amount = Number.parseInt(amountText, 10);
if (!Number.isFinite(amount)) return null;
switch (unitText.toLowerCase()) {
case "ms":
return `${amount} millis`;
case "s":
return `${amount} seconds`;
case "m":
return `${amount} minutes`;
case "h":
return `${amount} hours`;
case "d":
return `${amount} days`;
case "w":
return `${amount} weeks`;
default:
return null;
}
})()
: (trimmed as Duration.Input);
if (normalizedInput === null) return null;
const decoded = Duration.fromInput(normalizedInput as Duration.Input);
return Option.isSome(decoded) ? decoded.value : null;
};
export const DurationFromString = Schema.String.pipe(
Schema.decodeTo(
Schema.Duration,
SchemaTransformation.transformEffect({
decode: (value) => {
const duration = parseDurationInput(value);
if (duration !== null) {
return Effect.succeed(duration);
}
return Effect.fail(
new SchemaIssue.InvalidValue({
message: "Invalid duration. Use values like 5m, 1h, 30d, or 15 minutes.",
}),
);
},
encode: (duration) => Effect.succeed(Duration.format(duration)),
}),
),
);