Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

DesktopSshEnvironment.ts

173 lines6.2 KB

1import type {
2 DesktopDiscoveredSshHost,
3 DesktopSshEnvironmentBootstrap,
4 DesktopSshEnvironmentTarget,
5} from "@t3tools/contracts";
6import * as NetService from "@t3tools/shared/Net";
7import * as SshAuth from "@t3tools/ssh/auth";
8import { resolveSshTarget } from "@t3tools/ssh/command";
9import { discoverSshHosts } from "@t3tools/ssh/config";
10import {
11 SshCommandError,
12 SshHostDiscoveryError,
13 SshInvalidTargetError,
14 SshLaunchError,
15 SshPairingError,
16 SshPasswordPromptError,
17 SshReadinessError,
18} from "@t3tools/ssh/errors";
19import * as SshTunnel from "@t3tools/ssh/tunnel";
20import * as Context from "effect/Context";
21import type * as Digest from "effect/crypto/Digest";
22import * as Effect from "effect/Effect";
23import * as FileSystem from "effect/FileSystem";
24import * as Layer from "effect/Layer";
25import * as Path from "effect/Path";
26import * as Schema from "effect/Schema";
27import * as HttpClient from "effect/http/HttpClient";
28import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
29​
30import * as DesktopSshPasswordPrompts from "./DesktopSshPasswordPrompts.ts";
31​
32export type DesktopSshEnvironmentRuntimeServices =
33 | ChildProcessSpawner.ChildProcessSpawner
34 | Digest.Digest
35 | FileSystem.FileSystem
36 | Path.Path
37 | HttpClient.HttpClient
38 | NetService.NetService;
39​
40export type DesktopSshEnvironmentOperationError =
41 | SshCommandError
42 | SshInvalidTargetError
43 | SshLaunchError
44 | SshPairingError
45 | SshReadinessError
46 | SshPasswordPromptError
47 | NetService.NetError;
48​
49export type DesktopSshEnvironmentDiscoverError = SshHostDiscoveryError;
50​
51export class DesktopSshEnvironment extends Context.Service<
52 DesktopSshEnvironment,
53 {
54 readonly discoverHosts: (input?: {
55 readonly homeDir?: string;
56 }) => Effect.Effect<readonly DesktopDiscoveredSshHost[], DesktopSshEnvironmentDiscoverError>;
57 readonly resolveHost: (
58 alias: string,
59 ) => Effect.Effect<DesktopSshEnvironmentTarget, SshCommandError | SshInvalidTargetError>;
60 readonly ensureEnvironment: (
61 target: DesktopSshEnvironmentTarget,
62 options?: { readonly issuePairingToken?: boolean },
63 ) => Effect.Effect<DesktopSshEnvironmentBootstrap, DesktopSshEnvironmentOperationError>;
64 readonly disconnectEnvironment: (
65 target: DesktopSshEnvironmentTarget,
66 ) => Effect.Effect<void, DesktopSshEnvironmentOperationError>;
67 readonly closeAllTunnels: Effect.Effect<void>;
68 }
69>()("@t3tools/desktop/ssh/DesktopSshEnvironment") {}
70​
71export interface DesktopSshEnvironmentLayerOptions {
72 readonly resolveCliRunner?: Effect.Effect<SshTunnel.RemoteT3RunnerOptions>;
74​
75function discoverDesktopSshHostsEffect(input?: { readonly homeDir?: string }) {
76 return discoverSshHosts(input ?? {});
78​
79const isSshPasswordPromptError = Schema.is(SshPasswordPromptError);
80​
81export function isDesktopSshPasswordPromptCancellation(
82 error: unknown,
83): error is SshPasswordPromptError {
84 return (
85 isSshPasswordPromptError(error) &&
86 DesktopSshPasswordPrompts.isDesktopSshPasswordPromptCancellation(error.cause)
87 );
89​
90function unexpectedPasswordPromptError(error: never): never {
91 throw new Error(`Unhandled desktop SSH password prompt error: ${String(error)}`);
93​
94function toSshPasswordPromptError(
95 cause: DesktopSshPasswordPrompts.DesktopSshPasswordPromptRequestError,
96): SshPasswordPromptError {
97 let message: string;
98 switch (cause._tag) {
99 case "DesktopSshPromptRequestIdGenerationError":
100 message = "Secure randomness is unavailable.";
101 break;
102 case "DesktopSshPromptWindowUnavailableError":
103 case "DesktopSshPromptPresentationError":
104 message = "T3 Code window is not available for SSH authentication.";
105 break;
106 case "DesktopSshPromptTimedOutError":
107 message = `SSH authentication timed out for ${cause.destination}.`;
108 break;
109 case "DesktopSshPromptCancelledError":
110 message = `SSH authentication cancelled for ${cause.destination}.`;
111 break;
112 case "DesktopSshPromptWindowClosedError":
113 message = "SSH authentication was cancelled because the app window closed.";
114 break;
115 case "DesktopSshPromptServiceStoppedError":
116 message = "SSH password prompt service stopped.";
117 break;
118 default:
119 return unexpectedPasswordPromptError(cause);
120 }
121 return new SshPasswordPromptError({ message, cause });
123​
124const makePasswordPrompt = (
125 prompts: DesktopSshPasswordPrompts.DesktopSshPasswordPrompts["Service"],
126): SshAuth.SshPasswordPrompt["Service"] => ({
127 isAvailable: true,
128 request: (request: SshAuth.SshPasswordRequest) =>
129 prompts.request(request).pipe(Effect.mapError(toSshPasswordPromptError)),
130});
131​
132/** @public */
133export const make = Effect.gen(function* () {
134 const manager = yield* SshTunnel.SshEnvironmentManager;
135 const prompts = yield* DesktopSshPasswordPrompts.DesktopSshPasswordPrompts;
136 const runtimeContext = yield* Effect.context<DesktopSshEnvironmentRuntimeServices>();
137 const passwordPrompt = SshAuth.SshPasswordPrompt.of(makePasswordPrompt(prompts));
138​
139 return DesktopSshEnvironment.of({
140 discoverHosts: Effect.fn("desktop.ssh.discoverHosts")(function* (input) {
141 return yield* discoverDesktopSshHostsEffect(input);
142 }, Effect.provide(runtimeContext)),
143 resolveHost: Effect.fn("desktop.ssh.resolveHost")(function* (alias) {
144 return yield* resolveSshTarget(alias.trim());
145 }, Effect.provide(runtimeContext)),
146 ensureEnvironment: Effect.fn("desktop.ssh.ensureEnvironment")(
147 function* (target, ensureOptions) {
148 return yield* manager.ensureEnvironment(target, ensureOptions);
149 },
150 Effect.provideService(SshAuth.SshPasswordPrompt, passwordPrompt),
151 Effect.provide(runtimeContext),
152 ),
153 disconnectEnvironment: Effect.fn("desktop.ssh.disconnectEnvironment")(
154 function* (target) {
155 return yield* manager.disconnectEnvironment(target);
156 },
157 Effect.provideService(SshAuth.SshPasswordPrompt, passwordPrompt),
158 Effect.provide(runtimeContext),
159 ),
160 closeAllTunnels: manager.closeAllTunnels,
161 });
162});
163​
164export const layer = (options: DesktopSshEnvironmentLayerOptions = {}) =>
165 Layer.effect(DesktopSshEnvironment, make).pipe(
166 Layer.provide(
167 SshTunnel.SshEnvironmentManager.layer(
168 options.resolveCliRunner === undefined
169 ? {}
170 : { resolveCliRunner: options.resolveCliRunner },
171 ),
172 ),
173 );