Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

[codex] Migrate desktop shell and SSH Effect services (#3194)

Julius Marminge7eda6ba5fce8
diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.ts b/apps/desktop/src/shell/DesktopShellEnvironment.ts
index 13ac35b62..a48e896b7 100644
--- a/apps/desktop/src/shell/DesktopShellEnvironment.ts
+++ b/apps/desktop/src/shell/DesktopShellEnvironment.ts
@@ -3,7 +3,8 @@ import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
@@ -19,13 +20,11 @@ interface WindowsProbeOptions {
readonly loadProfile: boolean;
}
-export interface DesktopShellEnvironmentShape {
- readonly installIntoProcess: Effect.Effect<void, never>;
-}
-
export class DesktopShellEnvironment extends Context.Service<
DesktopShellEnvironment,
- DesktopShellEnvironmentShape
+ {
+ readonly installIntoProcess: Effect.Effect<void>;
+ }
>()("@t3tools/desktop/shell/DesktopShellEnvironment") {}
const LOGIN_SHELL_ENV_NAMES = [
@@ -336,20 +335,20 @@ const installShellEnvironment = (
return Effect.void;
};
-export const layer = Layer.effect(
- DesktopShellEnvironment,
- Effect.gen(function* () {
- const environment = yield* DesktopEnvironment.DesktopEnvironment;
- const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
- return DesktopShellEnvironment.of({
- installIntoProcess: installShellEnvironment({
- env: process.env,
- platform: environment.platform,
- userShell: Option.none(),
- }).pipe(
- Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
- Effect.withSpan("desktop.shellEnvironment.installIntoProcess"),
- ),
- });
- }),
-);
+export const make = Effect.gen(function* () {
+ const environment = yield* DesktopEnvironment.DesktopEnvironment;
+ const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+ const installIntoProcess: DesktopShellEnvironment["Service"]["installIntoProcess"] =
+ installShellEnvironment({
+ env: process.env,
+ platform: environment.platform,
+ userShell: Option.none(),
+ }).pipe(
+ Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+ Effect.withSpan("desktop.shellEnvironment.installIntoProcess"),
+ );
+
+ return DesktopShellEnvironment.of({ installIntoProcess });
+});
+
+export const layer = Layer.effect(DesktopShellEnvironment, make);
diff --git a/apps/desktop/src/ssh/DesktopSshEnvironment.test.ts b/apps/desktop/src/ssh/DesktopSshEnvironment.test.ts
index 77c86be39..baed26102 100644
--- a/apps/desktop/src/ssh/DesktopSshEnvironment.test.ts
+++ b/apps/desktop/src/ssh/DesktopSshEnvironment.test.ts
@@ -19,6 +19,20 @@ function makeTempHomeDir() {
}
describe("sshEnvironment", () => {
+ it("keeps prompt presentation diagnostics distinct from the legacy wrapper message", () => {
+ const cause = new DesktopSshPasswordPrompts.DesktopSshPromptPresentationError({
+ requestId: "prompt-1",
+ destination: "devbox",
+ cause: new Error("renderer send failed"),
+ });
+
+ assert.equal(cause.message, "Failed to present SSH password prompt for devbox.");
+ assert.equal(
+ DesktopSshEnvironment.toSshPasswordPromptError(cause).message,
+ "T3 Code window is not available for SSH authentication.",
+ );
+ });
+
it("treats password prompt timeouts as cancellable authentication prompts", () => {
assert.equal(
DesktopSshEnvironment.isDesktopSshPasswordPromptCancellation(
@@ -104,7 +118,6 @@ describe("sshEnvironment", () => {
Layer.succeed(DesktopSshPasswordPrompts.DesktopSshPasswordPrompts, {
request: () => Effect.die("unexpected password prompt request"),
resolve: () => Effect.die("unexpected password prompt resolution"),
- cancelPending: () => Effect.void,
}),
),
Layer.provideMerge(NodeServices.layer),
diff --git a/apps/desktop/src/ssh/DesktopSshEnvironment.ts b/apps/desktop/src/ssh/DesktopSshEnvironment.ts
index 595d3bea3..31e84ae99 100644
--- a/apps/desktop/src/ssh/DesktopSshEnvironment.ts
+++ b/apps/desktop/src/ssh/DesktopSshEnvironment.ts
@@ -4,11 +4,7 @@ import type {
DesktopSshEnvironmentTarget,
} from "@t3tools/contracts";
import * as NetService from "@t3tools/shared/Net";
-import {
- SshPasswordPrompt,
- type SshPasswordPromptShape,
- type SshPasswordRequest,
-} from "@t3tools/ssh/auth";
+import * as SshAuth from "@t3tools/ssh/auth";
import { discoverSshHosts } from "@t3tools/ssh/config";
import {
SshCommandError,
@@ -19,14 +15,14 @@ import {
SshPasswordPromptError,
SshReadinessError,
} from "@t3tools/ssh/errors";
-import { SshEnvironmentManager, type RemoteT3RunnerOptions } from "@t3tools/ssh/tunnel";
+import * as SshTunnel from "@t3tools/ssh/tunnel";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Path from "effect/Path";
-import { HttpClient } from "effect/unstable/http";
-import { ChildProcessSpawner } from "effect/unstable/process";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner";
import * as DesktopSshPasswordPrompts from "./DesktopSshPasswordPrompts.ts";
@@ -52,27 +48,25 @@ export type DesktopSshEnvironmentError =
| DesktopSshEnvironmentDiscoverError
| DesktopSshEnvironmentOperationError;
-export interface DesktopSshEnvironmentShape {
- readonly discoverHosts: (input?: {
- readonly homeDir?: string;
- }) => Effect.Effect<readonly DesktopDiscoveredSshHost[], DesktopSshEnvironmentDiscoverError>;
- readonly ensureEnvironment: (
- target: DesktopSshEnvironmentTarget,
- options?: { readonly issuePairingToken?: boolean },
- ) => Effect.Effect<DesktopSshEnvironmentBootstrap, DesktopSshEnvironmentOperationError>;
- readonly disconnectEnvironment: (
- target: DesktopSshEnvironmentTarget,
- ) => Effect.Effect<void, DesktopSshEnvironmentOperationError>;
-}
-
export class DesktopSshEnvironment extends Context.Service<
DesktopSshEnvironment,
- DesktopSshEnvironmentShape
+ {
+ readonly discoverHosts: (input?: {
+ readonly homeDir?: string;
+ }) => Effect.Effect<readonly DesktopDiscoveredSshHost[], DesktopSshEnvironmentDiscoverError>;
+ readonly ensureEnvironment: (
+ target: DesktopSshEnvironmentTarget,
+ options?: { readonly issuePairingToken?: boolean },
+ ) => Effect.Effect<DesktopSshEnvironmentBootstrap, DesktopSshEnvironmentOperationError>;
+ readonly disconnectEnvironment: (
+ target: DesktopSshEnvironmentTarget,
+ ) => Effect.Effect<void, DesktopSshEnvironmentOperationError>;
+ }
>()("@t3tools/desktop/ssh/DesktopSshEnvironment") {}
export interface DesktopSshEnvironmentLayerOptions {
readonly resolveCliPackageSpec?: () => string;
- readonly resolveCliRunner?: Effect.Effect<RemoteT3RunnerOptions>;
+ readonly resolveCliRunner?: Effect.Effect<SshTunnel.RemoteT3RunnerOptions>;
}
function discoverDesktopSshHostsEffect(input?: { readonly homeDir?: string }) {
@@ -88,27 +82,53 @@ export function isDesktopSshPasswordPromptCancellation(
);
}
+function unexpectedPasswordPromptError(error: never): never {
+ throw new Error(`Unhandled desktop SSH password prompt error: ${String(error)}`);
+}
+
+export function toSshPasswordPromptError(
+ cause: DesktopSshPasswordPrompts.DesktopSshPasswordPromptRequestError,
+): SshPasswordPromptError {
+ let message: string;
+ switch (cause._tag) {
+ case "DesktopSshPromptRequestIdGenerationError":
+ message = "Secure randomness is unavailable.";
+ break;
+ case "DesktopSshPromptWindowUnavailableError":
+ case "DesktopSshPromptPresentationError":
+ message = "T3 Code window is not available for SSH authentication.";
+ break;
+ case "DesktopSshPromptTimedOutError":
+ message = `SSH authentication timed out for ${cause.destination}.`;
+ break;
+ case "DesktopSshPromptCancelledError":
+ message = `SSH authentication cancelled for ${cause.destination}.`;
+ break;
+ case "DesktopSshPromptWindowClosedError":
+ message = "SSH authentication was cancelled because the app window closed.";
+ break;
+ case "DesktopSshPromptServiceStoppedError":
+ message = "SSH password prompt service stopped.";
+ break;
+ default:
+ return unexpectedPasswordPromptError(cause);
+ }
+ return new SshPasswordPromptError({ message, cause });
+}
+
const makePasswordPrompt = (
- prompts: DesktopSshPasswordPrompts.DesktopSshPasswordPromptsShape,
-): SshPasswordPromptShape => ({
+ prompts: DesktopSshPasswordPrompts.DesktopSshPasswordPrompts["Service"],
+): SshAuth.SshPasswordPrompt["Service"] => ({
isAvailable: true,
- request: (request: SshPasswordRequest) =>
- prompts.request(request).pipe(
- Effect.mapError(
- (cause) =>
- new SshPasswordPromptError({
- message: cause.message,
- cause,
- }),
- ),
- ),
+ request: (request: SshAuth.SshPasswordRequest) =>
+ prompts.request(request).pipe(Effect.mapError(toSshPasswordPromptError)),
});
-const make = Effect.gen(function* () {
- const manager = yield* SshEnvironmentManager;
+export const make = Effect.gen(function* () {
+ const manager = yield* SshTunnel.SshEnvironmentManager;
const prompts = yield* DesktopSshPasswordPrompts.DesktopSshPasswordPrompts;
const runtimeContext = yield* Effect.context<DesktopSshEnvironmentRuntimeServices>();
- const passwordPrompt = SshPasswordPrompt.of(makePasswordPrompt(prompts));
+ const passwordPrompt = SshAuth.SshPasswordPrompt.of(makePasswordPrompt(prompts));
return DesktopSshEnvironment.of({
discoverHosts: (input) =>
@@ -120,7 +140,7 @@ const make = Effect.gen(function* () {
manager
.ensureEnvironment(target, ensureOptions)
.pipe(
- Effect.provideService(SshPasswordPrompt, passwordPrompt),
+ Effect.provideService(SshAuth.SshPasswordPrompt, passwordPrompt),
Effect.provide(runtimeContext),
Effect.withSpan("desktop.ssh.ensureEnvironment"),
),
@@ -128,7 +148,7 @@ const make = Effect.gen(function* () {
manager
.disconnectEnvironment(target)
.pipe(
- Effect.provideService(SshPasswordPrompt, passwordPrompt),
+ Effect.provideService(SshAuth.SshPasswordPrompt, passwordPrompt),
Effect.provide(runtimeContext),
Effect.withSpan("desktop.ssh.disconnectEnvironment"),
),
@@ -138,7 +158,7 @@ const make = Effect.gen(function* () {
export const layer = (options: DesktopSshEnvironmentLayerOptions = {}) =>
Layer.effect(DesktopSshEnvironment, make).pipe(
Layer.provide(
- SshEnvironmentManager.layer({
+ SshTunnel.SshEnvironmentManager.layer({
...(options.resolveCliPackageSpec === undefined
? {}
: { resolveCliPackageSpec: options.resolveCliPackageSpec }),
diff --git a/apps/desktop/src/ssh/DesktopSshPasswordPrompts.ts b/apps/desktop/src/ssh/DesktopSshPasswordPrompts.ts
index 1d50f9ca3..c933bca3c 100644
--- a/apps/desktop/src/ssh/DesktopSshPasswordPrompts.ts
+++ b/apps/desktop/src/ssh/DesktopSshPasswordPrompts.ts
@@ -3,7 +3,6 @@ import { DesktopSshPasswordPromptResolutionInputSchema } from "@t3tools/contract
import type { SshPasswordRequest } from "@t3tools/ssh/auth";
import * as Context from "effect/Context";
import * as Crypto from "effect/Crypto";
-import * as Data from "effect/Data";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Duration from "effect/Duration";
@@ -11,93 +10,134 @@ import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Ref from "effect/Ref";
+import * as Schema from "effect/Schema";
-import * as IpcChannels from "../ipc/channels.ts";
import * as ElectronWindow from "../electron/ElectronWindow.ts";
+import { SSH_PASSWORD_PROMPT_CHANNEL } from "../ipc/channels.ts";
const DEFAULT_SSH_PASSWORD_PROMPT_TIMEOUT_MS = 3 * 60 * 1000;
-const WINDOW_UNAVAILABLE_MESSAGE = "T3 Code window is not available for SSH authentication.";
type DesktopSshPasswordPromptResolutionInput =
typeof DesktopSshPasswordPromptResolutionInputSchema.Type;
-export class DesktopSshPromptUnavailableError extends Data.TaggedError(
- "DesktopSshPromptUnavailableError",
-)<{
- readonly reason: string;
-}> {
- override get message() {
- return this.reason;
+const WINDOW_UNAVAILABLE_MESSAGE = "T3 Code window is not available for SSH authentication.";
+
+export class DesktopSshPromptRequestIdGenerationError extends Schema.TaggedErrorClass<DesktopSshPromptRequestIdGenerationError>()(
+ "DesktopSshPromptRequestIdGenerationError",
+ {
+ destination: Schema.String,
+ cause: Schema.Defect(),
+ },
+) {
+ override get message(): string {
+ return "Secure randomness is unavailable.";
}
}
-export class DesktopSshPromptWindowUnavailableError extends Data.TaggedError(
+export class DesktopSshPromptWindowUnavailableError extends Schema.TaggedErrorClass<DesktopSshPromptWindowUnavailableError>()(
"DesktopSshPromptWindowUnavailableError",
-)<{
- readonly destination: string;
-}> {
- override get message() {
+ {
+ destination: Schema.String,
+ },
+) {
+ override get message(): string {
return WINDOW_UNAVAILABLE_MESSAGE;
}
}
-export class DesktopSshPromptSendError extends Data.TaggedError("DesktopSshPromptSendError")<{
- readonly requestId: string;
- readonly destination: string;
- readonly cause: unknown;
-}> {
- override get message() {
- return WINDOW_UNAVAILABLE_MESSAGE;
+const isDesktopSshPromptWindowUnavailableError = Schema.is(DesktopSshPromptWindowUnavailableError);
+
+export class DesktopSshPromptPresentationError extends Schema.TaggedErrorClass<DesktopSshPromptPresentationError>()(
+ "DesktopSshPromptPresentationError",
+ {
+ requestId: Schema.String,
+ destination: Schema.String,
+ cause: Schema.Defect(),
+ },
+) {
+ override get message(): string {
+ return `Failed to present SSH password prompt for ${this.destination}.`;
}
}
-export class DesktopSshPromptTimedOutError extends Data.TaggedError(
+export class DesktopSshPromptTimedOutError extends Schema.TaggedErrorClass<DesktopSshPromptTimedOutError>()(
"DesktopSshPromptTimedOutError",
-)<{
- readonly requestId: string;
- readonly destination: string;
-}> {
- override get message() {
+ {
+ requestId: Schema.String,
+ destination: Schema.String,
+ },
+) {
+ override get message(): string {
return `SSH authentication timed out for ${this.destination}.`;
}
}
-export class DesktopSshPromptCancelledError extends Data.TaggedError(
+export class DesktopSshPromptCancelledError extends Schema.TaggedErrorClass<DesktopSshPromptCancelledError>()(
"DesktopSshPromptCancelledError",
-)<{
- readonly requestId: string;
- readonly destination: string;
- readonly reason: string;
-}> {
- override get message() {
- return this.reason;
+ {
+ requestId: Schema.String,
+ destination: Schema.String,
+ },
+) {
+ override get message(): string {
+ return `SSH authentication cancelled for ${this.destination}.`;
}
}
-export class DesktopSshPromptInvalidRequestIdError extends Data.TaggedError(
+export class DesktopSshPromptWindowClosedError extends Schema.TaggedErrorClass<DesktopSshPromptWindowClosedError>()(
+ "DesktopSshPromptWindowClosedError",
+ {
+ requestId: Schema.String,
+ destination: Schema.String,
+ },
+) {
+ override get message(): string {
+ return "SSH authentication was cancelled because the app window closed.";
+ }
+}
+
+export class DesktopSshPromptServiceStoppedError extends Schema.TaggedErrorClass<DesktopSshPromptServiceStoppedError>()(
+ "DesktopSshPromptServiceStoppedError",
+ {
+ requestId: Schema.String,
+ destination: Schema.String,
+ },
+) {
+ override get message(): string {
+ return "SSH password prompt service stopped.";
+ }
+}
+
+export class DesktopSshPromptInvalidRequestIdError extends Schema.TaggedErrorClass<DesktopSshPromptInvalidRequestIdError>()(
"DesktopSshPromptInvalidRequestIdError",
-)<{
- readonly requestId: string;
-}> {
- override get message() {
+ {
+ requestId: Schema.String,
+ },
+) {
+ override get message(): string {
return "Invalid SSH password prompt id.";
}
}
-export class DesktopSshPromptExpiredError extends Data.TaggedError("DesktopSshPromptExpiredError")<{
- readonly requestId: string;
-}> {
- override get message() {
+export class DesktopSshPromptExpiredError extends Schema.TaggedErrorClass<DesktopSshPromptExpiredError>()(
+ "DesktopSshPromptExpiredError",
+ {
+ requestId: Schema.String,
+ },
+) {
+ override get message(): string {
return "SSH password prompt expired. Try connecting again.";
}
}
export type DesktopSshPasswordPromptRequestError =
- | DesktopSshPromptUnavailableError
+ | DesktopSshPromptRequestIdGenerationError
| DesktopSshPromptWindowUnavailableError
- | DesktopSshPromptSendError
+ | DesktopSshPromptPresentationError
| DesktopSshPromptTimedOutError
- | DesktopSshPromptCancelledError;
+ | DesktopSshPromptCancelledError
+ | DesktopSshPromptWindowClosedError
+ | DesktopSshPromptServiceStoppedError;
export type DesktopSshPasswordPromptResolveError =
| DesktopSshPromptInvalidRequestIdError
@@ -107,28 +147,28 @@ export type DesktopSshPasswordPromptError =
| DesktopSshPasswordPromptRequestError
| DesktopSshPasswordPromptResolveError;
-export function isDesktopSshPasswordPromptCancellation(
- error: unknown,
-): error is DesktopSshPromptCancelledError | DesktopSshPromptTimedOutError {
- return (
- error instanceof DesktopSshPromptCancelledError ||
- error instanceof DesktopSshPromptTimedOutError
- );
-}
+export const DesktopSshPasswordPromptCancellation = Schema.Union([
+ DesktopSshPromptCancelledError,
+ DesktopSshPromptWindowClosedError,
+ DesktopSshPromptServiceStoppedError,
+ DesktopSshPromptTimedOutError,
+]);
+export type DesktopSshPasswordPromptCancellation = typeof DesktopSshPasswordPromptCancellation.Type;
-export interface DesktopSshPasswordPromptsShape {
- readonly request: (
- request: SshPasswordRequest,
- ) => Effect.Effect<string, DesktopSshPasswordPromptRequestError>;
- readonly resolve: (
- input: DesktopSshPasswordPromptResolutionInput,
- ) => Effect.Effect<void, DesktopSshPasswordPromptResolveError>;
- readonly cancelPending: (reason: string) => Effect.Effect<void>;
-}
+export const isDesktopSshPasswordPromptCancellation = Schema.is(
+ DesktopSshPasswordPromptCancellation,
+);
export class DesktopSshPasswordPrompts extends Context.Service<
DesktopSshPasswordPrompts,
- DesktopSshPasswordPromptsShape
+ {
+ readonly request: (
+ request: SshPasswordRequest,
+ ) => Effect.Effect<string, DesktopSshPasswordPromptRequestError>;
+ readonly resolve: (
+ input: DesktopSshPasswordPromptResolutionInput,
+ ) => Effect.Effect<void, DesktopSshPasswordPromptResolveError>;
+ }
>()("@t3tools/desktop/ssh/DesktopSshPasswordPrompts") {}
interface PendingSshPasswordPrompt {
@@ -137,7 +177,7 @@ interface PendingSshPasswordPrompt {
readonly deferred: Deferred.Deferred<string, DesktopSshPasswordPromptRequestError>;
}
-interface LayerOptions {
+export interface DesktopSshPasswordPromptsOptions {
readonly passwordPromptTimeoutMs?: number;
}
@@ -161,14 +201,16 @@ const failPending = (
error: DesktopSshPasswordPromptRequestError,
) => Deferred.fail(pending.deferred, error).pipe(Effect.asVoid);
-const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (options: LayerOptions = {}) {
+export const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (
+ options: DesktopSshPasswordPromptsOptions = {},
+) {
const electronWindow = yield* ElectronWindow.ElectronWindow;
const crypto = yield* Crypto.Crypto;
const pendingRef = yield* Ref.make(new Map<string, PendingSshPasswordPrompt>());
const passwordPromptTimeoutMs =
options.passwordPromptTimeoutMs ?? DEFAULT_SSH_PASSWORD_PROMPT_TIMEOUT_MS;
- const cancelPending = (reason: string): Effect.Effect<void> =>
+ const cancelPending = () =>
Ref.getAndSet(pendingRef, new Map()).pipe(
Effect.flatMap((pending) =>
Effect.forEach(
@@ -176,10 +218,9 @@ const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (options: La
(entry) =>
failPending(
entry,
- new DesktopSshPromptCancelledError({
+ new DesktopSshPromptServiceStoppedError({
requestId: entry.requestId,
destination: entry.destination,
- reason,
}),
),
{ discard: true },
@@ -188,13 +229,11 @@ const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (options: La
Effect.asVoid,
);
- yield* Effect.addFinalizer(() =>
- cancelPending("SSH password prompt service stopped.").pipe(Effect.ignore),
- );
+ yield* Effect.addFinalizer(() => cancelPending().pipe(Effect.ignore));
- const resolve = Effect.fn("desktop.sshPasswordPrompts.resolve")(function* (
- input: DesktopSshPasswordPromptResolutionInput,
- ): Effect.fn.Return<void, DesktopSshPasswordPromptResolveError> {
+ const resolve: DesktopSshPasswordPrompts["Service"]["resolve"] = Effect.fn(
+ "desktop.sshPasswordPrompts.resolve",
+ )(function* (input) {
const requestId = input.requestId.trim();
if (requestId.length === 0) {
return yield* new DesktopSshPromptInvalidRequestIdError({ requestId: input.requestId });
@@ -212,7 +251,6 @@ const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (options: La
new DesktopSshPromptCancelledError({
requestId,
destination: entry.destination,
- reason: `SSH authentication cancelled for ${entry.destination}.`,
}),
);
return;
@@ -221,9 +259,9 @@ const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (options: La
yield* Deferred.succeed(entry.deferred, input.password).pipe(Effect.asVoid);
});
- const request = Effect.fn("desktop.sshPasswordPrompts.request")(function* (
- input: SshPasswordRequest,
- ): Effect.fn.Return<string, DesktopSshPasswordPromptRequestError> {
+ const request: DesktopSshPasswordPrompts["Service"]["request"] = Effect.fn(
+ "desktop.sshPasswordPrompts.request",
+ )(function* (input) {
const window = yield* electronWindow.main;
if (Option.isNone(window) || window.value.isDestroyed()) {
return yield* new DesktopSshPromptWindowUnavailableError({
@@ -233,7 +271,11 @@ const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (options: La
const requestId = yield* crypto.randomUUIDv4.pipe(
Effect.mapError(
- () => new DesktopSshPromptUnavailableError({ reason: "Secure randomness is unavailable." }),
+ (cause) =>
+ new DesktopSshPromptRequestIdGenerationError({
+ destination: input.destination,
+ cause,
+ }),
),
);
const now = yield* DateTime.now;
@@ -267,10 +309,9 @@ const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (options: La
onSome: (pending) =>
failPending(
pending,
- new DesktopSshPromptCancelledError({
+ new DesktopSshPromptWindowClosedError({
requestId,
destination: input.destination,
- reason: "SSH authentication was cancelled because the app window closed.",
}),
),
}),
@@ -302,36 +343,43 @@ const make = Effect.fn("desktop.sshPasswordPrompts.make")(function* (options: La
return yield* Effect.try({
try: () => {
if (window.value.isDestroyed()) {
- throw new Error(WINDOW_UNAVAILABLE_MESSAGE);
+ throw new DesktopSshPromptWindowUnavailableError({
+ destination: input.destination,
+ });
}
window.value.once("closed", cancelOnWindowClosed);
- window.value.webContents.send(IpcChannels.SSH_PASSWORD_PROMPT_CHANNEL, promptRequest);
+ window.value.webContents.send(SSH_PASSWORD_PROMPT_CHANNEL, promptRequest);
if (window.value.isDestroyed()) {
- throw new Error(WINDOW_UNAVAILABLE_MESSAGE);
+ throw new DesktopSshPromptWindowUnavailableError({
+ destination: input.destination,
+ });
}
if (window.value.isMinimized()) {
window.value.restore();
}
if (window.value.isDestroyed()) {
- throw new Error(WINDOW_UNAVAILABLE_MESSAGE);
+ throw new DesktopSshPromptWindowUnavailableError({
+ destination: input.destination,
+ });
}
window.value.focus();
},
catch: (cause) =>
- new DesktopSshPromptSendError({
- requestId,
- destination: input.destination,
- cause,
- }),
+ isDesktopSshPromptWindowUnavailableError(cause)
+ ? cause
+ : new DesktopSshPromptPresentationError({
+ requestId,
+ destination: input.destination,
+ cause,
+ }),
}).pipe(Effect.andThen(waitForPassword), Effect.ensuring(cleanup));
});
return DesktopSshPasswordPrompts.of({
request,
resolve,
- cancelPending,
});
});
-export const layer = (options: LayerOptions = {}) =>
+export const layer = (options: DesktopSshPasswordPromptsOptions = {}) =>
Layer.effect(DesktopSshPasswordPrompts, make(options));