overmux 0.0.8 → 0.0.9

package/docs/100-introduction/300-why-i-built-overmux.md

@@ -19,4 +19,4 @@ I lived in a customized tmux setup. But kept noticing that that the terminal, fo
 
 [Herdr](https://github.com/herdrdev/herdr) (a TUI) and [Orca](https://github.com/stablyai/orca) (web based) offer a decent default experience. But they lack the customizability I love with the terminal and neovim. They use their own muxer implementations and dictate workflows.
 
-This future filled me with existential dread, so I built Overmux to embed my terminal in a Desktop webapp and build my own experience with a mix of tmux terminals + custom web uis.
+This future didn't _spark joy_ for me, so I built Overmux to embed my terminal in a Desktop webapp and build my own experience with a mix of tmux terminals + custom web uis.

package/docs/200-getting-started/200-install-overmux-desktop.md

@@ -22,6 +22,19 @@ Download the ZIP for your Mac from the [Overmux releases](https://github.com/ric
 
 Overmux is not currently signed or notarized. Follow [Apple's instructions for opening an app from an unidentified developer](https://support.apple.com/en-us/102445) to allow it to run.
 
+<details>
+<summary>macOS says Overmux is damaged or the developer cannot be verified</summary>
+
+For quarantine-related blocking, run this **only for a trusted download from [official Overmux releases](https://github.com/richardgill/overmux/releases)**:
+
+```bash
+xattr -dr com.apple.quarantine "$HOME/Applications/Overmux.app"
+```
+
+Use `/Applications/Overmux.app` instead if you installed it there. Then reopen Overmux in Finder.
+
+</details>
+
 ## Linux
 
 Download the AppImage or Debian package from the [Overmux releases](https://github.com/richardgill/overmux/releases).

package/docs/400-reference/500-server/100-resources.md

@@ -73,6 +73,31 @@ When the subscription ends, Overmux calls the cleanup function returned by `subs
 
 The React code stays the same: `useResource({ id: "ls" })`.
 
+### Asynchronous setup
+
+`subscribe` can be synchronous or asynchronous. Both forms return a cleanup function. For example, replace the `ls` resource's `subscribe` handler to resolve the directory's canonical path before watching it:
+
+```ts
+import { watch } from "node:fs";
+import { realpath } from "node:fs/promises";
+
+// Inside the resource definition:
+subscribe: async (_input, invalidate, context) => {
+  const directory = await realpath("/");
+  // The subscription may have ended while resolving the path.
+  context.signal.throwIfAborted();
+
+  const watcher = watch(directory, { signal: context.signal }, () => {
+    invalidate();
+  });
+  return () => watcher.close();
+},
+```
+
+`context.signal` is an `AbortSignal` that Overmux aborts when the client unsubscribes, disconnects, or the server shuts down. Cancellation does not automatically stop an async function: pass the signal to APIs that support it and check it after awaiting setup. Here, `realpath` does not accept a signal, so `throwIfAborted()` prevents starting a watcher if cancellation happened during that work.
+
+Overmux calls the returned cleanup function once, even if setup finishes after cancellation. Cleanup may also be asynchronous. In this example, the signal can close the watcher before Overmux calls cleanup; `watcher.close()` is safe to call again. If setup throws before returning cleanup, your handler must release any resources it already acquired.
+
 ## Derived
 
 Derived resources compute a value from other resources.

package/docs/400-reference/500-server/500-api.md

@@ -47,7 +47,7 @@ A resource definition has a `contract` created with `defineResourceContract({ in
 | Kind | Required handler API |
 | --- | --- |
 | `query` | `read(input, context) => output \| Promise<output>` |
-| `subscription` | `read(input, context)` and `subscribe(input, invalidate, context) => disposer` |
+| `subscription` | `read(input, context)` and `subscribe(input, invalidate, context) => (() => void \| Promise<void>) \| Promise<() => void \| Promise<void>>` |
 | `derived` | `dependencies` and `combine(dependencies) => output` |
 
 ```ts
@@ -69,7 +69,9 @@ const resources = {
 };
 ```
 
-`subscribe` must synchronously return a cleanup function. Overmux calls it when that client subscription, or the server runtime, closes. A derived resource reads the resources named by `dependencies`; invalidating a dependency also invalidates its dependants. See [Resources](./100-resources.md) for contracts, derived dependencies, and invalidation.
+`subscribe` returns a cleanup function, directly or asynchronously. Overmux aborts `context.signal` when the subscription ends, including during setup, on client disconnect, or on server shutdown. Overmux calls the returned cleanup function once, even if setup returns it after cancellation. The cleanup function itself may also be asynchronous. If setup throws before returning cleanup, the handler must release any resources it already acquired. See [Asynchronous setup](./100-resources.md#asynchronous-setup) for an example.
+
+A derived resource reads the resources named by `dependencies`; invalidating a dependency also invalidates its dependants. See [Resources](./100-resources.md) for contracts, derived dependencies, and invalidation.
 
 ## Stream handlers
 

package/docs/400-reference/600-client/010-commands.md

@@ -158,32 +158,3 @@ const CommandMenu = () => {
 Each entry exposes `id`, `title`, `bindings`, `enabled`, and `execute()`. The list includes disabled commands but excludes commands without a registration.
 
 Each command appears once, even if multiple components register it. `execute()` selects the handler using the current focus and runs it only if enabled.
-
-## Using commands from packages
-
-Packages can export commands to include alongside your own:
-
-```tsx
-import { sourceControlCommands } from "@overmux/git/react";
-
-export const client = defineOvermuxClient({
-  commands: {
-    ...commands,
-    ...sourceControlCommands,
-  },
-  component: App,
-});
-```
-
-Adding commands to the registry does not register their handlers. For this package, pass the commands to `SourceControlView`:
-
-```tsx
-<SourceControlView
-  {...sourceControlProps}
-  commandHandles={sourceControlCommands}
-/>
-```
-
-The view registers handlers for navigating changed files and scrolling diffs. They then appear in `useCommands()` alongside your own registered commands.
-
-Keep command IDs unique when combining registries, and pass the same command objects to the client and the component.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "overmux",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "license": "MIT",
   "homepage": "https://github.com/richardgill/overmux",
   "repository": {

package/src/internal/client/overmux-react.ts

@@ -127,13 +127,131 @@ const useCanonicalInput = (input: unknown) => {
   return useMemo(() => (key ? JSON.parse(key) : undefined), [key]);
 };
 
+// Query identity shares pending work across observers without retaining unused cache entries.
+const pendingResourceInvalidations = new WeakSet<object>();
+
+type ResourceQuery = {
+  queryClient: ReturnType<typeof useQueryClient>;
+  queryKey: readonly unknown[];
+};
+
+const invalidateResource = ({ queryClient, queryKey }: ResourceQuery) => {
+  const query = queryClient.getQueryCache().find({ exact: true, queryKey });
+
+  if (query && query.state.fetchStatus !== "idle") {
+    // TanStack coalesces initial-read invalidations into that same read. Queue a
+    // follow-up instead, without cancelling reads or overlooking same-turn changes.
+    pendingResourceInvalidations.add(query);
+    return;
+  }
+
+  if (query) {
+    pendingResourceInvalidations.delete(query);
+  }
+
+  void queryClient.invalidateQueries({ exact: true, queryKey });
+};
+
+const flushResourceInvalidation = ({
+  queryClient,
+  queryKey,
+}: ResourceQuery) => {
+  const query = queryClient.getQueryCache().find({ exact: true, queryKey });
+
+  if (!query || query.state.fetchStatus !== "idle") {
+    return;
+  }
+
+  // All observers see settlement. Consuming the shared flag before starting a read
+  // ensures their callbacks cannot keep triggering each other's follow-up reads.
+  if (pendingResourceInvalidations.delete(query)) {
+    void queryClient.invalidateQueries({ exact: true, queryKey });
+  }
+};
+
+const useResourceInvalidation = ({
+  queryKey,
+  skipped,
+}: {
+  queryKey: readonly [id: string, input: unknown];
+  skipped: boolean;
+}) => {
+  const [id, canonicalInput] = queryKey;
+  const { manifest, overmuxServerApi } = useRuntime();
+  const queryClient = useQueryClient();
+  const invalidate = useCallback(
+    () => invalidateResource({ queryClient, queryKey }),
+    [queryClient, queryKey],
+  );
+
+  useEffect(() => {
+    if (skipped) {
+      return;
+    }
+
+    let active = true;
+    const cache = queryClient.getQueryCache();
+    const observedQuery = cache.find({ exact: true, queryKey });
+
+    // Fast reads can enter and leave fetching between React renders. Observe cache
+    // settlement directly, then defer the follow-up outside TanStack's notification.
+    const unsubscribe = cache.subscribe((event) => {
+      if (
+        event.type === "updated" &&
+        event.query === observedQuery &&
+        event.query.state.fetchStatus === "idle" &&
+        pendingResourceInvalidations.has(event.query)
+      ) {
+        queueMicrotask(() => {
+          if (active) {
+            flushResourceInvalidation({ queryClient, queryKey });
+          }
+        });
+      }
+    });
+
+    flushResourceInvalidation({ queryClient, queryKey });
+    return () => {
+      active = false;
+      unsubscribe();
+    };
+  }, [queryClient, queryKey, skipped]);
+
+  useEffect(() => {
+    if (skipped || !manifest.resources.includes(id)) {
+      return;
+    }
+
+    let active = true;
+    const unsubscribe = overmuxServerApi.subscribeResource({
+      id,
+      input: canonicalInput,
+      onError: () => active && invalidate(),
+      onInvalidate: () => active && invalidate(),
+    });
+
+    return () => {
+      active = false;
+      unsubscribe();
+    };
+  }, [
+    manifest.resources,
+    canonicalInput,
+    id,
+    invalidate,
+    overmuxServerApi,
+    skipped,
+  ]);
+
+  return invalidate;
+};
+
 const useResourceById = <TOutput>(
   id: string,
   input: unknown,
   skipped: boolean,
 ): ResourceResult<TOutput> | undefined => {
-  const { manifest, overmuxServerApi } = useRuntime();
-  const queryClient = useQueryClient();
+  const { overmuxServerApi } = useRuntime();
   const canonicalInput = useCanonicalInput(input);
   const queryKey = useMemo(
     () => [id, canonicalInput] as const,
@@ -148,31 +266,7 @@ const useResourceById = <TOutput>(
       }) as Promise<TOutput>,
     queryKey,
   });
-  useEffect(
-    () =>
-      !skipped && manifest.resources.includes(id)
-        ? overmuxServerApi.subscribeResource({
-            id,
-            input: canonicalInput,
-            onError: () =>
-              void queryClient.invalidateQueries({ exact: true, queryKey }),
-            onInvalidate: () =>
-              void queryClient.invalidateQueries({ exact: true, queryKey }),
-          })
-        : undefined,
-    [
-      manifest.resources,
-      canonicalInput,
-      id,
-      overmuxServerApi,
-      queryClient,
-      queryKey,
-      skipped,
-    ],
-  );
-  const refetch = useCallback(() => {
-    void queryClient.invalidateQueries({ exact: true, queryKey });
-  }, [queryClient, queryKey]);
+  const refetch = useResourceInvalidation({ queryKey, skipped });
   if (skipped) {
     return undefined;
   }

package/src/internal/server/runtime/runtime-resources.ts

@@ -19,7 +19,7 @@ export type RuntimeResource = {
     input: unknown,
     listener: () => void,
     signal?: AbortSignal,
-  ) => RuntimeDisposer;
+  ) => Promise<RuntimeDisposer>;
 };
 
 export type RuntimeResourceDefinitions = Readonly<
@@ -47,6 +47,51 @@ type CreateRuntimeResourcesOptions = {
   lifecycle: RuntimeLifecycle;
 };
 
+const createSubscriptionLifetime = ({
+  entry,
+  invalidationListeners,
+  lifecycle,
+  signal,
+}: {
+  entry: InvalidationListener;
+  invalidationListeners: Set<InvalidationListener>;
+  lifecycle: RuntimeLifecycle;
+  signal?: AbortSignal;
+}) => {
+  const controller = new AbortController();
+  const subscriptionSignal = AbortSignal.any([
+    lifecycle.requestSignal(signal),
+    controller.signal,
+  ]);
+  subscriptionSignal.throwIfAborted();
+  const registeredEntry = {
+    ...entry,
+    listener: () => {
+      if (!subscriptionSignal.aborted) {
+        entry.listener();
+      }
+    },
+  };
+  const disposers: RuntimeDisposer[] = [];
+  // Own the lifetime before invoking userland, which can invalidate and
+  // trigger unsubscribe synchronously, or await setup past cancellation.
+  const release = lifecycle.track(async () => {
+    invalidationListeners.delete(registeredEntry);
+    await lifecycle.disposeAll(disposers);
+  }, subscriptionSignal);
+  const dispose = () => {
+    controller.abort(new Error("Resource subscription closed"));
+    return release();
+  };
+  invalidationListeners.add(registeredEntry);
+  return {
+    dispose,
+    disposers,
+    refresh: registeredEntry.listener,
+    signal: subscriptionSignal,
+  };
+};
+
 export const createRuntimeResources = ({
   definitions,
   instance,
@@ -119,13 +164,14 @@ export const createRuntimeResources = ({
     return definition.contract.output.parse(rawOutput);
   };
 
-  const activateWatchers = (
+  const activateSubscriptions = async (
     id: string,
     rawInput: unknown,
-    signal: AbortSignal | undefined,
+    signal: AbortSignal,
     activated: Set<string>,
     disposers: RuntimeDisposer[],
-  ) => {
+  ): Promise<void> => {
+    signal.throwIfAborted();
     if (activated.has(id)) {
       return;
     }
@@ -133,44 +179,77 @@ export const createRuntimeResources = ({
     const definition = definitions[id]!;
     const input = definition.contract.input.parse(rawInput);
     if (definition.kind === "subscription") {
-      const dispose = definition.subscribe(
+      const dispose = await definition.subscribe(
         input,
-        () => invalidateResource(id, input),
+        () => {
+          if (!signal.aborted) {
+            invalidateResource(id, input);
+          }
+        },
         context(signal),
       );
       if (typeof dispose !== "function") {
         throw new Error(`Resource ${id} subscribe must return a disposer`);
       }
+      // Cancellation releases acquired resources without waiting for pending
+      // userland setup. A cleanup returned after cancellation is released here.
+      if (signal.aborted) {
+        await dispose();
+        signal.throwIfAborted();
+      }
       disposers.push(dispose);
       return;
     }
     if (definition.kind === "derived") {
-      graph.dependencies.get(id)?.forEach((dependencyId) => {
-        activateWatchers(dependencyId, rawInput, signal, activated, disposers);
-      });
+      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: (rawInput, listener, signal) => {
+      subscribe: async (rawInput, listener, signal) => {
         lifecycle.requestSignal(signal).throwIfAborted();
         const input = definitions[name]!.contract.input.parse(rawInput);
-        const entry = { input, listener, resourceId: name };
-        const watcherDisposers: RuntimeDisposer[] = [];
-        invalidationListeners.add(entry);
+        const subscription = createSubscriptionLifetime({
+          entry: { input, listener, resourceId: name },
+          invalidationListeners,
+          lifecycle,
+          signal,
+        });
         try {
-          activateWatchers(name, rawInput, signal, new Set(), watcherDisposers);
+          await activateSubscriptions(
+            name,
+            rawInput,
+            subscription.signal,
+            new Set(),
+            subscription.disposers,
+          );
+          subscription.signal.throwIfAborted();
+          // Refresh only this subscriber to cover changes during setup. Returning
+          // cleanup does not imply an external event source is already ready.
+          subscription.refresh();
+          subscription.signal.throwIfAborted();
+          return subscription.dispose;
         } catch (cause) {
-          invalidationListeners.delete(entry);
-          void lifecycle.disposeAll(watcherDisposers).catch(() => undefined);
+          try {
+            await subscription.dispose();
+          } catch (cleanupError) {
+            throw new AggregateError(
+              [cause, cleanupError],
+              "Resource subscription setup and cleanup failed",
+            );
+          }
           throw cause;
         }
-        return lifecycle.track(async () => {
-          invalidationListeners.delete(entry);
-          await lifecycle.disposeAll(watcherDisposers);
-        }, signal);
       },
     });
   });

package/src/internal/server/websocket-connection.ts

@@ -301,7 +301,7 @@ const subscribeResource = (
     state.subscriptions.set(message.subscriptionId, entry);
     const signal = AbortSignal.any([operationSignal, controller.signal]);
     try {
-      entry.dispose = resource.subscribe(
+      const dispose = await resource.subscribe(
         message.input,
         () =>
           void send(state, {
@@ -310,8 +310,33 @@ const subscribeResource = (
           }),
         signal,
       );
+      // While setup awaits, the client can unsubscribe and reuse this ID.
+      // Compare entry identity so late setup cannot attach to its replacement.
+      // Core makes cleanup safe to call again if cancellation already released it.
+      if (state.subscriptions.get(message.subscriptionId) === entry) {
+        entry.dispose = dispose;
+      } else {
+        await dispose();
+      }
     } catch (cause) {
-      await disposeSubscription(state, message.subscriptionId);
+      // A cancelled setup may settle after its ID has been reused. Do not
+      // remove the replacement or deliver the old failure to its client.
+      if (signal.aborted) {
+        // Ignore expected cancellation, but log other late failures,
+        // including cleanup errors, without sending them to the client.
+        if (cause !== signal.reason) {
+          state.serverLogger?.log({
+            correlationId: identity.operationId,
+            details: { ...identity, ...diagnosticErrorDetails(cause) },
+            event: "resource-subscription-cancelled-error",
+            level: "error",
+          });
+        }
+        return;
+      }
+      if (state.subscriptions.get(message.subscriptionId) === entry) {
+        await disposeSubscription(state, message.subscriptionId);
+      }
       throw cause;
     }
   });

package/src/public/config.ts

@@ -86,7 +86,7 @@ export type SubscriptionResourceDefinition<
     input: z.output<TInput>,
     invalidate: () => void,
     context: TContext,
-  ) => RuntimeDisposer;
+  ) => RuntimeDisposer | Promise<RuntimeDisposer>;
 };
 
 export type DerivedResourceDefinition<

package/dist/exports/index-Cz3xkCa4.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-Cz3xkCa4.d.ts","names":[],"sources":["../../../shared/dist/index.d.ts","../../../ai-context/dist/index.d.ts","../../src/public/ai-context.ts","../../src/public/notifications.ts","../../src/public/contracts.ts","../../src/public/config.ts"],"mappings":"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"}