@aryasaatvik/motel 0.3.0

package/src/StartupGate.tsx

@@ -0,0 +1,263 @@
+import { Effect } from "effect"
+import { RGBA, TextAttributes } from "@opentui/core"
+import { useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/react"
+import { useEffect, useMemo, useState } from "react"
+import { App } from "./App.js"
+import { getManagedDaemonStatus, type DaemonStatus } from "./daemon.js"
+import { MOTEL_SERVICE_ID } from "./registry.js"
+import { startDaemon, stopConflictingDaemon, type ConflictStatus } from "./startupLifecycle.js"
+import { Divider, PlainLine, TextLine } from "./ui/primitives.tsx"
+import { colors } from "./ui/theme.ts"
+
+type ConflictScreenState = {
+	kind: "conflict"
+	message: string
+	status: ConflictStatus
+	busy: boolean
+	notice: string | null
+}
+
+type ErrorScreenState = {
+	kind: "error"
+	message: string
+	busy: boolean
+	notice: string | null
+}
+
+type StartupState =
+	| { kind: "loading"; message: string }
+	| { kind: "ready" }
+	| ConflictScreenState
+	| ErrorScreenState
+
+type RecoveryAction = {
+	readonly key: string
+	readonly label: string
+	readonly run: () => Promise<void>
+	readonly disabled?: boolean
+}
+
+const readStatus = () => Effect.runPromise(getManagedDaemonStatus)
+
+const isRecoverableConflict = (status: DaemonStatus | null): status is ConflictStatus =>
+	status !== null &&
+	status.service === MOTEL_SERVICE_ID &&
+	status.pid !== null &&
+	status.workdir !== null &&
+	status.reason !== null
+
+const LoadingScreen = ({ width, height, message }: { width: number; height: number; message: string }) => {
+	const panelWidth = Math.min(76, Math.max(50, width - 8))
+	const left = Math.max(0, Math.floor((width - panelWidth) / 2))
+	const top = Math.max(0, Math.floor((height - 5) / 2))
+
+	return (
+		<box width={width} height={height} backgroundColor={RGBA.fromHex(colors.screenBg)}>
+			<box position="absolute" left={left} top={top} width={panelWidth} flexDirection="column">
+				<TextLine>
+					<span fg={colors.accent} attributes={TextAttributes.BOLD}>MOTEL</span>
+					<span fg={colors.separator}>{" · "}</span>
+					<span fg={colors.muted}>starting up...</span>
+				</TextLine>
+				<Divider width={panelWidth} />
+				<box paddingTop={1}>
+					<PlainLine text={message} fg={colors.count} />
+				</box>
+			</box>
+		</box>
+	)
+}
+
+const RecoveryScreen = ({
+	title,
+	message,
+	width,
+	height,
+	detailLines,
+	actions,
+	selectedIndex,
+	notice,
+	busy,
+}: {
+	readonly title: string
+	readonly message: string
+	readonly width: number
+	readonly height: number
+	readonly detailLines: readonly string[]
+	readonly actions: readonly RecoveryAction[]
+	readonly selectedIndex: number
+	readonly notice: string | null
+	readonly busy: boolean
+}) => {
+	const panelWidth = Math.min(96, Math.max(64, width - 8))
+	const left = Math.max(0, Math.floor((width - panelWidth) / 2))
+	const bodyHeight = 9 + detailLines.length + actions.length + (notice ? 2 : 0)
+	const top = Math.max(0, Math.floor((height - bodyHeight) / 2))
+
+	return (
+		<box width={width} height={height} backgroundColor={RGBA.fromHex(colors.screenBg)}>
+			<box position="absolute" left={left} top={top} width={panelWidth} flexDirection="column">
+				<TextLine>
+					<span fg={colors.accent} attributes={TextAttributes.BOLD}>MOTEL</span>
+					<span fg={colors.separator}>{" · "}</span>
+					<span fg={colors.error} attributes={TextAttributes.BOLD}>{title}</span>
+				</TextLine>
+				<Divider width={panelWidth} />
+				<box paddingTop={1} paddingBottom={1} flexDirection="column">
+					<PlainLine text={message} fg={colors.text} />
+				</box>
+				{detailLines.map((line, index) => (
+					<PlainLine key={`${index}:${line}`} text={line} fg={colors.muted} />
+				))}
+				<box paddingTop={1} flexDirection="column">
+					{actions.map((action, index) => {
+						const selected = index === selectedIndex
+						const prefix = selected ? ">" : " "
+						const text = `${prefix} [${action.key}] ${action.label}${action.disabled ? " (unavailable)" : ""}`
+						return (
+							<TextLine key={action.key} bg={selected ? colors.selectedBg : undefined}>
+								<span fg={selected ? colors.selectedText : colors.text}>{text}</span>
+							</TextLine>
+						)
+					})}
+				</box>
+				<box paddingTop={1} flexDirection="column">
+					{notice ? <PlainLine text={notice} fg={busy ? colors.warning : colors.count} /> : null}
+					<PlainLine text={busy ? "Working..." : "j/k or ↑↓ select · enter run · r retry · k stop incompatible daemon · q quit"} fg={colors.count} />
+				</box>
+			</box>
+		</box>
+	)
+}
+
+export const StartupGate = () => {
+	const renderer = useRenderer()
+	const { width = 100, height = 24 } = useTerminalDimensions()
+	const [startupState, setStartupState] = useState<StartupState>({ kind: "loading", message: "Checking managed daemon..." })
+	const [selectedIndex, setSelectedIndex] = useState(0)
+
+	const attemptStart = async () => {
+		setStartupState({ kind: "loading", message: "Checking managed daemon..." })
+		try {
+			await startDaemon()
+			setStartupState({ kind: "ready" })
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error)
+			const status = await readStatus().catch(() => null)
+			if (isRecoverableConflict(status)) {
+				setSelectedIndex(0)
+				setStartupState({ kind: "conflict", message, status, busy: false, notice: null })
+				return
+			}
+			setSelectedIndex(0)
+			setStartupState({ kind: "error", message, busy: false, notice: null })
+		}
+	}
+
+	useEffect(() => {
+		void attemptStart()
+	}, [])
+
+	const actions = useMemo<readonly RecoveryAction[]>(() => {
+		if (startupState.kind === "conflict") {
+			return [
+				{ key: "r", label: "Retry startup", run: attemptStart },
+				{
+					key: "k",
+					label: `Stop incompatible daemon (${startupState.status.pid})`,
+					run: async () => {
+						setStartupState((current) => current.kind === "conflict"
+							? { ...current, busy: true, notice: `Stopping daemon ${current.status.pid}...` }
+							: current)
+						try {
+							await stopConflictingDaemon(startupState.status)
+							await attemptStart()
+						} catch (error) {
+							const message = error instanceof Error ? error.message : String(error)
+							setStartupState((current) => current.kind === "conflict"
+								? { ...current, busy: false, notice: message }
+								: current)
+						}
+					},
+				},
+				{ key: "q", label: "Quit", run: async () => { renderer.destroy() } },
+			]
+		}
+		if (startupState.kind === "error") {
+			return [
+				{ key: "r", label: "Retry startup", run: attemptStart },
+				{ key: "q", label: "Quit", run: async () => { renderer.destroy() } },
+			]
+		}
+		return []
+	}, [renderer, startupState])
+
+	useKeyboard((key) => {
+		if (startupState.kind === "ready" || startupState.kind === "loading" || key.repeated) return
+		if (key.name === "q" || (key.ctrl && key.name === "c")) {
+			renderer.destroy()
+			return
+		}
+		if (key.name === "up" || key.name === "k") {
+			setSelectedIndex((current) => (current + actions.length - 1) % actions.length)
+			return
+		}
+		if (key.name === "down" || key.name === "j") {
+			setSelectedIndex((current) => (current + 1) % actions.length)
+			return
+		}
+		if (key.name === "r") {
+			void actions.find((action) => action.key === "r")?.run()
+			return
+		}
+		if (key.name === "k") {
+			void actions.find((action) => action.key === "k")?.run()
+			return
+		}
+		if (key.name === "return" || key.name === "enter") {
+			void actions[selectedIndex]?.run()
+		}
+	})
+
+	if (startupState.kind === "ready") return <App />
+	if (startupState.kind === "loading") return <LoadingScreen width={width} height={height} message={startupState.message} />
+	if (startupState.kind === "conflict") {
+		const status = startupState.status
+		const detailLines = [
+			`Port: ${status.url}`,
+			`Daemon workdir: ${status.workdir}`,
+			`Daemon pid: ${status.pid}`,
+			`Incompatible database: ${status.databasePath}`,
+			status.workdir.startsWith("/tmp") || status.workdir.startsWith("/private/tmp")
+				? "This looks like a temp/test daemon."
+				: "This daemon is using a different database configuration.",
+		]
+		return (
+			<RecoveryScreen
+				title="Daemon Configuration Conflict"
+				message={startupState.message}
+				width={width}
+				height={height}
+				detailLines={detailLines}
+				actions={actions}
+				selectedIndex={selectedIndex}
+				notice={startupState.notice}
+				busy={startupState.busy}
+			/>
+		)
+	}
+
+	return (
+		<RecoveryScreen
+			title="Startup Error"
+			message={startupState.message}
+			width={width}
+			height={height}
+			detailLines={["Retry startup or quit the TUI."]}
+			actions={actions}
+			selectedIndex={selectedIndex}
+			notice={startupState.notice}
+			busy={startupState.busy}
+		/>
+	)
+}

