@aryasaatvik/motel 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aryasaatvik/motel",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "A local OpenTelemetry ingest + TUI viewer for development, backed by SQLite.",
   "type": "module",
   "license": "MIT",
@@ -98,9 +98,10 @@
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@effect/atom-react": "4.0.0-beta.101",
-    "@effect/opentelemetry": "4.0.0-beta.101",
-    "@effect/platform-bun": "4.0.0-beta.101",
+    "@effect/atom-react": "4.0.0-rc.110",
+    "@effect/opentelemetry": "4.0.0-rc.110",
+    "@effect/platform-bun": "4.0.0-rc.110",
+    "@effect/platform-node-shared": "4.0.0-rc.110",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-logs-otlp-http": "^0.219.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.219.0",
@@ -111,7 +112,7 @@
     "@opentelemetry/sdk-trace-node": "^2.8.0",
     "@opentui/core": "0.4.2",
     "@opentui/react": "0.4.2",
-    "effect": "4.0.0-beta.101",
+    "effect": "4.0.0-rc.110",
     "protobufjs": "7.6.4",
     "react": "^19.2.7",
     "scheduler": "^0.27.0"

package/src/daemon.test.ts

@@ -226,6 +226,35 @@ describe("daemon manager", () => {
 		expect(finalStatus.running).toBe(false)
 	})
 
