@kitlangton/motel 0.2.5 → 0.2.6

package/src/mcp.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import { BunRuntime, BunStdio } from "@effect/platform-bun"
 import { Effect, Layer, Logger, Schema } from "effect"
+import { MOTEL_VERSION } from "./registry.js"
 import { McpServer, Tool, Toolkit } from "effect/unstable/ai"
 import { TraceSpanStatus } from "./domain.js"
 import { MotelClient, MotelClientLive } from "./motelClient.js"
@@ -422,7 +423,7 @@ const ServerLayer = McpServer.toolkit(MotelToolkit).pipe(
 	Layer.provide(
 		McpServer.layerStdio({
 			name: "motel",
-			version: "0.1.0",
+			version: MOTEL_VERSION,
 		}),
 	),
 	Layer.provide(BunStdio.layer),

package/src/opentui-jsx.d.ts

@@ -0,0 +1,11 @@
+import type { Key } from "react"
+
+// TypeScript 6 does not preserve React's inherited `key` attribute through
+// OpenTUI's JSX runtime declarations for custom components.
+declare module "@opentui/react/jsx-runtime" {
+	namespace JSX {
+		interface IntrinsicAttributes {
+			readonly key?: Key | null | undefined
+		}
+	}
+}

package/src/otlp.test.ts

@@ -0,0 +1,65 @@
+import rootModule from "@opentelemetry/otlp-transformer/build/esm/generated/root.js"
+import { describe, expect, test } from "bun:test"
+import { normalizeOtlpBinaryId } from "./otlp.ts"
+import { decodeProtobufLogs, decodeProtobufTraces } from "./otlpProtobuf.ts"
+
+describe("normalizeOtlpBinaryId", () => {
+	test("normalizes hex and canonical base64 IDs", () => {
+		expect(normalizeOtlpBinaryId("0123456789ABCDEF", 8)).toBe("0123456789abcdef")
+		expect(normalizeOtlpBinaryId(Buffer.from("0123456789abcdef", "hex").toString("base64"), 8)).toBe("0123456789abcdef")
+		expect(normalizeOtlpBinaryId(Buffer.from("0123456789abcdef0123456789abcdef", "hex").toString("base64"), 16)).toBe("0123456789abcdef0123456789abcdef")
+	})
+
+	test("preserves non-standard human-readable IDs", () => {
+		expect(normalizeOtlpBinaryId("ai-stream-1", 8)).toBe("ai-stream-1")
+		expect(normalizeOtlpBinaryId("ai-stream-2", 8)).toBe("ai-stream-2")
+		expect(normalizeOtlpBinaryId("trace-ai", 16)).toBe("trace-ai")
+	})
+
+	test("returns null for absent IDs", () => {
+		expect(normalizeOtlpBinaryId(null, 16)).toBeNull()
+		expect(normalizeOtlpBinaryId(undefined, 8)).toBeNull()
+		expect(normalizeOtlpBinaryId("", 16)).toBeNull()
+	})
+})
+
+const root = rootModule as unknown as {
+	readonly opentelemetry: {
+		readonly proto: {
+			readonly collector: {
+				readonly trace: { readonly v1: { readonly ExportTraceServiceRequest: { encode: (message: unknown) => { finish: () => Uint8Array } } } }
+				readonly logs: { readonly v1: { readonly ExportLogsServiceRequest: { encode: (message: unknown) => { finish: () => Uint8Array } } } }
+			}
+		}
+	}
+}
+
+describe("protobuf OTLP decoders", () => {
+	test("decodes traces into the JSON ingest shape", () => {
+		const encoded = root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest.encode({
+			resourceSpans: [{
+				resource: { attributes: [{ key: "service.name", value: { stringValue: "proto-svc" } }] },
+				scopeSpans: [{ spans: [{
+					traceId: Buffer.from("0123456789abcdef0123456789abcdef", "hex"),
+					spanId: Buffer.from("0123456789abcdef", "hex"),
+					name: "op",
+					startTimeUnixNano: 1,
+					endTimeUnixNano: 2,
+				}] }],
+			}],
+		}).finish()
+		const span = decodeProtobufTraces(encoded).resourceSpans?.[0]?.scopeSpans?.[0]?.spans?.[0]
+		expect(span?.name).toBe("op")
+		expect(normalizeOtlpBinaryId(span?.traceId, 16)).toBe("0123456789abcdef0123456789abcdef")
+		expect(normalizeOtlpBinaryId(span?.spanId, 8)).toBe("0123456789abcdef")
+	})
+
+	test("decodes logs into the JSON ingest shape", () => {
+		const encoded = root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest.encode({
+			resourceLogs: [{ scopeLogs: [{ logRecords: [{ timeUnixNano: 5, severityText: "INFO", body: { stringValue: "hello" } }] }] }],
+		}).finish()
+		const record = decodeProtobufLogs(encoded).resourceLogs?.[0]?.scopeLogs?.[0]?.logRecords?.[0]
+		expect(record?.severityText).toBe("INFO")
+		expect(record?.body?.stringValue).toBe("hello")
+	})
+})

package/src/otlp.ts

@@ -140,3 +140,23 @@ export const spanKindLabel = (kind: number | undefined): string | null => {
 }
 
 export const spanStatusLabel = (code: number | undefined): "ok" | "error" => (code === 2 ? "error" : "ok")
+
+/** Normalize OTLP hex or canonical base64 binary IDs to lowercase hex. */
+export const normalizeOtlpBinaryId = (
+	value: string | null | undefined,
+	expectedBytes: 8 | 16,
+): string | null => {
+	if (!value) return null
+	const expectedHexLength = expectedBytes * 2
+	if (value.length === expectedHexLength && /^[0-9a-f]+$/.test(value)) return value
+	if (value.length === expectedHexLength && /^[0-9a-fA-F]+$/.test(value)) return value.toLowerCase()
+	try {
+		const bytes = Buffer.from(value, "base64")
+		if (bytes.length === expectedBytes && bytes.toString("base64") === value) {
+			return bytes.toString("hex")
+		}
+	} catch {
+		// Preserve non-standard human-readable IDs used by local fixtures and custom exporters.
+	}
+	return value
+}

package/src/otlpProtobuf.ts

@@ -0,0 +1,35 @@
+import rootModule from "@opentelemetry/otlp-transformer/build/esm/generated/root.js"
+import type { OtlpLogExportRequest, OtlpTraceExportRequest } from "./otlp.js"
+
+interface ProtobufType {
+	readonly decode: (bytes: Uint8Array) => unknown
+	readonly toObject: (message: unknown, options: Record<string, unknown>) => unknown
+}
+
+const root = rootModule as unknown as {
+	readonly opentelemetry: {
+		readonly proto: {
+			readonly collector: {
+				readonly trace: { readonly v1: { readonly ExportTraceServiceRequest: ProtobufType } }
+				readonly logs: { readonly v1: { readonly ExportLogsServiceRequest: ProtobufType } }
+			}
+		}
+	}
+}
+
+const ExportTraceServiceRequest = root.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest
+const ExportLogsServiceRequest = root.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest
+const decodeOptions = {
+	bytes: String,
+	longs: String,
+	defaults: false,
+	enums: Number,
+	arrays: true,
+	objects: true,
+}
+
+export const decodeProtobufTraces = (bytes: Uint8Array): OtlpTraceExportRequest =>
+	ExportTraceServiceRequest.toObject(ExportTraceServiceRequest.decode(bytes), decodeOptions) as OtlpTraceExportRequest
+
+export const decodeProtobufLogs = (bytes: Uint8Array): OtlpLogExportRequest =>
+	ExportLogsServiceRequest.toObject(ExportLogsServiceRequest.decode(bytes), decodeOptions) as OtlpLogExportRequest

package/src/registry.ts

@@ -1,14 +1,23 @@
 import * as fs from "node:fs"
 import * as os from "node:os"
 import * as path from "node:path"
+import packageJson from "../package.json" with { type: "json" }
 
-export const MOTEL_VERSION = "0.1.0"
+export const MOTEL_VERSION = packageJson.version
 export const MOTEL_SERVICE_ID = "motel-local-server"
 
 const stateHome = () =>
 	process.env.XDG_STATE_HOME?.trim() || path.join(os.homedir(), ".local", "state")
 
-export const registryDir = () => path.join(stateHome(), "motel", "instances")
+/**
+ * The shared, machine-global motel state directory. Holds the SQLite
+ * database, daemon log, daemon lock, and the per-pid instance registry.
+ * One motel daemon serves every project on this machine — there is no
+ * per-cwd state.
+ */
+export const motelStateDir = () => process.env.MOTEL_RUNTIME_DIR?.trim() || path.join(stateHome(), "motel")
+
+export const registryDir = (runtimeDir = motelStateDir()) => path.join(runtimeDir, "instances")
 
 export type RegistryEntry = {
 	readonly pid: number
@@ -16,6 +25,8 @@ export type RegistryEntry = {
 	readonly workdir: string
 	readonly startedAt: string
 	readonly version: string
+	readonly instanceId?: string
+	readonly processIdentity?: string
 	/**
 	 * The SQLite database path the daemon is serving. Optional because
 	 * older daemon builds omit it; consumers should treat a missing
@@ -26,7 +37,7 @@ export type RegistryEntry = {
 	readonly databasePath?: string
 }
 
-const entryPath = (pid: number) => path.join(registryDir(), `${pid}.json`)
+const entryPath = (pid: number, runtimeDir = motelStateDir()) => path.join(registryDir(runtimeDir), `${pid}.json`)
 
 export const isAlive = (pid: number): boolean => {
 	try {
@@ -37,8 +48,23 @@ export const isAlive = (pid: number): boolean => {
 	}
 }
 
-export const listAliveEntries = (): RegistryEntry[] => {
-	const dir = registryDir()
+export const processIdentity = (pid: number): string | null => {
+	try {
+		const result = Bun.spawnSync({ cmd: ["ps", "-p", String(pid), "-o", "lstart="] })
+		if (result.exitCode !== 0) return null
+		const identity = result.stdout.toString().trim()
+		return identity.length > 0 ? identity : null
+	} catch {
+		return null
+	}
+}
+
+export const isManagedDaemonProcess = (entry: RegistryEntry): boolean => {
+	return Boolean(entry.instanceId && entry.processIdentity && processIdentity(entry.pid) === entry.processIdentity)
+}
+
+export const listAliveEntries = (runtimeDir = motelStateDir()): RegistryEntry[] => {
+	const dir = registryDir(runtimeDir)
 	let files: string[]
 	try {
 		files = fs.readdirSync(dir)
@@ -51,7 +77,7 @@ export const listAliveEntries = (): RegistryEntry[] => {
 		const full = path.join(dir, f)
 		try {
 			const entry = JSON.parse(fs.readFileSync(full, "utf8")) as RegistryEntry
-			if (isAlive(entry.pid)) {
+			if (entry.instanceId && entry.processIdentity ? isManagedDaemonProcess(entry) : isAlive(entry.pid)) {
 				alive.push(entry)
 			} else {
 				try { fs.unlinkSync(full) } catch {}
@@ -63,9 +89,9 @@ export const listAliveEntries = (): RegistryEntry[] => {
 	return alive
 }
 
-export const writeRegistryEntry = (entry: RegistryEntry) => {
-	fs.mkdirSync(registryDir(), { recursive: true })
-	const file = entryPath(entry.pid)
+export const writeRegistryEntry = (entry: RegistryEntry, runtimeDir = motelStateDir()) => {
+	fs.mkdirSync(registryDir(runtimeDir), { recursive: true })
+	const file = entryPath(entry.pid, runtimeDir)
 	fs.writeFileSync(file, JSON.stringify(entry, null, 2), "utf8")
 }
 
@@ -79,9 +105,9 @@ export const writeRegistryEntry = (entry: RegistryEntry) => {
  * server (via BunRuntime.runMain) now owns signal handling; registry
  * cleanup rides along on scope release.
  */
-export const removeRegistryEntry = (pid: number) => {
+export const removeRegistryEntry = (pid: number, runtimeDir = motelStateDir()) => {
 	try {
-		fs.unlinkSync(entryPath(pid))
+		fs.unlinkSync(entryPath(pid, runtimeDir))
 	} catch {
 		// Already gone — another cleanup path won the race, or the entry
 		// was never written.

package/src/runtime.ts

@@ -5,9 +5,7 @@ import { SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs"
 import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base"
 import { Layer, ManagedRuntime } from "effect"
 import { config } from "./config.js"
-import { LogQueryServiceLive } from "./services/LogQueryService.js"
 import { TelemetryStoreLive, TelemetryStoreReadonlyLive } from "./services/TelemetryStore.js"
-import { TraceQueryServiceLive } from "./services/TraceQueryService.js"
 
 const telemetryLayer = NodeSdk.layer(() => ({
 	spanProcessor: new SimpleSpanProcessor(
@@ -30,12 +28,10 @@ const telemetryLayer = NodeSdk.layer(() => ({
 	},
 }))
 
-// TUI-side services are readonly — a daemon/worker writer owns the DB
+// TUI-side runtime is readonly — a daemon/worker writer owns the DB
 // lock while ingests are in flight, and trying to grab the write lock
 // for schema init on startup causes "database is locked" on bun dev.
-const QueryServicesLive = Layer.mergeAll(TraceQueryServiceLive, LogQueryServiceLive).pipe(Layer.provideMerge(TelemetryStoreReadonlyLive))
-
-const QueryRuntimeLive = config.otel.enabled ? Layer.mergeAll(QueryServicesLive, telemetryLayer) : QueryServicesLive
+const QueryRuntimeLive = config.otel.enabled ? Layer.mergeAll(TelemetryStoreReadonlyLive, telemetryLayer) : TelemetryStoreReadonlyLive
 
 export const queryRuntime = ManagedRuntime.make(QueryRuntimeLive)
 // `storeRuntime` is the full writer runtime, exposed for the telemetry

package/src/services/AsyncIngest.ts

@@ -20,7 +20,7 @@
  */
 
 import * as BunWorker from "@effect/platform-bun/BunWorker"
-import { Context, Effect, Layer, Scope } from "effect"
+import { Context, Duration, Effect, Exit, Layer, Scope } from "effect"
 import * as RpcClient from "effect/unstable/rpc/RpcClient"
 import type { RpcClientError } from "effect/unstable/rpc/RpcClientError"
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization"
@@ -55,16 +55,28 @@ export const AsyncIngestLive = Layer.effect(
 		// spawn the worker and make /api/health wait on the worker's SQLite
 		// bootstrap. Cache a lazy initializer instead so the worker only starts
 		// on the first ingest request, but is still shared thereafter.
-		const getClient = yield* Effect.gen(function*() {
-			const protocolContext = yield* Layer.buildWithScope(WorkerProtocol, scope)
-			return yield* RpcClient.make(IngestRpcs).pipe(
+		const [getClient, invalidateClient] = yield* Effect.cachedInvalidateWithTTL(Effect.gen(function*() {
+			const clientScope = yield* Scope.fork(scope, "sequential")
+			const protocolContext = yield* Layer.buildWithScope(WorkerProtocol, clientScope)
+			const client = yield* RpcClient.make(IngestRpcs).pipe(
 				Effect.provide(protocolContext),
-				Effect.provideService(Scope.Scope, scope),
+				Effect.provideService(Scope.Scope, clientScope),
 			)
-		}).pipe(Effect.cached)
+			return { client, clientScope }
+		}), Duration.infinity)
+		// Start the sole writer/maintenance worker immediately, but do not make
+		// HTTP health wait for SQLite bootstrap. Managed readiness still verifies
+		// the worker through explicit ingest probes.
+		yield* Effect.forkScoped(getClient.pipe(Effect.ignore))
 		return {
-			ingestTraces: (input, options) => Effect.flatMap(getClient, (client) => client.ingestTraces(input, options)),
-			ingestLogs: (input, options) => Effect.flatMap(getClient, (client) => client.ingestLogs(input, options)),
+			ingestTraces: (input, options) =>
+				Effect.flatMap(getClient, ({ client, clientScope }) => client.ingestTraces(input, options).pipe(
+					Effect.onError(() => Effect.andThen(Scope.close(clientScope, Exit.void), invalidateClient)),
+				)),
+			ingestLogs: (input, options) =>
+				Effect.flatMap(getClient, ({ client, clientScope }) => client.ingestLogs(input, options).pipe(
+					Effect.onError(() => Effect.andThen(Scope.close(clientScope, Exit.void), invalidateClient)),
+				)),
 		}
 	}),
 )

package/src/services/LogQueryService.ts

@@ -2,6 +2,10 @@ import { Effect, Layer, Context } from "effect"
 import type { LogItem } from "../domain.js"
 import { TelemetryStore } from "./TelemetryStore.js"
 
+/**
+ * Compatibility adapter for consumers importing the historical log query module.
+ * New internal callers should use TelemetryStoreReadonly directly.
+ */
 export class LogQueryService extends Context.Service<
 	LogQueryService,
 	{
@@ -15,29 +19,11 @@ export class LogQueryService extends Context.Service<
 
 export const LogQueryServiceLive = Layer.effect(
 	LogQueryService,
-	Effect.gen(function* () {
-		const store = yield* TelemetryStore
-
-		const listRecentLogs = Effect.fn("motel/LogQueryService.listRecentLogs")(function* (serviceName: string) {
-			yield* Effect.annotateCurrentSpan("log.service_name", serviceName)
-			const logs = yield* store.listRecentLogs(serviceName)
-			yield* Effect.annotateCurrentSpan("log.result_count", logs.length)
-			return logs
-		})
-
-		const listTraceLogs = Effect.fn("motel/LogQueryService.listTraceLogs")(function* (traceId: string) {
-			yield* Effect.annotateCurrentSpan("log.trace_id", traceId)
-			const logs = yield* store.listTraceLogs(traceId)
-			yield* Effect.annotateCurrentSpan("log.result_count", logs.length)
-			return logs
-		})
-
-		return LogQueryService.of({
-			listRecentLogs,
-			listTraceLogs,
-			searchLogs: store.searchLogs,
-			logStats: store.logStats,
-			listFacets: store.listFacets,
-		})
-	}),
+	Effect.map(TelemetryStore, (store) => LogQueryService.of({
+		listRecentLogs: store.listRecentLogs,
+		listTraceLogs: store.listTraceLogs,
+		searchLogs: store.searchLogs,
+		logStats: store.logStats,
+		listFacets: store.listFacets,
+	})),
 )

package/src/services/TelemetryQuery.ts

@@ -0,0 +1,62 @@
+import * as BunWorker from "@effect/platform-bun/BunWorker"
+import { Duration, Effect, Exit, Layer, Scope } from "effect"
+import * as RpcClient from "effect/unstable/rpc/RpcClient"
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization"
+import type { WorkerError } from "effect/unstable/workers/WorkerError"
+import type { RpcClientError } from "effect/unstable/rpc/RpcClientError"
+import { TelemetryStoreReadonly, type TelemetryStoreReader } from "./TelemetryStore.js"
+import { QueryRpcs } from "./queryRpc.js"
+
+type QueryMethod = keyof TelemetryStoreReader
+type QueryClient = RpcClient.FromGroup<typeof QueryRpcs, RpcClientError | WorkerError>
+type QueryClientEntry = { readonly client: QueryClient; readonly clientScope: Scope.Scope }
+
+const WorkerProtocol = RpcClient.layerProtocolWorker({ size: 1 }).pipe(
+	Layer.provide(RpcSerialization.layerMsgPack),
+	Layer.provide(BunWorker.layer(() => new Worker(new URL("./telemetryQueryWorker.ts", import.meta.url)))),
+)
+
+const query = <A>(getClient: Effect.Effect<QueryClientEntry, unknown>, invalidateClient: Effect.Effect<void>, method: QueryMethod, args: readonly unknown[] = []) =>
+	Effect.flatMap(getClient, ({ client, clientScope }) => client.query({ method, args }).pipe(
+		Effect.onError(() => Effect.andThen(Scope.close(clientScope, Exit.void), invalidateClient)),
+	)).pipe(
+		Effect.map((result) => result as A),
+		Effect.mapError((error) => error instanceof Error ? error : new Error(String(error))),
+	)
+
+export const TelemetryQueryLive = Layer.effect(
+	TelemetryStoreReadonly,
+	Effect.gen(function*() {
+		const scope = yield* Scope.Scope
+		const [getClient, invalidateClient] = yield* Effect.cachedInvalidateWithTTL(Effect.gen(function*() {
+			const clientScope = yield* Scope.fork(scope, "sequential")
+			const protocolContext = yield* Layer.buildWithScope(WorkerProtocol, clientScope)
+			const client = yield* RpcClient.make(QueryRpcs).pipe(
+				Effect.provide(protocolContext),
+				Effect.provideService(Scope.Scope, clientScope),
+			)
+			return { client, clientScope }
+		}), Duration.infinity)
+		const run = <A>(method: QueryMethod, args: readonly unknown[] = []) => query<A>(getClient, invalidateClient, method, args)
+		return TelemetryStoreReadonly.of({
+			listServices: run("listServices"),
+			listRecentTraces: (serviceName, options) => run("listRecentTraces", [serviceName, options]),
+			listTraceSummaries: (serviceName, options) => run("listTraceSummaries", [serviceName, options]),
+			searchTraces: (input) => run("searchTraces", [input]),
+			searchTraceSummaries: (input) => run("searchTraceSummaries", [input]),
+			traceStats: (input) => run("traceStats", [input]),
+			getTrace: (traceId) => run("getTrace", [traceId]),
+			getSpan: (spanId) => run("getSpan", [spanId]),
+			listTraceSpans: (traceId) => run("listTraceSpans", [traceId]),
+			searchSpans: (input) => run("searchSpans", [input]),
+			searchLogs: (input) => run("searchLogs", [input]),
+			logStats: (input) => run("logStats", [input]),
+			listFacets: (input) => run("listFacets", [input]),
+			listRecentLogs: (serviceName) => run("listRecentLogs", [serviceName]),
+			listTraceLogs: (traceId) => run("listTraceLogs", [traceId]),
+			searchAiCalls: (input) => run("searchAiCalls", [input]),
+			getAiCall: (spanId) => run("getAiCall", [spanId]),
+			aiCallStats: (input) => run("aiCallStats", [input]),
+		})
+	}),
+)