package/src/cli.ts

@@ -0,0 +1,205 @@
+import { Console, Effect, Option, References } from "effect"
+import { Argument, Command } from "effect/unstable/cli"
+import { config } from "./config.js"
+import { otelServerInstructions } from "./instructions.js"
+import { attributeFiltersFromArgs, isAttributeFilterToken } from "./queryFilters.js"
+import { queryRuntime } from "./runtime.js"
+import { TelemetryStoreReadonly } from "./services/TelemetryStore.js"
+
+const json = (value: unknown) => Console.log(JSON.stringify(value, null, 2))
+
+const query = <A>(effect: Effect.Effect<A, unknown, TelemetryStoreReadonly>) =>
+	Effect.promise(() => queryRuntime.runPromise(effect.pipe(Effect.provideService(References.MinimumLogLevel, "None")))).pipe(
+		Effect.andThen(json),
+		Effect.ensuring(Effect.promise(() => queryRuntime.dispose())),
+	)
+
+const optional = (value: Option.Option<string>, fallback?: string) => Option.getOrElse(value, () => fallback)
+
+const searchOperand = Argument.string("service-or-filter").pipe(
+	Argument.mapTryCatch(
+		(value) => {
+			if (value.startsWith("attr.") && !isAttributeFilterToken(value)) {
+				throw new Error("attribute filters must use attr.<key>=<value>")
+			}
+			return value
+		},
+		(error) => error instanceof Error ? error.message : String(error),
+	),
+	Argument.variadic,
+)
+
+const services = Command.make("services", {}, () =>
+	query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.listServices)),
+).pipe(Command.withDescription("List observed telemetry services"))
+
+const traces = Command.make("traces", {
+	service: Argument.string("service").pipe(Argument.optional),
+	limit: Argument.integer("limit").pipe(Argument.optional),
+}, ({ service, limit }) =>
+	query(Effect.flatMap(TelemetryStoreReadonly, (store) =>
+		store.listRecentTraces(optional(service, config.otel.serviceName)!, {
+			limit: Option.getOrElse(limit, () => config.otel.traceFetchLimit),
+		}),
+	)),
+).pipe(Command.withDescription("List recent traces"))
+
+const trace = Command.make("trace", {
+	traceId: Argument.string("trace-id"),
+}, ({ traceId }) =>
+	query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.getTrace(traceId))),
+).pipe(Command.withDescription("Get one trace"))
+
+const span = Command.make("span", {
+	spanId: Argument.string("span-id"),
+}, ({ spanId }) =>
+	Effect.promise(() => fetch(`${config.otel.queryUrl}/api/spans/${encodeURIComponent(spanId)}`).then((response) => response.json())).pipe(
+		Effect.andThen(json),
+	),
+).pipe(Command.withDescription("Get one span"))
+
+const traceSpans = Command.make("trace-spans", {
+	traceId: Argument.string("trace-id"),
+}, ({ traceId }) =>
+	query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.listTraceSpans(traceId))),
+).pipe(Command.withDescription("List spans in one trace"))
+
+const parseSearchSpans = (args: ReadonlyArray<string>) => {
+	const service = args[0] ?? config.otel.serviceName
+	const operation = args[1] && !isAttributeFilterToken(args[1]) && !args[1].startsWith("parent=") ? args[1] : undefined
+	const parentTokenIndex = args.findIndex((value, index) => index > 0 && value.startsWith("parent="))
+	const parentOperation = parentTokenIndex >= 0 ? args[parentTokenIndex]?.slice("parent=".length) : undefined
+	const attributeStartIndex = operation ? 2 : 1
+	return { service, operation, parentOperation, attributeFilters: attributeFiltersFromArgs(args.slice(attributeStartIndex)) }
+}
+
+const searchSpans = Command.make("search-spans", {
+	args: searchOperand,
+}, ({ args }) => {
+	const input = parseSearchSpans(args as ReadonlyArray<string>)
+	return query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.searchSpans({
+		serviceName: input.service,
+		operation: input.operation,
+		parentOperation: input.parentOperation,
+		attributeFilters: input.attributeFilters,
+		limit: config.otel.logFetchLimit,
+	})))
+}).pipe(Command.withDescription("Search spans by service, operation, parent, and attributes"))
+
+const searchTraces = Command.make("search-traces", {
+	args: searchOperand,
+}, ({ args }) => {
+	const values = args as ReadonlyArray<string>
+	const service = values[0] ?? config.otel.serviceName
+	const operation = values[1] && !isAttributeFilterToken(values[1]) ? values[1] : undefined
+	const attributeFilters = attributeFiltersFromArgs(values.slice(operation ? 2 : 1))
+	return query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.searchTraces({
+		serviceName: service,
+		operation,
+		attributeFilters,
+		limit: config.otel.traceFetchLimit,
+	})))
+}).pipe(Command.withDescription("Search trace summaries by service, operation, and attributes"))
+
+const traceStats = Command.make("trace-stats", {
+	groupBy: Argument.string("groupBy"),
+	agg: Argument.choice("aggregation", ["count", "avg_duration", "p95_duration", "error_rate"]),
+	args: searchOperand,
+}, ({ groupBy, agg, args }) => {
+	const values = args as ReadonlyArray<string>
+	const service = values[0] && !isAttributeFilterToken(values[0]) ? values[0] : undefined
+	return query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.traceStats({
+		groupBy,
+		agg,
+		serviceName: service,
+		attributeFilters: attributeFiltersFromArgs(values.slice(service ? 1 : 0)),
+		limit: 20,
+	})))
+}).pipe(Command.withDescription("Aggregate trace metrics"))
+
+const instructions = Command.make("instructions", {}, () => Console.log(otelServerInstructions()))
+	.pipe(Command.withDescription("Print Effect telemetry setup instructions"))
+
+const logs = Command.make("logs", {
+	service: Argument.string("service").pipe(Argument.optional),
+}, ({ service }) =>
+	query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.listRecentLogs(optional(service, config.otel.serviceName)!))),
+).pipe(Command.withDescription("List recent logs"))
+
+const searchLogs = Command.make("search-logs", {
+	args: searchOperand,
+}, ({ args }) => {
+	const values = args as ReadonlyArray<string>
+	const service = values[0] ?? config.otel.serviceName
+	const body = values[1] && !isAttributeFilterToken(values[1]) ? values[1] : undefined
+	return query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.searchLogs({
+		serviceName: service,
+		body,
+		attributeFilters: attributeFiltersFromArgs(values.slice(body ? 2 : 1)),
+		limit: config.otel.logFetchLimit,
+	})))
+}).pipe(Command.withDescription("Search logs by service, body, and attributes"))
+
+const logStats = Command.make("log-stats", {
+	groupBy: Argument.string("groupBy"),
+	args: searchOperand,
+}, ({ groupBy, args }) => {
+	const values = args as ReadonlyArray<string>
+	const service = values[0] && !isAttributeFilterToken(values[0]) ? values[0] : undefined
+	return query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.logStats({
+		groupBy,
+		agg: "count",
+		serviceName: service,
+		attributeFilters: attributeFiltersFromArgs(values.slice(service ? 1 : 0)),
+		limit: 20,
+	})))
+}).pipe(Command.withDescription("Aggregate log metrics"))
+
+const traceLogs = Command.make("trace-logs", {
+	traceId: Argument.string("trace-id"),
+}, ({ traceId }) =>
+	query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.listTraceLogs(traceId))),
+).pipe(Command.withDescription("List logs for one trace"))
+
+const spanLogs = Command.make("span-logs", {
+	spanId: Argument.string("span-id"),
+}, ({ spanId }) =>
+	query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.searchLogs({
+		spanId,
+		limit: config.otel.logFetchLimit,
+	}))),
+).pipe(Command.withDescription("List logs for one span"))
+
+const facets = Command.make("facets", {
+	type: Argument.choice("type", ["traces", "logs"]),
+	field: Argument.string("field"),
+}, ({ type, field }) =>
+	query(Effect.flatMap(TelemetryStoreReadonly, (store) => store.listFacets({ type, field, limit: 20 }))),
+).pipe(Command.withDescription("List facet values"))
+
+const endpoints = Command.make("endpoints", {}, () => json({
+	baseUrl: config.otel.baseUrl,
+	exporterUrl: config.otel.exporterUrl,
+	logsExporterUrl: config.otel.logsExporterUrl,
+	queryUrl: config.otel.queryUrl,
+	databasePath: config.otel.databasePath,
+})).pipe(Command.withDescription("Print configured telemetry endpoints"))
+
+export const queryCommands = [
+	services,
+	traces,
+	trace,
+	span,
+	traceSpans,
+	searchSpans,
+	searchTraces,
+	traceStats,
+	instructions,
+	logs,
+	searchLogs,
+	logStats,
+	traceLogs,
+	spanLogs,
+	facets,
+	endpoints,
+] as const