+	test("keeps one ingest generation usable after concurrent client aborts", async () => {
+		const harness = makeHarness()
+		activeHarnesses.push(harness)
+		const started = await Effect.runPromise(harness.manager.ensure)
+
+		await Promise.all(Array.from({ length: 50 }, async () => {
+			const controller = new AbortController()
+			const request = fetch(`http://127.0.0.1:${harness.port}/v1/traces`, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: "{}",
+				signal: controller.signal,
+			}).catch(() => undefined)
+			controller.abort()
+			await request
+		}))
+
+		for (const path of ["/v1/traces", "/v1/logs"]) {
+			const response = await fetch(`http://127.0.0.1:${harness.port}${path}`, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: "{}",
+			})
+			expect(response.ok).toBe(true)
+		}
+		const status = await Effect.runPromise(harness.manager.ensure)
+		expect(status.pid).toBe(started.pid)
+	})
+
 	test("health responds while ingest readiness waits for a write lock", async () => {
 		const harness = makeHarness()
 		activeHarnesses.push(harness)

package/src/launchAgent.test.ts

@@ -45,12 +45,13 @@ const daemonStatus = (overrides: Partial<DaemonStatus> = {}): DaemonStatus => ({
 	...overrides,
 })
 
-const makeHarness = (options: { readonly installed?: boolean; readonly missingExecutables?: readonly string[]; readonly plist?: Record<string, unknown>; readonly plutilExitCode?: number; readonly launchctlPrintExitCode?: number; readonly launchctlPrintStderr?: string; readonly bootoutExitCode?: number; readonly health?: DaemonStatus } = {}) => {
+const makeHarness = (options: { readonly installed?: boolean; readonly missingExecutables?: readonly string[]; readonly plist?: Record<string, unknown>; readonly plutilExitCode?: number; readonly launchctlPrintExitCode?: number; readonly launchctlPrintStderr?: string; readonly bootoutExitCode?: number; readonly health?: DaemonStatus; readonly readyAfter?: number } = {}) => {
 	let installed = options.installed ?? false
 	let plist = options.plist ?? plistValue()
 	let launchctlPrintExitCode = options.launchctlPrintExitCode ?? 113
 	const calls: Array<readonly string[]> = []
 	const fileEvents: string[] = []
+	let probeCalls = 0
 	const files = new Map<string, string>()
 	const operations: LaunchAgentOperations = {
 		platform: "darwin",
@@ -73,9 +74,10 @@ const makeHarness = (options: { readonly installed?: boolean; readonly missingEx
 			return { exitCode: 0, stdout: "", stderr: "" }
 		},
 		getDaemonStatus: async () => options.health ?? daemonStatus(),
+		probeDaemonIngest: async () => ++probeCalls > (options.readyAfter ?? 0),
 		version: "0.2.6",
 	}
-	return { calls, fileEvents, manager: createLaunchAgentManager(spec, operations) }
+	return { calls, fileEvents, get probeCalls() { return probeCalls }, manager: createLaunchAgentManager(spec, operations) }
 }
 
 describe("LaunchAgent specification", () => {
@@ -211,8 +213,9 @@ describe("LaunchAgent lifecycle", () => {
 	})
 
 	test("bootstraps an unloaded service before restarting it", async () => {
-		const harness = makeHarness({ installed: true, launchctlPrintExitCode: 113 })
+		const harness = makeHarness({ installed: true, launchctlPrintExitCode: 113, readyAfter: 2 })
 		await Effect.runPromise(harness.manager.restart)
+		expect(harness.probeCalls).toBe(3)
 		expect(harness.calls.filter(([command]) => command === "launchctl")).toEqual([
 			["launchctl", "print", spec.target],
 			["launchctl", "bootstrap", spec.domain, spec.plistPath],
@@ -276,6 +279,7 @@ describe("LaunchAgent lifecycle", () => {
 					return { exitCode: 0, stdout: "", stderr: "" }
 				},
 				getDaemonStatus: async () => daemonStatus(),
+				probeDaemonIngest: async () => true,
 				version: "0.2.6",
 			} satisfies LaunchAgentOperations),
 		})

package/src/launchAgent.ts

@@ -50,6 +50,7 @@ export type LaunchAgentOperations = {
 	readonly unlink: (file: string) => Promise<void>
 	readonly run: (command: string, args: readonly string[]) => Promise<CommandResult>
 	readonly getDaemonStatus: () => Promise<DaemonStatus>
+	readonly probeDaemonIngest: () => Promise<boolean>
 	readonly version: string
 }
 
@@ -206,6 +207,20 @@ export const compareLaunchAgent = (inspection: LaunchAgentInspection, spec: Laun
 
 const defaultOperations = (): LaunchAgentOperations => {
 	const daemon = createDaemonManager()
+	const probeDaemonIngest = async () => {
+		try {
+			const post = (path: string) => fetch(`http://127.0.0.1:27686${path}`, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: "{}",
+				signal: AbortSignal.timeout(3_000),
+			})
+			const [traces, logs] = await Promise.all([post("/v1/traces"), post("/v1/logs")])
+			return traces.ok && logs.ok
+		} catch {
+			return false
+		}
+	}
 	return {
 		exists: async (file) => fs.access(file).then(() => true).catch(() => false),
 		readFile: (file) => fs.readFile(file, "utf8"),
@@ -219,6 +234,7 @@ const defaultOperations = (): LaunchAgentOperations => {
 			return { exitCode, stdout, stderr }
 		},
 		getDaemonStatus: () => Effect.runPromise(daemon.getStatus),
+		probeDaemonIngest,
 		version: MOTEL_VERSION,
 		platform: process.platform,
 	}
@@ -299,6 +315,19 @@ export const createLaunchAgentManager = (spec = buildLaunchAgentSpec(), supplied
 			}
 		}
 	}
+	const waitForReady = async () => {
+		const deadline = Date.now() + 30_000
+		while (Date.now() < deadline) {
+			const health = await operations.getDaemonStatus()
+			if (health.running && health.managed && await operations.probeDaemonIngest()) return health
+			await Bun.sleep(100)
+		}
+		throw new LaunchAgentError("Motel LaunchAgent did not become ingest-ready within 30 seconds.")
+	}
+	const readyStatus = async () => {
+		await waitForReady()
+		return Effect.runPromise(status)
+	}
 	const inspect = Effect.tryPromise({ try: () => readInspection(operations, spec), catch: (error) => error instanceof LaunchAgentError ? error : new LaunchAgentError(error instanceof Error ? error.message : String(error)) })
 	const status = Effect.tryPromise({
 		try: async (): Promise<LaunchAgentStatus> => {
@@ -332,7 +361,7 @@ export const createLaunchAgentManager = (spec = buildLaunchAgentSpec(), supplied
 				await required(operations, "launchctl", ["bootstrap", spec.domain, spec.plistPath])
 				await required(operations, "launchctl", ["enable", spec.target])
 				await required(operations, "launchctl", ["kickstart", "-k", spec.target])
-				return Effect.runPromise(status)
+				return readyStatus()
 			}
 			await requireExecutables()
 			if (manager === "loaded" && !replace) throw new LaunchAgentError("Motel has a loaded LaunchAgent job that does not match the requested install state. Re-run with --replace to boot it out before installing.")
@@ -342,7 +371,7 @@ export const createLaunchAgentManager = (spec = buildLaunchAgentSpec(), supplied
 			await required(operations, "launchctl", ["bootstrap", spec.domain, spec.plistPath])
 			await required(operations, "launchctl", ["enable", spec.target])
 			await required(operations, "launchctl", ["kickstart", "-k", spec.target])
-			return Effect.runPromise(status)
+			return readyStatus()
 		},
 		catch: (error) => error instanceof LaunchAgentError ? error : new LaunchAgentError(error instanceof Error ? error.message : String(error)),
 	})
@@ -353,7 +382,7 @@ export const createLaunchAgentManager = (spec = buildLaunchAgentSpec(), supplied
 			const manager = requireKnownLaunchctlState(launchctlState(await optional(operations, "launchctl", ["print", spec.target])))
 			if (manager === "not-loaded") await required(operations, "launchctl", ["bootstrap", spec.domain, spec.plistPath])
 			await required(operations, "launchctl", ["kickstart", "-k", spec.target])
-			return Effect.runPromise(status)
+			return readyStatus()
 		},
 		catch: (error) => error instanceof LaunchAgentError ? error : new LaunchAgentError(error instanceof Error ? error.message : String(error)),
 	})
@@ -374,7 +403,7 @@ export const createLaunchAgentManager = (spec = buildLaunchAgentSpec(), supplied
 			const manager = requireKnownLaunchctlState(launchctlState(await optional(operations, "launchctl", ["print", spec.target])))
 			if (manager === "not-loaded") await required(operations, "launchctl", ["bootstrap", spec.domain, spec.plistPath])
 			await required(operations, "launchctl", ["kickstart", "-k", spec.target])
-			return Effect.runPromise(status)
+			return readyStatus()
 		},
 		catch: (error) => error instanceof LaunchAgentError ? error : new LaunchAgentError(error instanceof Error ? error.message : String(error)),
 	})

package/src/mcp.ts

@@ -2,7 +2,7 @@
 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 { McpProtocol, McpServer, Tool, Toolkit } from "effect/unstable/ai"
 import { TraceSpanStatus } from "./domain.js"
 import { MotelClient, MotelClientLive } from "./motelClient.js"
 import { Locator, LocatorLive } from "./locator.js"
@@ -424,6 +424,12 @@ const ServerLayer = McpServer.toolkit(MotelToolkit).pipe(
 		McpServer.layerStdio({
 			name: "motel",
 			version: MOTEL_VERSION,
+			protocols: [
+				McpProtocol.v2025_11_25,
+				McpProtocol.v2025_06_18,
+				McpProtocol.v2025_03_26,
+				McpProtocol.v2024_11_05,
+			],
 		}),
 	),
 	Layer.provide(BunStdio.layer),

package/src/motel.test.ts

@@ -172,5 +172,5 @@ describe("motel command tree", () => {
 		} finally {
 			fs.rmSync(temporaryPrefix, { recursive: true, force: true })
 		}
-	})
+	}, 20_000)
 })

