fix(desktop): preserve structural SSH IPC errors

Julius Marminge committed 4 months ago

Commit 9ed4bf41 parent 44dd90f2 files · +35 −50Browse files

Unified · Split

2 files

apps/desktop/src/ipc/methods/sshEnvironment.test.ts +30 −18
apps/desktop/src/ipc/methods/sshEnvironment.ts +5 −32

apps/desktop/src/ipc/methods/sshEnvironment.test.ts+30−18

@@ -5,7 +5,6 @@ import { · 4 unmodified lines
5	} from "@t3tools/contracts";	5	} from "@t3tools/contracts";
6	import {	6	import {
7	SshCommandSpawnError,	7	SshCommandSpawnError,
8	SshCommandTimeoutError,
9	SshHttpBridgeError,	8	SshHttpBridgeError,
10	SshPasswordPromptWindowClosedError,	9	SshPasswordPromptWindowClosedError,
11	} from "@t3tools/ssh/errors";	10	} from "@t3tools/ssh/errors";
@@ -21,9 +20,9 @@ import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse"; · 9 unmodified lines
21		20
22	import {	21	import {
23	DesktopSshEnvironmentRequestError,	22	DesktopSshEnvironmentRequestError,
		23	disconnectSshEnvironment,
24	ensureSshEnvironment,	24	ensureSshEnvironment,
25	fetchSshEnvironmentDescriptor,	25	fetchSshEnvironmentDescriptor,
26	toDesktopSshIpcPresentationError,
27	} from "./sshEnvironment.ts";	26	} from "./sshEnvironment.ts";
28	import * as DesktopSshEnvironment from "../../ssh/DesktopSshEnvironment.ts";	27	import * as DesktopSshEnvironment from "../../ssh/DesktopSshEnvironment.ts";
29	import * as DesktopSshPasswordPrompts from "../../ssh/DesktopSshPasswordPrompts.ts";	28	import * as DesktopSshPasswordPrompts from "../../ssh/DesktopSshPasswordPrompts.ts";
@@ -95,7 +94,7 @@ describe("SSH environment IPC", () => { · 65 unmodified lines
95	}).pipe(Effect.provide(layer));	94	}).pipe(Effect.provide(layer));
96	});	95	});
97		96
98	it("presents legacy process causes without weakening structured errors", () => {	97	it.effect("preserves structural SSH errors and exact causes at the IPC boundary", () => {
99	const cause = new Error("ssh executable was not found");	98	const cause = new Error("ssh executable was not found");
100	const structured = new SshCommandSpawnError({	99	const structured = new SshCommandSpawnError({
101	command: "ssh",	100	command: "ssh",
@@ -103,22 +102,35 @@ describe("SSH environment IPC", () => { · 1 unmodified line
103	target: "devbox",	102	target: "devbox",
104	cause,	103	cause,
105	});	104	});
		105	const target = {
		106	alias: "devbox",
		107	hostname: "devbox.example.test",
		108	username: "developer",
		109	port: 22,
		110	};
		111	const layer = Layer.succeed(
		112	DesktopSshEnvironment.DesktopSshEnvironment,
		113	DesktopSshEnvironment.DesktopSshEnvironment.of({
		114	discoverHosts: () => Effect.die("unexpected host discovery"),
		115	ensureEnvironment: () => Effect.fail(structured),
		116	disconnectEnvironment: () => Effect.fail(structured),
		117	}),
		118	);
106		119
107	const presentation = toDesktopSshIpcPresentationError(structured);	120	return Effect.gen(function* () {
108	assert.equal(structured.message, "Failed to spawn SSH command for devbox.");	121	const exits = yield* Effect.all([
109	assert.equal(presentation.message, cause.message);	122	Effect.exit(ensureSshEnvironment.handler({ target })),
110	assert.strictEqual(presentation.cause, structured);	123	Effect.exit(disconnectSshEnvironment.handler(target)),
111	});	124	]);
112		125	for (const exit of exits) {
113	it("passes structural SSH errors without process causes through the IPC boundary", () => {	126	assert(Exit.isFailure(exit));
114	const structured = new SshCommandTimeoutError({	127	const failure = Cause.findErrorOption(exit.cause);
115	command: "ssh",	128	assert(Option.isSome(failure));
116	argumentCount: 0,	129	assert.strictEqual(failure.value, structured);
117	target: "devbox",	130	}
118	timeoutMs: 30_000,	131	assert.equal(structured.message, "Failed to spawn SSH command for devbox.");
119	});	132	assert.strictEqual(structured.cause, cause);
120		133	}).pipe(Effect.provide(layer));
121	assert.strictEqual(toDesktopSshIpcPresentationError(structured), structured);
122	});	134	});
123		135
124	it.effect("fetches and decodes the remote environment descriptor", () => {	136	it.effect("fetches and decodes the remote environment descriptor", () => {

apps/desktop/src/ipc/methods/sshEnvironment.ts+5−32

   AuthSessionState,
   AuthWebSocketTicketResult,
 } from "@t3tools/contracts";
-import {
+import { SshHttpBridgeError, type SshPasswordPromptError } from "@t3tools/ssh/errors";
-  SshCommandExecutionError,
-  SshCommandSpawnError,
-  SshHttpBridgeError,
-  type SshPasswordPromptError,
-  SshTunnelMonitorError,
-  SshTunnelSpawnError,
-} from "@t3tools/ssh/errors";
 import { resolveLoopbackSshHttpBaseUrl } from "@t3tools/ssh/tunnel";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 const isEnvironmentRequestInvalidError = Schema.is(EnvironmentRequestInvalidError);
 const isEnvironmentScopeRequiredError = Schema.is(EnvironmentScopeRequiredError);
 const isSshHttpBridgeError = Schema.is(SshHttpBridgeError);
-const isSshCausePresentationError = Schema.is(
-  Schema.Union([
-    SshCommandSpawnError,
-    SshCommandExecutionError,
-    SshTunnelSpawnError,
-    SshTunnelMonitorError,
-  ]),
-);
-// Electron only forwards the message from a rejected ipcRenderer.invoke promise. Keep the typed,
-// structural SSH error intact as the cause for main-process diagnostics while preserving the
-// actionable process message that the renderer historically presented to the user.
-export function toDesktopSshIpcPresentationError(
-  error: DesktopSshEnvironment.DesktopSshEnvironmentOperationError,
-): DesktopSshEnvironment.DesktopSshEnvironmentOperationError | Error {
-  if (isSshCausePresentationError(error) && error.cause instanceof Error) {
-    return new Error(error.cause.message, { cause: error });
-  }
-  return error;
-}
 function readSshHttpStatus(cause: DesktopSshEnvironmentRequestCause): number | null {
   if (isRemoteEnvironmentAuthUndeclaredStatusError(cause)) {
   }),
 });
+// Electron forwards only the message from a rejected ipcRenderer.invoke promise to the renderer.
+// Preserve typed SSH errors at this boundary so that message stays structural while main-process
+// diagnostics retain the exact cause and error fields.
 export const ensureSshEnvironment = DesktopIpc.makeIpcMethod({
   channel: IpcChannels.ENSURE_SSH_ENVIRONMENT_CHANNEL,
   payload: DesktopSshEnvironmentEnsureInputSchema,
         SshPasswordPromptWindowClosedError: handleDesktopSshPasswordPromptCancellation,
         SshPasswordPromptServiceStoppedError: handleDesktopSshPasswordPromptCancellation,
       }),
-      Effect.mapError(toDesktopSshIpcPresentationError),
     );
   }),
 });
   result: Schema.Void,
   handler: Effect.fn("desktop.ipc.sshEnvironment.disconnectEnvironment")(function* (target) {
     const sshEnvironment = yield* DesktopSshEnvironment.DesktopSshEnvironment;
-    yield* sshEnvironment
+    yield* sshEnvironment.disconnectEnvironment(target);
-      .disconnectEnvironment(target)
-      .pipe(Effect.mapError(toDesktopSshIpcPresentationError));
   }),
 });