package/src/config.ts

@@ -0,0 +1,45 @@
+import { motelStateDir } from "./registry.js"
+import * as path from "node:path"
+
+const parseBoolean = (value: string | undefined, defaultValue: boolean) => {
+	const normalized = value?.trim().toLowerCase()
+	if (!normalized) return defaultValue
+	return !["0", "false", "no", "off"].includes(normalized)
+}
+
+export const parsePositiveInt = (value: string | undefined, defaultValue: number) => {
+	const parsed = Number.parseInt(value ?? "", 10)
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultValue
+}
+
+const baseUrl =
+	process.env.MOTEL_OTEL_BASE_URL?.trim() ||
+	process.env.MOTEL_OTEL_QUERY_URL?.trim() ||
+	process.env.MOTEL_OTEL_COLLECTOR_URL?.trim() ||
+	"http://127.0.0.1:27686"
+
+const parsedBaseUrl = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`)
+export const resolveOtelUrl = (path: string) => new URL(path.startsWith("/") ? path.slice(1) : path, parsedBaseUrl).toString()
+const serverPort = parsePositiveInt(process.env.MOTEL_OTEL_PORT, Number.parseInt(parsedBaseUrl.port || "80", 10))
+
+export const config = {
+	otel: {
+		enabled: parseBoolean(process.env.MOTEL_OTEL_ENABLED, false),
+		serviceName: process.env.MOTEL_OTEL_SERVICE_NAME?.trim() || "motel-otel-tui",
+		baseUrl,
+		host: process.env.MOTEL_OTEL_HOST?.trim() || parsedBaseUrl.hostname,
+		port: serverPort,
+		queryUrl: baseUrl,
+		exporterUrl: process.env.MOTEL_OTEL_EXPORTER_URL?.trim() || resolveOtelUrl("/v1/traces"),
+		logsExporterUrl: process.env.MOTEL_OTEL_LOGS_EXPORTER_URL?.trim() || resolveOtelUrl("/v1/logs"),
+		databasePath: process.env.MOTEL_OTEL_DB_PATH?.trim() || path.join(motelStateDir(), "telemetry.sqlite"),
+		traceLookbackMinutes: parsePositiveInt(process.env.MOTEL_OTEL_TRACE_LOOKBACK_MINUTES, 1440),
+		traceFetchLimit: parsePositiveInt(process.env.MOTEL_OTEL_TRACE_LIMIT, 100),
+		logFetchLimit: parsePositiveInt(process.env.MOTEL_OTEL_LOG_LIMIT, 80),
+		retentionHours: parsePositiveInt(process.env.MOTEL_OTEL_RETENTION_HOURS, 168),
+		maxDbSizeMb: parsePositiveInt(process.env.MOTEL_OTEL_MAX_DB_SIZE_MB, 1024),
+		retentionTraceBatch: parsePositiveInt(process.env.MOTEL_OTEL_RETENTION_TRACE_BATCH, 100),
+		retentionLogBatch: parsePositiveInt(process.env.MOTEL_OTEL_RETENTION_LOG_BATCH, 5_000),
+		retentionIntervalSeconds: parsePositiveInt(process.env.MOTEL_OTEL_RETENTION_INTERVAL_SECONDS, 10),
+	},
+} as const