package/src/motel.ts

@@ -39,7 +39,9 @@ const restart = Command.make("restart", {}, () =>
 ).pipe(Command.withDescription("Restart only the managed telemetry daemon"))
 
 const serviceManager = createLaunchAgentManager()
-const serviceInstall = Command.make("install", { replace: Flag.boolean("replace") }, ({ replace }) =>
+const serviceInstall = Command.make("install", {
+	replace: Flag.boolean("replace").pipe(Flag.withDefault(false)),
+}, ({ replace }) =>
 	serviceManager.install(replace).pipe(Effect.andThen(json)),
 ).pipe(Command.withDescription("Install the per-user Motel LaunchAgent"))
 const serviceStatus = Command.make("status", {}, () =>

package/src/services/AsyncIngest.ts

@@ -20,7 +20,7 @@
  */
 
 import * as BunWorker from "@effect/platform-bun/BunWorker"
-import { Context, Duration, Effect, Exit, Layer, Scope } from "effect"
+import { Context, Effect, 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,28 +55,26 @@ 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, invalidateClient] = yield* Effect.cachedInvalidateWithTTL(Effect.gen(function*() {
+		// The server scope owns exactly one lazy writer generation. Request
+		// failures must not replace it: concurrent stale failures can otherwise
+		// invalidate a newer cached generation and orphan its SQLite writer and
+		// maintenance fibers. A poisoned worker stays failed until the managed
+		// daemon is restarted, which the external ingest readiness probe handles.
+		const getClient = yield* Effect.cached(Effect.gen(function*() {
 			const clientScope = yield* Scope.fork(scope, "sequential")
 			const protocolContext = yield* Layer.buildWithScope(WorkerProtocol, clientScope)
-			const client = yield* RpcClient.make(IngestRpcs).pipe(
+			return yield* RpcClient.make(IngestRpcs).pipe(
 				Effect.provide(protocolContext),
 				Effect.provideService(Scope.Scope, clientScope),
 			)
-			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, 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)),
-				)),
+			ingestTraces: (input, options) => Effect.flatMap(getClient, (client) => client.ingestTraces(input, options)),
+			ingestLogs: (input, options) => Effect.flatMap(getClient, (client) => client.ingestLogs(input, options)),
 		}
 	}),
 )

package/src/services/TelemetryQuery.ts

@@ -1,5 +1,5 @@
 import * as BunWorker from "@effect/platform-bun/BunWorker"
-import { Duration, Effect, Exit, Layer, Scope } from "effect"
+import { Effect, 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"
@@ -9,17 +9,14 @@ 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(
+const query = <A>(getClient: Effect.Effect<QueryClient, unknown>, method: QueryMethod, args: readonly unknown[] = []) =>
+	Effect.flatMap(getClient, (client) => client.query({ method, args })).pipe(
 		Effect.map((result) => result as A),
 		Effect.mapError((error) => error instanceof Error ? error : new Error(String(error))),
 	)
@@ -28,16 +25,15 @@ export const TelemetryQueryLive = Layer.effect(
 	TelemetryStoreReadonly,
 	Effect.gen(function*() {
 		const scope = yield* Scope.Scope
-		const [getClient, invalidateClient] = yield* Effect.cachedInvalidateWithTTL(Effect.gen(function*() {
+		const getClient = yield* Effect.cached(Effect.gen(function*() {
 			const clientScope = yield* Scope.fork(scope, "sequential")
 			const protocolContext = yield* Layer.buildWithScope(WorkerProtocol, clientScope)
-			const client = yield* RpcClient.make(QueryRpcs).pipe(
+			return 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)
+		}))
+		const run = <A>(method: QueryMethod, args: readonly unknown[] = []) => query<A>(getClient, method, args)
 		return TelemetryStoreReadonly.of({
 			listServices: run("listServices"),
 			listRecentTraces: (serviceName, options) => run("listRecentTraces", [serviceName, options]),

package/src/services/TelemetryStore.ts

@@ -539,6 +539,9 @@ const makeTelemetryStoreEffect = (opts: TelemetryStoreOptions) =>
 			`)
 		} else {
 			db.exec(`
+				-- Wait for an existing writer to release startup locks before any
+				-- pragma that may need to update the database header.
+				PRAGMA busy_timeout = 15000;
 				-- Bump cache above the 2MB default. 64MB fits most hot index pages
 				-- (trace_summaries, spans, span_attributes indexes) in RAM even on
 				-- multi-GB databases, cutting cold-read latency meaningfully on
@@ -557,8 +560,7 @@ const makeTelemetryStoreEffect = (opts: TelemetryStoreOptions) =>
 			// existing DBs that predate this setting keep their current mode;
 			// Motel never performs a surprise full-file VACUUM at startup.
 			try { db.exec(`PRAGMA auto_vacuum = INCREMENTAL;`) } catch { /* ignore */ }
-			try {
-				db.exec(`
+			db.exec(`
 					PRAGMA journal_mode = WAL;
 					PRAGMA synchronous = NORMAL;
 					PRAGMA temp_store = MEMORY;
@@ -656,11 +658,7 @@ const makeTelemetryStoreEffect = (opts: TelemetryStoreOptions) =>
 						key TEXT PRIMARY KEY,
 						value TEXT NOT NULL
 					);
-				`)
-			} catch (err) {
-				if (!isSqliteLockError(err)) throw err
-				console.warn(`motel: writer bootstrap skipped during startup: ${(err as Error).message}`)
-			}
+			`)
 		}
 
 		// Tables detected at runtime. For writer connections these flags are

package/src/services/ingestRpc.ts

@@ -21,7 +21,7 @@ import { Schema } from "effect"
 import * as Rpc from "effect/unstable/rpc/Rpc"
 import * as RpcGroup from "effect/unstable/rpc/RpcGroup"
 
-export class IngestError extends Schema.TaggedErrorClass<IngestError>()("IngestError", {
+export class IngestError extends Schema.TaggedError<IngestError>()("IngestError", {
 	message: Schema.String,
 }) {}
 

package/src/services/queryRpc.ts

@@ -2,7 +2,7 @@ import { Schema } from "effect"
 import * as Rpc from "effect/unstable/rpc/Rpc"
 import * as RpcGroup from "effect/unstable/rpc/RpcGroup"
 
-export class QueryError extends Schema.TaggedErrorClass<QueryError>()("QueryError", {
+export class QueryError extends Schema.TaggedError<QueryError>()("QueryError", {
 	message: Schema.String,
 }) {}