overmux 0.0.10 → 0.0.12

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # overmux
 
+## 0.0.12
+
+### Patch Changes
+
+- [#43](https://github.com/richardgill/overmux/pull/43) [`b392280`](https://github.com/richardgill/overmux/commit/b3922800cfe31ca3d85c76fa3d364d146d96df88) Thanks [@richardgill](https://github.com/richardgill)! - Add structured `context.logger` logging to resource, stream, and operation handlers, with automatic capability and request/session correlation and safe cleanup logging.
+
+  Replace the top-level `debug` boolean with `logLevel: "debug" | "info" | "warn" | "error"`, defaulting to `"info"` in development and production. Runtime and handler events use the same severity threshold with no lifecycle exceptions; browser console forwarding is enabled only at `"debug"`. Remove `debug` from existing configuration and use `logLevel: "debug"` when investigating. The runtime protocol version increases to reject older browser manifests.
+
+- [#46](https://github.com/richardgill/overmux/pull/46) [`053f7b6`](https://github.com/richardgill/overmux/commit/053f7b6cf03050e6499905fc9d71bdf5a9894fde) Thanks [@richardgill](https://github.com/richardgill)! - Isolate each named stream from the shared resource/operation worker. Query, subscription, and derived resources continue to run together with operations; each named stream has its own worker.
+
+  Remove `context.invalidate` from stream handlers. Resource and operation contexts retain invalidation. Use an operation to mutate data and invalidate resources, or a subscription resource watcher to refresh clients when an external source changes.
+
+## 0.0.11
+
+### Patch Changes
+
+- [#40](https://github.com/richardgill/overmux/pull/40) [`1a8bf22`](https://github.com/richardgill/overmux/commit/1a8bf22fb787b78a0beb8212fa33b074bfb9e9e5) Thanks [@richardgill](https://github.com/richardgill)! - Brand background notifications with the Overmux logo on a light background and a monochrome Android status-bar badge. Ship the notification images with the runtime so they remain available in development and production, including after session expiry.
+
+- [#42](https://github.com/richardgill/overmux/pull/42) [`910ca21`](https://github.com/richardgill/overmux/commit/910ca216beeedeb7326baad6625452bb691fc801) Thanks [@richardgill](https://github.com/richardgill)! - Add a synchronous `onBeforeInputEvent` desktop configuration hook for the remote Overmux view and owned native web views, with cancellation before native-view passthrough. Document the hook and Linux Super+C/V configuration in the configuration reference.
+
+- [#38](https://github.com/richardgill/overmux/pull/38) [`cfc58d8`](https://github.com/richardgill/overmux/commit/cfc58d8881fa847fc15f7a5a02c2ad5e702ebe02) Thanks [@richardgill](https://github.com/richardgill)! - Fix browser background notifications with a runtime-owned push service worker in development and production. Enable now registers an active worker with bounded failure reporting; notification clicks only navigate within the current origin.
+
 ## 0.0.10
 
 ### Patch Changes

package/dist/bin.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire, findPackageJSON } from "node:module";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { constants, cpSync, createWriteStream, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import { access, open, readFile, readdir, realpath } from "node:fs/promises";
 import { createConnection, isIP } from "node:net";
@@ -1853,6 +1853,12 @@ var createInstanceIdentity = (instanceId) => ({
 	instanceId: instanceIdSchema$1.parse(instanceId),
 	deepLinkPrefix: `overmux://${instanceId}`
 });
+var logLevelSchema$1 = z.enum([
+	"debug",
+	"info",
+	"warn",
+	"error"
+]);
 //#endregion
 //#region ../shared/dist/node/index.js
 var durationPattern = /^([1-9]\d*)(ms|s|m|h|d)$/;
@@ -1872,6 +1878,12 @@ var durationToMilliseconds = (duration) => {
 };
 var aiContextSnippets = ["package-source", "tech-stack-recommendations"];
 var instanceIdSchema = z.string().max(253).regex(/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?(?![\s\S])/, "Expected a lowercase instance ID with only ASCII letters, digits, internal dots and hyphens");
+var logLevelSchema = z.enum([
+	"debug",
+	"info",
+	"warn",
+	"error"
+]);
 var zodTypeSchema = z.custom((value) => value instanceof z.ZodType, "Expected a Zod schema");
 var functionSchema = z.custom((value) => typeof value === "function", "Expected a function");
 var contractRuntimeSchema = z.object({
@@ -1937,11 +1949,11 @@ var serverDefinitionRuntimeSchema = z.object({
 var configDefinitionRuntimeSchema = serverConfigRuntimeSchema.extend({
 	aiContextSnippets: z.array(z.enum(aiContextSnippets)).optional(),
 	auth: authConfigRuntimeSchema,
-	debug: z.boolean().optional(),
+	logLevel: logLevelSchema.optional(),
 	instanceId: z.union([instanceIdSchema, z.custom((value) => typeof value === "function", "Expected an instance ID or a function of the bound port")]).optional(),
 	server: serverDefinitionRuntimeSchema,
 	vite: z.string().min(1).optional()
-});
+}).strict();
 var resolveLogicalPath = async (path) => {
 	const logicalPath = resolve(path);
 	return {
@@ -2396,9 +2408,9 @@ var backgroundNotificationSubscriptionSchema = z.object({
 z.object({ publicKey: deliveryKeySchema }).strict();
 z.object({ endpoint: backgroundNotificationSubscriptionSchema.shape.endpoint }).strict();
 z.object({
-	debug: z.boolean(),
+	logLevel: logLevelSchema$1,
 	operations: z.array(z.string().min(1)),
-	protocolVersion: z.literal(10),
+	protocolVersion: z.literal(11),
 	resources: z.array(z.string().min(1)),
 	streams: z.array(z.string().min(1))
 });
@@ -2601,6 +2613,31 @@ var createRuntimeLifecycle = (preparationSignal) => {
 	};
 };
 //#endregion
+//#region src/internal/server/runtime/handler-logger.ts
+var createHandlerLogger = ({ serverLogger, correlation = {}, ...identity }) => {
+	const { correlationId = randomUUID(), ...session } = correlation;
+	const log = (level, event, data) => {
+		try {
+			serverLogger?.log({
+				correlationId,
+				details: {
+					...identity,
+					...session,
+					data
+				},
+				event,
+				level
+			});
+		} catch {}
+	};
+	return {
+		debug: (event, details) => log("debug", event, details),
+		info: (event, details) => log("info", event, details),
+		warn: (event, details) => log("warn", event, details),
+		error: (event, details) => log("error", event, details)
+	};
+};
+//#endregion
 //#region src/internal/server/runtime/runtime-operations.ts
 var OperationValidationError = class extends Error {
 	phase;
@@ -2609,18 +2646,25 @@ var OperationValidationError = class extends Error {
 		this.phase = phase;
 	}
 };
-var createRuntimeOperations = ({ context, definitions, notifications }) => {
+var createRuntimeOperations = ({ context, definitions, notifications, serverLogger }) => {
 	const operations = /* @__PURE__ */ new Map();
 	Object.entries(definitions).forEach(([name, definition]) => {
 		if (!name) throw new Error("Operation names must not be empty");
 		operations.set(name, {
-			execute: async (rawInput, signal) => {
+			execute: async (rawInput, signal, correlation) => {
 				const operationContext = context(signal);
 				operationContext.signal.throwIfAborted();
 				const input = definition.input.safeParse(rawInput);
 				if (!input.success) throw new OperationValidationError("input", input.error);
 				const rawOutput = await definition.handle(input.data, {
 					...operationContext,
+					logger: createHandlerLogger({
+						serverLogger,
+						correlation,
+						capabilityKind: "operation",
+						registeredName: name,
+						handler: "handle"
+					}),
 					notifications
 				});
 				operationContext.signal.throwIfAborted();
@@ -2732,6 +2776,14 @@ var getInvalidatedResourceIds = (graph, resourceId) => {
 };
 //#endregion
 //#region src/internal/server/runtime/runtime-resources.ts
+var parseDependencyInputs = (definitions, graph, id, rawInput, inputs = /* @__PURE__ */ new Map()) => {
+	if (inputs.has(id)) return inputs;
+	inputs.set(id, definitions[id].contract.input.parse(rawInput));
+	graph.dependencies.get(id)?.forEach((dependencyId) => {
+		parseDependencyInputs(definitions, graph, dependencyId, rawInput, inputs);
+	});
+	return inputs;
+};
 var createSubscriptionLifetime = ({ entry, invalidationListeners, lifecycle, signal }) => {
 	const controller = new AbortController();
 	const subscriptionSignal = AbortSignal.any([lifecycle.requestSignal(signal), controller.signal]);
@@ -2743,23 +2795,23 @@ var createSubscriptionLifetime = ({ entry, invalidationListeners, lifecycle, sig
 		}
 	};
 	const disposers = [];
+	const subscription = {
+		disposers,
+		dispose: () => {
+			controller.abort(/* @__PURE__ */ new Error("Resource subscription closed"));
+			return release();
+		},
+		refresh: registeredEntry.listener,
+		signal: subscriptionSignal
+	};
 	const release = lifecycle.track(async () => {
 		invalidationListeners.delete(registeredEntry);
 		await lifecycle.disposeAll(disposers);
 	}, subscriptionSignal);
-	const dispose = () => {
-		controller.abort(/* @__PURE__ */ new Error("Resource subscription closed"));
-		return release();
-	};
 	invalidationListeners.add(registeredEntry);
-	return {
-		dispose,
-		disposers,
-		refresh: registeredEntry.listener,
-		signal: subscriptionSignal
-	};
+	return subscription;
 };
-var createRuntimeResources = ({ definitions, instance, lifecycle }) => {
+var createRuntimeResources = ({ definitions, instance, lifecycle, serverLogger }) => {
 	const graph = createResourceDependencyGraph(definitions);
 	const invalidationListeners = /* @__PURE__ */ new Set();
 	const resources = /* @__PURE__ */ new Map();
@@ -2767,11 +2819,11 @@ var createRuntimeResources = ({ definitions, instance, lifecycle }) => {
 		if (lifecycle.signal.aborted) return;
 		const ids = getInvalidatedResourceIds(graph, id);
 		invalidationListeners.forEach((entry) => {
-			if (ids.has(entry.resourceId) && (allInputs || isDeepStrictEqual(entry.input, input))) entry.listener();
+			if (ids.has(entry.resourceId) && (allInputs || isDeepStrictEqual(entry.inputs.get(id), input))) entry.listener();
 		});
 	};
 	const invalidate = (resourceId, input) => {
-		if (!resources.has(resourceId)) throw new Error(`Unknown resource ID: ${resourceId}`);
+		if (!Object.hasOwn(definitions, resourceId)) throw new Error(`Unknown resource ID: ${resourceId}`);
 		const definition = definitions[resourceId];
 		const parsedInput = input === void 0 ? void 0 : definition.contract.input.parse(input);
 		invalidateResource(resourceId, parsedInput, input === void 0);
@@ -2781,43 +2833,68 @@ var createRuntimeResources = ({ definitions, instance, lifecycle }) => {
 		invalidate,
 		signal: lifecycle.requestSignal(signal)
 	});
-	const read = async (id, rawInput, signal) => {
-		const definition = definitions[id];
-		const operationSignal = lifecycle.requestSignal(signal);
-		operationSignal.throwIfAborted();
-		const input = definition.contract.input.parse(rawInput);
-		const rawOutput = definition.kind === "derived" ? definition.combine(Object.fromEntries(await Promise.all(Object.entries(definition.dependencies).map(async ([name, dependencyId]) => [name, await read(dependencyId, rawInput, signal)])))) : await definition.read(input, context(signal));
-		operationSignal.throwIfAborted();
-		return definition.contract.output.parse(rawOutput);
+	const read = (id, rawInput, signal, correlation = { correlationId: randomUUID() }, reads = /* @__PURE__ */ new Map()) => {
+		const existing = reads.get(id);
+		if (existing) return existing;
+		const pending = readDefinition(id, rawInput, signal, correlation, reads);
+		reads.set(id, pending);
+		return pending;
 	};
-	const activateSubscriptions = async (id, rawInput, signal, activated, disposers) => {
-		signal.throwIfAborted();
-		if (activated.has(id)) return;
-		activated.add(id);
+	const readDefinition = async (id, rawInput, signal, correlation, reads) => {
 		const definition = definitions[id];
+		const handlerContext = {
+			...context(signal),
+			logger: createHandlerLogger({
+				serverLogger,
+				correlation,
+				capabilityKind: "resource",
+				registeredName: id,
+				handler: "read"
+			})
+		};
+		handlerContext.signal.throwIfAborted();
 		const input = definition.contract.input.parse(rawInput);
-		if (definition.kind === "subscription") {
-			const dispose = await definition.subscribe(input, () => {
-				if (!signal.aborted) invalidateResource(id, input);
-			}, context(signal));
-			if (typeof dispose !== "function") throw new Error(`Resource ${id} subscribe must return a disposer`);
-			if (signal.aborted) {
-				await dispose();
-				signal.throwIfAborted();
+		const dependencies = definition.kind === "derived" ? Object.fromEntries(await Promise.all(Object.entries(definition.dependencies).map(async ([name, dependencyId]) => [name, await read(dependencyId, rawInput, handlerContext.signal, correlation, reads)]))) : void 0;
+		handlerContext.signal.throwIfAborted();
+		const output = definition.kind === "derived" ? definition.combine(dependencies) : await definition.read(input, handlerContext);
+		handlerContext.signal.throwIfAborted();
+		return definition.contract.output.parse(output);
+	};
+	const activateSubscriptions = async (inputs, subscription, correlation) => {
+		for (const [id, input] of inputs) {
+			subscription.signal.throwIfAborted();
+			const definition = definitions[id];
+			if (definition.kind === "subscription") {
+				const dispose = await definition.subscribe(input, () => {
+					if (!subscription.signal.aborted) invalidateResource(id, input);
+				}, {
+					...context(subscription.signal),
+					logger: createHandlerLogger({
+						serverLogger,
+						correlation,
+						capabilityKind: "resource",
+						registeredName: id,
+						handler: "subscribe"
+					})
+				});
+				if (typeof dispose !== "function") throw new Error(`Resource ${id} subscribe must return a disposer`);
+				if (subscription.signal.aborted) {
+					await dispose();
+					subscription.signal.throwIfAborted();
+				}
+				subscription.disposers.push(dispose);
 			}
-			disposers.push(dispose);
-			return;
 		}
-		if (definition.kind === "derived") for (const dependencyId of graph.dependencies.get(id) ?? []) await activateSubscriptions(dependencyId, rawInput, signal, activated, disposers);
 	};
 	Object.keys(definitions).forEach((name) => {
 		resources.set(name, {
-			read: (input, signal) => read(name, input, signal),
-			subscribe: async (rawInput, listener, signal) => {
+			read: (rawInput, signal, correlation) => read(name, rawInput, signal, correlation),
+			subscribe: async (rawInput, listener, signal, _onError, correlation = { correlationId: randomUUID() }) => {
 				lifecycle.requestSignal(signal).throwIfAborted();
+				const inputs = parseDependencyInputs(definitions, graph, name, rawInput);
 				const subscription = createSubscriptionLifetime({
 					entry: {
-						input: definitions[name].contract.input.parse(rawInput),
+						inputs,
 						listener,
 						resourceId: name
 					},
@@ -2826,7 +2903,7 @@ var createRuntimeResources = ({ definitions, instance, lifecycle }) => {
 					signal
 				});
 				try {
-					await activateSubscriptions(name, rawInput, subscription.signal, /* @__PURE__ */ new Set(), subscription.disposers);
+					await activateSubscriptions(inputs, subscription, correlation);
 					subscription.signal.throwIfAborted();
 					subscription.refresh();
 					subscription.signal.throwIfAborted();
@@ -2851,11 +2928,11 @@ var createRuntimeResources = ({ definitions, instance, lifecycle }) => {
 };
 //#endregion
 //#region src/internal/server/runtime/runtime-streams.ts
-var createRuntimeStreams = ({ context, definitions, lifecycle }) => {
+var createRuntimeStreams = ({ instance, definitions, lifecycle, serverLogger }) => {
 	const streams = /* @__PURE__ */ new Map();
 	Object.entries(definitions).forEach(([name, definition]) => {
 		if (!name) throw new Error("Stream names must not be empty");
-		streams.set(name, { open: async (rawInput, emit, requestSignal, onError) => {
+		streams.set(name, { open: async (rawInput, emit, requestSignal, onError, correlation) => {
 			const sessionController = new AbortController();
 			const sessionSignal = requestSignal ? AbortSignal.any([requestSignal, sessionController.signal]) : sessionController.signal;
 			const operationSignal = lifecycle.requestSignal(sessionSignal);
@@ -2874,7 +2951,14 @@ var createRuntimeStreams = ({ context, definitions, lifecycle }) => {
 				if (opened) onError?.(cause);
 			};
 			const session = await definition.open(input, {
-				...context(sessionSignal),
+				instance,
+				logger: createHandlerLogger({
+					serverLogger,
+					correlation,
+					capabilityKind: "stream",
+					registeredName: name,
+					handler: "open"
+				}),
 				emit: (message) => {
 					if (operationSignal.aborted) return;
 					try {
@@ -2921,32 +3005,35 @@ var createRuntimeStreams = ({ context, definitions, lifecycle }) => {
 };
 //#endregion
 //#region src/internal/server/runtime/create-runtime.ts
-var createRuntime = async ({ config, debug = true, notifications = { send: async () => void 0 }, signal }) => {
+var createRuntime = async ({ config, notifications = { send: async () => void 0 }, signal, serverLogger }) => {
 	const lifecycle = createRuntimeLifecycle(signal);
 	const instance = createRuntimeInstance(config.instanceId ?? defaultInstanceId);
 	try {
 		const resources = createRuntimeResources({
 			definitions: config.server.resources ?? {},
 			instance: instance.context,
-			lifecycle
+			lifecycle,
+			serverLogger
 		});
 		const context = resources.context;
 		const operations = createRuntimeOperations({
 			context,
 			definitions: config.server.operations ?? {},
-			notifications
+			notifications,
+			serverLogger
 		});
 		const streams = createRuntimeStreams({
-			context,
+			instance: instance.context,
 			definitions: config.server.streams ?? {},
-			lifecycle
+			lifecycle,
+			serverLogger
 		});
 		lifecycle.signal.throwIfAborted();
 		lifecycle.completePreparation();
 		const manifest = {
-			debug,
+			logLevel: serverLogger?.logLevel ?? config.logLevel ?? "info",
 			operations: [...operations.names],
-			protocolVersion: 10,
+			protocolVersion: 11,
 			resources: [...resources.names],
 			streams: [...streams.names]
 		};
@@ -3165,7 +3252,7 @@ var errorMessage = (cause) => cause instanceof Error ? cause.message : String(ca
 var childOptionsSchema = z.object({
 	configAliases: z.record(z.string(), z.string()).optional(),
 	configPath: z.string(),
-	debug: z.boolean().optional(),
+	logLevel: logLevelSchema$1.optional(),
 	developmentWebTarget: z.url().optional(),
 	host: z.string().optional(),
 	port: z.number().int().min(0).max(65535).optional(),