diff --git a/packages/app/component-tests/plugin-host.fixture.tsx b/packages/app/component-tests/plugin-host.fixture.tsx index 1c0e17503a2..e338856a973 100644 --- a/packages/app/component-tests/plugin-host.fixture.tsx +++ b/packages/app/component-tests/plugin-host.fixture.tsx @@ -237,6 +237,8 @@ export function mountPlugins(input: { plugins?: readonly PluginInfo[] /** The client of an Ipc while main provides it, as a desktop window's bridge reports it. Omitted: the web. */ ipc?: (token: Ipc) => IpcClient | undefined + /** Whether main failed to answer the window's subscribe to an Ipc. */ + ipcFailed?: (token: Ipc) => boolean }) { const held = Promise.withResolvers() const saved = { ...input.stored } @@ -312,6 +314,7 @@ export function mountPlugins(input: { apis={fakeApis(storage)} whenMounted={mounted} ipc={input.ipc} + ipcFailed={input.ipcFailed} > diff --git a/packages/app/component-tests/plugin-host.spec.ts b/packages/app/component-tests/plugin-host.spec.ts index 0f397f74963..af89b937792 100644 --- a/packages/app/component-tests/plugin-host.spec.ts +++ b/packages/app/component-tests/plugin-host.spec.ts @@ -1066,6 +1066,7 @@ story( const Other = Ipc.define({ id: "other.ipc", methods: {} }) const [available, setAvailable] = createSignal(false) const [awake, setAwake] = createSignal(false) + const [failed, setFailed] = createSignal(false) const kept: Kept = {} const client = { @@ -1076,6 +1077,7 @@ story( const host = mountPlugins({ ipc: (token: { readonly id: string }) => (token.id === Awake.id && available() ? client : undefined), + ipcFailed: (token: { readonly id: string }) => token.id === Awake.id && failed(), definitions: [{ id: "acme", windowEntry: async () => ({ default: (ctx: Context) => void (kept.ctx = ctx) }) }], }) @@ -1085,6 +1087,16 @@ story( if (!ctx) throw new Error("the plugin never set up") const main = ctx.main(Awake) + // A call that waits rejects once main fails to answer the window's subscribe, instead of waiting forever. + const stuck = main.get() + setFailed(true) + + const unanswered = await stuck.then( + () => false, + (cause: unknown) => String(cause).includes("unavailable: failed"), + ) + + setFailed(false) const waiting = main.get() const before = main.state() setAwake(true) @@ -1111,10 +1123,11 @@ story( host.unmount() - return { before, answered, state, foreign, rejected, same: ctx.main(Awake) === main } + return { unanswered, before, answered, state, foreign, rejected, same: ctx.main(Awake) === main } }, fixture) expect(result).toEqual({ + unanswered: true, before: undefined, answered: true, state: { awake: true }, diff --git a/packages/app/src/runtime/plugin/host.tsx b/packages/app/src/runtime/plugin/host.tsx index fdcb7a8ee39..7378f4a67b8 100644 --- a/packages/app/src/runtime/plugin/host.tsx +++ b/packages/app/src/runtime/plugin/host.tsx @@ -156,6 +156,8 @@ type HostInput = { plugin?: (id: string) => PluginInput | undefined /** How many times an Ipc became available. Reactive. */ generation?: (token: Ipc) => number + /** Main did not answer the window's subscribe to an Ipc. Reactive. */ + ipcFailed?: (token: Ipc) => boolean } export function PluginHostProvider(props: ParentProps) { @@ -573,7 +575,12 @@ function createHost(input: HostInput) { const client = input.ipc(token) - if (!client) return absent(token.id, true) + if (!client) { + const reason = absent(token.id, true) + + // A provider that may still start, but whose subscribe failed, is not coming until main provides it again. + return reason === pending && input.ipcFailed?.(token) ? inactive.failed : reason + } const generation = input.generation?.(token) ?? 1 const cached = clients.get(token.id) diff --git a/packages/app/src/runtime/plugin/ipc-machine.test.ts b/packages/app/src/runtime/plugin/ipc-machine.test.ts new file mode 100644 index 00000000000..530fdc43a7b --- /dev/null +++ b/packages/app/src/runtime/plugin/ipc-machine.test.ts @@ -0,0 +1,172 @@ +import { expect, test } from "bun:test" +import { + createIpcState, + selectIpcAvailable, + selectIpcFailed, + selectIpcGeneration, + selectIpcNeedsSubscribe, + selectIpcValue, + transitionIpc, + type IpcEffect, + type IpcEvent, + type IpcState, +} from "./ipc-machine" + +/** Folds events through the machine, collecting every effect in order. */ +function replay(events: readonly IpcEvent[], from = createIpcState()) { + return events.reduce<{ state: IpcState; effects: IpcEffect[] }>( + (current, event) => { + const next = transitionIpc(current.state, event) + + return { state: next.state, effects: [...current.effects, ...next.effects] } + }, + { state: from, effects: [] }, + ) +} + +function view(state: IpcState, id = "acme.awake") { + return { + available: selectIpcAvailable(state, id), + value: selectIpcValue(state, id), + generation: selectIpcGeneration(state, id), + failed: selectIpcFailed(state, id), + subscribe: selectIpcNeedsSubscribe(state, id), + } +} + +const subscribe: IpcEvent = { type: "subscribe", id: "acme.awake" } + +// Before, a subscribe that rejected or never answered left the Ipc looking like it was still subscribing, so every +// `ctx.main()` call waited forever. +test.each<{ name: string; event: IpcEvent }>([ + { name: "rejects", event: { type: "failed", id: "acme.awake", attempt: 1, cause: new Error("boom") } }, + { name: "never answers", event: { type: "timeout", id: "acme.awake", attempt: 1 } }, +])("a subscribe that $name fails the Ipc without retrying on every read", (input) => { + const run = replay([subscribe, input.event, subscribe]) + + expect(run.effects.map((effect) => effect.type)).toEqual(["subscribe", "timer.start", "timer.stop", "log"]) + expect(view(run.state)).toEqual({ available: false, value: undefined, generation: 0, failed: true, subscribe: false }) +}) + +test("a failed Ipc subscribes again once main provides it again, keeping its generation count", () => { + const run = replay([ + subscribe, + { type: "failed", id: "acme.awake", attempt: 1, cause: "boom" }, + { type: "available", id: "acme.awake", available: false }, + { type: "available", id: "acme.awake", available: true }, + ]) + + expect(run.effects.slice(-2)).toEqual([ + { type: "subscribe", id: "acme.awake", attempt: 2 }, + { type: "timer.start", id: "acme.awake", attempt: 2 }, + ]) + + // The reply's own availability is older than the broadcast that started it. + const answered = transitionIpc(run.state, { + type: "subscribed", + id: "acme.awake", + attempt: 2, + available: false, + state: { awake: true }, + }) + + expect(view(answered.state)).toEqual({ + available: true, + value: { awake: true }, + generation: 1, + failed: false, + subscribe: false, + }) +}) + +test("results of an older subscribe change nothing", () => { + const run = replay([ + subscribe, + { type: "timeout", id: "acme.awake", attempt: 1 }, + { type: "available", id: "acme.awake", available: true }, + ]) + + const stale: IpcEvent[] = [ + { type: "subscribed", id: "acme.awake", attempt: 1, available: true, state: 1 }, + { type: "failed", id: "acme.awake", attempt: 1, cause: "late" }, + { type: "timeout", id: "acme.awake", attempt: 1 }, + ] + + stale.forEach((event) => expect(transitionIpc(run.state, event)).toEqual({ state: run.state, effects: [] })) +}) + +// Before, a state push or reply while the Ipc was unavailable stored a value its readers then saw. +test("an unavailable Ipc holds no state", () => { + const reply = replay([ + subscribe, + { type: "subscribed", id: "acme.awake", attempt: 1, available: false, state: { awake: true } }, + ]) + + expect(view(reply.state).value).toBeUndefined() + expect(transitionIpc(reply.state, { type: "state", id: "acme.awake", value: 1 }).state).toBe(reply.state) + + const gone = replay([ + subscribe, + { type: "state", id: "acme.awake", value: { awake: true } }, + { type: "available", id: "acme.awake", available: false }, + { type: "available", id: "acme.awake", available: true }, + { type: "subscribed", id: "acme.awake", attempt: 1, available: true, state: { awake: false } }, + ]) + + // Going away cleared both the push and the reply's older state. + expect(view(gone.state)).toMatchObject({ available: true, value: undefined, generation: 1 }) +}) + +test.each<{ name: string; event: IpcEvent; reply: { available: boolean; state: unknown }; expected: object }>([ + { + name: "the Ipc appearing", + event: { type: "available", id: "acme.awake", available: true }, + reply: { available: false, state: undefined }, + expected: { available: true, value: undefined, generation: 1 }, + }, + { + name: "the Ipc going away", + event: { type: "available", id: "acme.awake", available: false }, + reply: { available: true, state: { count: 1 } }, + expected: { available: false, value: undefined, generation: 0 }, + }, + { + name: "a state push", + event: { type: "state", id: "acme.awake", value: { count: 2 } }, + reply: { available: true, state: { count: 1 } }, + expected: { available: true, value: { count: 2 }, generation: 1 }, + }, +])("a subscribe reply older than $name keeps the event's data", (input) => { + const run = replay([subscribe, input.event, { type: "subscribed", id: "acme.awake", attempt: 1, ...input.reply }]) + + expect(view(run.state)).toMatchObject(input.expected) +}) + +test("availability broadcast before any read counts a generation once", () => { + const run = replay([ + { type: "available", id: "acme.awake", available: true }, + subscribe, + { type: "subscribed", id: "acme.awake", attempt: 1, available: true, state: undefined }, + { type: "available", id: "acme.awake", available: false }, + { type: "available", id: "acme.awake", available: true }, + ]) + + expect(view(run.state)).toMatchObject({ available: true, generation: 2 }) +}) + +test("disposing stops pending timers and ignores late replies", () => { + const run = replay([subscribe, { type: "disposed" }]) + + expect(run.effects.at(-1)).toEqual({ type: "timer.stop", id: "acme.awake" }) + + const late = transitionIpc(run.state, { + type: "subscribed", + id: "acme.awake", + attempt: 1, + available: true, + state: undefined, + }) + + expect(late.state).toBe(run.state) + expect(selectIpcNeedsSubscribe(run.state, "acme.awake")).toBe(false) +}) diff --git a/packages/app/src/runtime/plugin/ipc-machine.ts b/packages/app/src/runtime/plugin/ipc-machine.ts new file mode 100644 index 00000000000..1771c2d8b03 --- /dev/null +++ b/packages/app/src/runtime/plugin/ipc-machine.ts @@ -0,0 +1,213 @@ +export type IpcChannel = + /** Only main's availability broadcasts arrived; no window code asked for a client yet. */ + | { readonly status: "unsubscribed"; readonly available: boolean; readonly generation: number } + /** + * `subscribe` is in flight. `available` is the last availability known; `moved` is true once a broadcast arrived + * during the flight, which is newer than the reply. `pushed` is state main pushed during the flight. + */ + | { + readonly status: "subscribing" + readonly attempt: number + readonly generation: number + readonly available: boolean + readonly moved: boolean + readonly pushed: { readonly value: unknown } | undefined + } + | { readonly status: "available"; readonly generation: number; readonly value: unknown } + | { readonly status: "unavailable"; readonly generation: number } + /** The subscribe request failed or timed out; the next availability broadcast subscribes again. */ + | { readonly status: "failed"; readonly generation: number } + +export type IpcState = { + readonly status: "running" | "disposed" + readonly issued: number + readonly channels: Readonly> +} + +export type IpcEvent = + /** Window code asked for the Ipc's client. */ + | { readonly type: "subscribe"; readonly id: string } + | { + readonly type: "subscribed" + readonly id: string + readonly attempt: number + readonly available: boolean + /** The decoded state main sent with the reply, if any. */ + readonly state: unknown + } + | { readonly type: "failed"; readonly id: string; readonly attempt: number; readonly cause: unknown } + | { readonly type: "timeout"; readonly id: string; readonly attempt: number } + | { readonly type: "available"; readonly id: string; readonly available: boolean } + /** Decoded state main pushed. */ + | { readonly type: "state"; readonly id: string; readonly value: unknown } + | { readonly type: "disposed" } + +export type IpcEffect = + | { readonly type: "subscribe"; readonly id: string; readonly attempt: number } + | { readonly type: "timer.start"; readonly id: string; readonly attempt: number } + | { readonly type: "timer.stop"; readonly id: string } + | { readonly type: "log"; readonly id: string; readonly cause: unknown } + +export type IpcTransition = { readonly state: IpcState; readonly effects: readonly IpcEffect[] } + +export function createIpcState(): IpcState { + return { status: "running", issued: 0, channels: {} } +} + +export function transitionIpc(state: IpcState, event: IpcEvent): IpcTransition { + if (state.status === "disposed") return step(state) + + if (event.type === "disposed") + return step( + { status: "disposed", issued: state.issued, channels: {} }, + Object.entries(state.channels).flatMap(([id, channel]) => + channel.status === "subscribing" ? [{ type: "timer.stop", id } as const] : [], + ), + ) + + const channel = state.channels[event.id] + + if (event.type === "subscribe") { + if (channel && channel.status !== "unsubscribed") return step(state) + + return subscribe(state, event.id, { + generation: channel?.generation ?? 0, + available: channel?.available ?? false, + moved: false, + }) + } + + if (event.type === "available") return available(state, event.id, channel, event.available) + + if (event.type === "state") { + if (channel?.status === "subscribing") + return step(put(state, event.id, { ...channel, pushed: { value: event.value } })) + + if (channel?.status === "available") return step(put(state, event.id, { ...channel, value: event.value })) + + // Main pushes state only while it provides the Ipc. + return step(state) + } + + if (channel?.status !== "subscribing" || channel.attempt !== event.attempt) return step(state) + + if (event.type === "subscribed") { + // A broadcast during the flight is newer than the reply's availability, and a push newer than its state. + const live = channel.moved ? channel.available : event.available + const generation = live && !channel.available ? channel.generation + 1 : channel.generation + const stop = [{ type: "timer.stop", id: event.id } as const] + + if (!live) return step(put(state, event.id, { status: "unavailable", generation }), stop) + + return step( + put(state, event.id, { + status: "available", + generation, + value: channel.pushed ? channel.pushed.value : event.state, + }), + stop, + ) + } + + const cause = event.type === "failed" ? event.cause : new Error(`Ipc "${event.id}" did not answer the subscribe`) + + return step(put(state, event.id, { status: "failed", generation: channel.generation }), [ + { type: "timer.stop", id: event.id }, + { type: "log", id: event.id, cause }, + ]) +} + +/** Window code reading the client asks main for it: never yet asked, and the clients still run. */ +export function selectIpcNeedsSubscribe(state: IpcState, id: string) { + const channel = state.channels[id] + + return state.status === "running" && (!channel || channel.status === "unsubscribed") +} + +/** Main provides the Ipc, as far as the window knows. */ +export function selectIpcAvailable(state: IpcState, id: string) { + const channel = state.channels[id] + + return channel?.status === "available" || (channel?.status === "subscribing" && channel.available) +} + +export function selectIpcValue(state: IpcState, id: string) { + const channel = state.channels[id] + + if (channel?.status === "available") return channel.value + + if (channel?.status === "subscribing" && channel.available) return channel.pushed?.value + + return undefined +} + +/** How many times the Ipc became available; 0 until it first is. */ +export function selectIpcGeneration(state: IpcState, id: string) { + return state.channels[id]?.generation ?? 0 +} + +export function selectIpcFailed(state: IpcState, id: string) { + return state.channels[id]?.status === "failed" +} + +function available(state: IpcState, id: string, channel: IpcChannel | undefined, next: boolean): IpcTransition { + if (!channel) return step(put(state, id, { status: "unsubscribed", available: next, generation: next ? 1 : 0 })) + + const generation = next ? channel.generation + 1 : channel.generation + + if (channel.status === "unsubscribed") { + if (channel.available === next) return step(state) + + return step(put(state, id, { status: "unsubscribed", available: next, generation })) + } + + if (channel.status === "subscribing") + return step( + put(state, id, { + ...channel, + available: next, + moved: true, + generation: next && !channel.available ? generation : channel.generation, + // Going away clears the state too, so the reply's older state never shows. + pushed: next ? channel.pushed : { value: undefined }, + }), + ) + + if (channel.status === "available") { + if (next) return step(state) + + return step(put(state, id, { status: "unavailable", generation: channel.generation })) + } + + if (channel.status === "unavailable") { + if (!next) return step(state) + + return step(put(state, id, { status: "available", generation, value: undefined })) + } + + // A provider that comes back may answer a subscribe that failed before. + if (!next) return step(state) + + return subscribe(state, id, { generation, available: true, moved: true }) +} + +function subscribe( + state: IpcState, + id: string, + input: { readonly generation: number; readonly available: boolean; readonly moved: boolean }, +) { + const attempt = state.issued + 1 + + return step(put({ ...state, issued: attempt }, id, { status: "subscribing", attempt, pushed: undefined, ...input }), [ + { type: "subscribe", id, attempt }, + { type: "timer.start", id, attempt }, + ]) +} + +function put(state: IpcState, id: string, channel: IpcChannel): IpcState { + return { ...state, channels: { ...state.channels, [id]: channel } } +} + +function step(state: IpcState, effects: readonly IpcEffect[] = []): IpcTransition { + return { state, effects } +} diff --git a/packages/app/src/runtime/plugin/ipc.test.ts b/packages/app/src/runtime/plugin/ipc.test.ts index 0445aa2e5ef..5a257a044d8 100644 --- a/packages/app/src/runtime/plugin/ipc.test.ts +++ b/packages/app/src/runtime/plugin/ipc.test.ts @@ -72,14 +72,69 @@ test("no-input methods pass their first argument's abort signal to the bridge", ipcs.dispose() }) +test("a subscribe main rejects fails the Ipc until main provides it again", async () => { + const bridge = fakeBridge() + const ipcs = createIpcClients(bridge.value) + ipcs.client(token) + bridge.fail(new Error("main is busy")) + await Bun.sleep(0) + const failed = { failed: ipcs.failed(token), client: ipcs.client(token), subscribes: bridge.subscribes() } + bridge.emit({ type: "available", ipc: "fixture", available: true }) + bridge.reply({ available: true, state: { count: 1 } }) + await Bun.sleep(0) + + expect(failed).toEqual({ failed: true, client: undefined, subscribes: 1 }) + expect({ failed: ipcs.failed(token), state: ipcs.client(token)?.state(), subscribes: bridge.subscribes() }).toEqual({ + failed: false, + state: { count: 1 }, + subscribes: 2, + }) + ipcs.dispose() +}) + +test("a payload its codec rejects reaches no reader and does not stop the bridge's other listeners", async () => { + const bridge = fakeBridge() + const Counter = Ipc.define({ id: "fixture", methods: {}, state: Schema.Struct({ count: Schema.Number }) }) + const ipcs = createIpcClients(bridge.value) + const seen: string[] = [] + ipcs.typed(Counter) + bridge.value.on((message) => void seen.push(message.type)) + bridge.reply({ available: true, state: { count: 1 } }) + await Bun.sleep(0) + bridge.emit({ type: "state", ipc: "fixture", state: { count: "many" } }) + + expect({ seen, state: ipcs.typed(Counter)?.state() }).toEqual({ seen: ["state"], state: { count: 1 } }) + ipcs.dispose() +}) + +test("a subscribe reply that lands after dispose changes nothing", async () => { + const bridge = fakeBridge() + const ipcs = createIpcClients(bridge.value) + ipcs.client(token) + ipcs.dispose() + bridge.reply({ available: true }) + await Bun.sleep(0) + + expect({ client: ipcs.client(token), generation: ipcs.generation(token) }).toEqual({ + client: undefined, + generation: 0, + }) +}) + function fakeBridge() { const listeners = new Set<(message: BridgeMessage) => void>() - const pending = Promise.withResolvers() + // One reply per subscribe, answered in order. + const replies: PromiseWithResolvers[] = [] const value: Bridge = { packaged: false, call: () => Promise.reject(new Error("no calls in this test")), - subscribe: () => pending.promise, + subscribe: () => { + const reply = Promise.withResolvers() + replies.push(reply) + + return reply.promise + }, on: (listener) => { listeners.add(listener) @@ -103,6 +158,9 @@ function fakeBridge() { return { value, emit: (message: BridgeMessage) => listeners.forEach((listener) => listener(message)), - reply: (reply: Reply) => pending.resolve(reply), + /** Answers the latest subscribe. */ + reply: (reply: Reply) => replies.at(-1)?.resolve(reply), + fail: (cause: unknown) => replies.at(-1)?.reject(cause), + subscribes: () => replies.length, } } diff --git a/packages/app/src/runtime/plugin/ipc.ts b/packages/app/src/runtime/plugin/ipc.ts index ddc5d7410f6..0e51e1f3987 100644 --- a/packages/app/src/runtime/plugin/ipc.ts +++ b/packages/app/src/runtime/plugin/ipc.ts @@ -1,8 +1,19 @@ -import { batch } from "solid-js" +import { untrack } from "solid-js" import { createStore, reconcile } from "solid-js/store" -import { Schema } from "effect" +import { Exit, Schema } from "effect" import type { Ipc, IpcCallOptions, IpcClient, IpcSpec } from "@opencode/plugin/gui" import type { Bridge } from "@opencode/plugin/gui/host" +import { + createIpcState, + selectIpcAvailable, + selectIpcFailed, + selectIpcGeneration, + selectIpcNeedsSubscribe, + selectIpcValue, + transitionIpc, + type IpcEffect, + type IpcEvent, +} from "./ipc-machine" type Codec = NonNullable @@ -12,107 +23,128 @@ type Decoded = Codec["Type"] /** A value as it crosses the bridge, encoded by an Ipc's codec. */ type Encoded = Codec["Encoded"] -type IpcState = { - available: Record - values: Record - // Counts each time an Ipc becomes available, so users can tell a returning provider from the one they had. - generations: Record -} +type View = { available: boolean; generation: number; failed: boolean; value: Decoded } + +// How long main may take to answer a subscribe before the Ipc counts as failed. +const subscribeTimeout = 10_000 /** Renderer-side clients for the Ipcs that plugins provide in the main process. */ export function createIpcClients(bridge: Bridge | undefined) { - const [state, setState] = createStore({ available: {}, values: {}, generations: {} }) - - const setAvailable = (id: string, available: boolean) => { - if (available && !state.available[id]) setState("generations", id, (value = 0) => value + 1) - - setState("available", id, available) - } + const machine = { state: createIpcState() } + // What readers see of each Ipc, projected from the machine and reconciled, so a change wakes only its own readers. + const [views, setViews] = createStore>({}) + // Events an effect raises synchronously wait behind that effect. + const queue: IpcEvent[] = [] + const timers = new Map>() const specs = new Map() const clients = new Map>() const listeners = new Map void>>() - const subscribed = new Set() - // How many availability and state events reached each Ipc. Events are newer than any snapshot, so a - // subscribe reply only fills in what no event changed while it was in flight. - const changes = new Map() - const changesOf = (id: string) => { - const existing = changes.get(id) + const dispatch = (event: IpcEvent) => { + queue.push(event) - if (existing) return existing - - const created = { available: 0, state: 0 } - - changes.set(id, created) - - return created + if (queue.length === 1) untrack(drain) } - const decodeState = (id: string, value: Encoded): Decoded => { - const schema = specs.get(id)?.state + const drain = () => { + const event = queue[0] - return schema ? Schema.decodeUnknownSync(schema)(value) : value + if (!event) return + + const next = transitionIpc(machine.state, event) + + if (next.state !== machine.state && event.type !== "disposed") + setViews( + event.id, + reconcile({ + available: selectIpcAvailable(next.state, event.id), + generation: selectIpcGeneration(next.state, event.id), + failed: selectIpcFailed(next.state, event.id), + value: selectIpcValue(next.state, event.id), + }), + ) + + machine.state = next.state + next.effects.forEach(run) + queue.shift() + drain() } - const stop = bridge?.on((message) => { - if (message.type === "state") { - if (!specs.has(message.ipc)) return + const run = (effect: IpcEffect) => { + if (effect.type === "subscribe") { + if (!bridge) return - changesOf(message.ipc).state++ - setState("values", message.ipc, reconcile(decodeState(message.ipc, message.state))) + return void Promise.try(() => bridge.subscribe(effect.id)).then( + (result) => { + const state = result.state === undefined ? Exit.succeed(undefined) : decodeState(effect.id, result.state) + + if (Exit.isFailure(state)) + return dispatch({ type: "failed", id: effect.id, attempt: effect.attempt, cause: state.cause }) + + dispatch({ + type: "subscribed", + id: effect.id, + attempt: effect.attempt, + available: result.available, + state: state.value, + }) + }, + (cause: unknown) => dispatch({ type: "failed", id: effect.id, attempt: effect.attempt, cause }), + ) + } + + if (effect.type === "timer.start") { + clearTimeout(timers.get(effect.id)) + timers.set( + effect.id, + setTimeout(() => dispatch({ type: "timeout", id: effect.id, attempt: effect.attempt }), subscribeTimeout), + ) return } - if (message.type === "available") { - const changed = changesOf(message.ipc) - - changed.available++ - - // Going away clears the state too. - if (!message.available) changed.state++ - - batch(() => { - setAvailable(message.ipc, message.available) - - if (!message.available) setState("values", message.ipc, undefined) - }) + if (effect.type === "timer.stop") { + clearTimeout(timers.get(effect.id)) + timers.delete(effect.id) return } + console.error(`[plugin] ${effect.id}`, effect.cause) + } + + const decodeState = (id: string, value: Encoded) => { + const schema = specs.get(id)?.state + + return schema ? Schema.decodeUnknownExit(schema)(value) : Exit.succeed(value) + } + + // A payload its codec rejects is dropped here, so it never throws into the bridge's other listeners. + const stop = bridge?.on((message) => { + if (message.type === "available") + return dispatch({ type: "available", id: message.ipc, available: message.available }) + + if (message.type === "state") { + if (!specs.has(message.ipc)) return + + const state = decodeState(message.ipc, message.state) + + if (Exit.isFailure(state)) return console.error(`[plugin] ${message.ipc}`, state.cause) + + return dispatch({ type: "state", id: message.ipc, value: state.value }) + } + if (message.type !== "event") return const schema = specs.get(message.ipc)?.events?.[message.name] - const data = schema ? Schema.decodeUnknownSync(schema)(message.data) : message.data + const data = schema ? Schema.decodeUnknownExit(schema)(message.data) : Exit.succeed(message.data) - listeners.get(message.ipc)?.forEach((listener) => listener(message.name, data)) + if (Exit.isFailure(data)) return console.error(`[plugin] ${message.ipc}`, data.cause) + + listeners.get(message.ipc)?.forEach((listener) => listener(message.name, data.value)) }) - const subscribe = (connected: Bridge, token: Ipc) => { - if (subscribed.has(token.id)) return - - subscribed.add(token.id) - specs.set(token.id, token.spec) - - const before = { ...changesOf(token.id) } - - void connected - .subscribe(token.id) - .then((result) => { - const after = changesOf(token.id) - - batch(() => { - if (after.available === before.available) setAvailable(token.id, result.available) - - if (after.state === before.state && result.state !== undefined) - setState("values", token.id, decodeState(token.id, result.state)) - }) - }) - .catch((cause: unknown) => console.error(`[plugin] ${token.id}`, cause)) - } - const create = (connected: Bridge, token: Ipc): IpcClient => { const methods = Object.fromEntries( Object.entries(token.spec.methods).map(([name, method]) => { @@ -128,7 +160,7 @@ export function createIpcClients(bridge: Bridge | undefined) { ) const client = Object.assign(methods, { - state: () => state.values[token.id], + state: () => (views[token.id]?.available ? views[token.id]?.value : undefined), on(name: string, listener: (data: Decoded) => void) { const set = listeners.get(token.id) ?? new Set() @@ -152,9 +184,11 @@ export function createIpcClients(bridge: Bridge | undefined) { const client = (token: Ipc) => { if (!bridge) return undefined - subscribe(bridge, token) + specs.set(token.id, token.spec) - if (!state.available[token.id]) return undefined + if (selectIpcNeedsSubscribe(machine.state, token.id)) dispatch({ type: "subscribe", id: token.id }) + + if (!views[token.id]?.available) return undefined const existing = clients.get(token.id) @@ -170,7 +204,9 @@ export function createIpcClients(bridge: Bridge | undefined) { return { client, /** How many times the Ipc became available; 0 until it first is. Reactive. */ - generation: (token: Ipc) => state.generations[token.id] ?? 0, + generation: (token: Ipc) => views[token.id]?.generation ?? 0, + /** Main did not answer the Ipc's subscribe; the next time main provides it, the window asks again. Reactive. */ + failed: (token: Ipc) => views[token.id]?.failed ?? false, /** A client typed by its token, for host code that uses one Ipc directly. */ typed: (token: Ipc) => // SAFETY: the client was built from this token's spec, so its methods, state and events are those of `S`. @@ -178,6 +214,7 @@ export function createIpcClients(bridge: Bridge | undefined) { /** Stops listening to the bridge. Call it when the owner of these clients goes away. */ dispose() { stop?.() + dispatch({ type: "disposed" }) }, } } diff --git a/packages/app/src/runtime/plugin/root.tsx b/packages/app/src/runtime/plugin/root.tsx index 57471bb8fe8..cd06317b5d0 100644 --- a/packages/app/src/runtime/plugin/root.tsx +++ b/packages/app/src/runtime/plugin/root.tsx @@ -95,6 +95,7 @@ export function PluginRoot(props: ParentProps) { ipc={bridge ? (token) => ipcs.client(token) : undefined} plugin={(id) => plugins()?.find((plugin) => plugin.definition.id === id)} generation={ipcs.generation} + ipcFailed={ipcs.failed} > plugins() !== undefined} />