The best way to control Claude Code, Codex and more from any computer or phone

main
ts 664 lines 24.4 KB
Raw
1 import { expect, it } from "@effect/vitest";
2 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
3 import * as NodeServices from "@effect/platform-node/NodeServices";
4 import * as Net from "@t3tools/shared/Net";
5 import * as Deferred from "effect/Deferred";
6 import * as Effect from "effect/Effect";
7 import * as Fiber from "effect/Fiber";
8 import * as FileSystem from "effect/FileSystem";
9 import * as Layer from "effect/Layer";
10 import * as PlatformError from "effect/PlatformError";
11 import * as Sink from "effect/Sink";
12 import * as Stream from "effect/Stream";
13 import * as HttpClient from "effect/http/HttpClient";
14 import * as HttpClientResponse from "effect/http/HttpClientResponse";
15 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
16 import * as TestClock from "effect/testing/TestClock";
17 import * as ServerConfig from "../config.ts";
18 import * as DeviceHost from "./DeviceHost.ts";
19 import * as SshDeviceHost from "./SshDeviceHost.ts";
20
21 it.effect("preserves installed status after probes and cleans failed agent activation", () =>
22 Effect.gen(function* () {
23 const fs = yield* FileSystem.FileSystem;
24 const home = yield* fs.makeTempDirectoryScoped();
25 const modes: string[] = [];
26 const owners: string[] = [];
27 const tunnelArgs: string[][] = [];
28 const tunnelStdins: unknown[] = [];
29 const commandArgs: string[][] = [];
30 let forwards = 0;
31 let failForward = true;
32 let rejectConfig = true;
33 const releases: Array<string | undefined> = [];
34 const spawner = ChildProcessSpawner.make((command) =>
35 Effect.gen(function* () {
36 if (command._tag !== "StandardCommand") return yield* Effect.die("Unexpected command");
37 const forwarding = command.args.includes("-L");
38 (forwarding ? tunnelArgs : commandArgs).push(command.args.map(String));
39 if (forwarding) tunnelStdins.push(command.options.stdin);
40 let output = "";
41 let exitCode = 0;
42 if (forwarding) {
43 if (failForward) {
44 failForward = false;
45 return yield* PlatformError.systemError({
46 _tag: "AlreadyExists",
47 module: "ChildProcess",
48 method: "spawn",
49 description: "Port already bound",
50 });
51 }
52 forwards++;
53 yield* Effect.addFinalizer(() =>
54 Effect.sync(() => {
55 forwards--;
56 }),
57 );
58 } else {
59 const stdin = command.options.stdin;
60 if (
61 !stdin ||
62 typeof stdin !== "object" ||
63 !("stream" in stdin) ||
64 !Stream.isStream(stdin.stream)
65 )
66 return yield* Effect.die("Missing script");
67 const script = yield* stdin.stream.pipe(
68 Stream.decodeText(),
69 Stream.runFold(
70 () => "",
71 (a, b) => a + b,
72 ),
73 );
74 const mode = /const mode = "([^"]+)"/.exec(script)?.[1] ?? "";
75 modes.push(mode);
76 owners.push(/const owner = "([^"]+)"/.exec(script)?.[1] ?? "");
77 output = JSON.stringify({
78 nodePath: "/node",
79 platforms: [{ platform: "ios", available: true }],
80 hubPort: 1234,
81 helpers: { serveSimAxSettings: null, serveSimCli: null },
82 ...(mode === "agent-start"
83 ? { daemonPort: 1235, token: "fixture", entryPath: "/agent.mjs" }
84 : {}),
85 });
86 if (mode === "") {
87 output = `${"verbose-prefix ".repeat(400)}PANIC: emulator SDK is broken\n`;
88 exitCode = 1;
89 }
90 }
91 return ChildProcessSpawner.makeHandle({
92 pid: ChildProcessSpawner.ProcessId(123),
93 stdout: Stream.make(new TextEncoder().encode(output)),
94 stderr: Stream.empty,
95 all: Stream.empty,
96 exitCode: forwarding
97 ? Effect.never
98 : Effect.succeed(ChildProcessSpawner.ExitCode(exitCode)),
99 isRunning: Effect.succeed(forwarding),
100 kill: () => Effect.void,
101 stdin: Sink.drain,
102 getInputFd: () => Sink.drain,
103 getOutputFd: () => Stream.empty,
104 unref: Effect.succeed(Effect.void),
105 });
106 }),
107 );
108 const host = yield* SshDeviceHost.make(
109 { kind: "ssh", id: "test", label: "Test", target: "test.example" },
110 () =>
111 rejectConfig
112 ? Effect.fail(
113 new DeviceHost.DeviceHostError({
114 hostId: "test",
115 step: "configuring agent access",
116 cause: new Error("fixture failure"),
117 }),
118 )
119 : Effect.void,
120 ).pipe(
121 Effect.provide(Layer.mergeAll(ServerConfig.layerTest(home, home), Net.layer)),
122 Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
123 Effect.provideService(
124 HttpClient.HttpClient,
125 HttpClient.make((request) =>
126 Effect.sync(() => {
127 if (!request.url.endsWith("/rpc"))
128 return HttpClientResponse.fromWeb(request, new Response("ok"));
129 releases.push(request.headers.authorization);
130 return HttpClientResponse.fromWeb(request, Response.json({ result: { ok: true } }));
131 }),
132 ),
133 ),
134 );
135 yield* host.ensureReady(() => Effect.void);
136 yield* SshDeviceHost.probe({
137 kind: "ssh",
138 id: "test",
139 label: "Test",
140 target: "test.example",
141 }).pipe(
142 Effect.provide(ServerConfig.layerTest(home, home)),
143 Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
144 );
145 expect(new Set(owners).size).toBe(1);
146 expect(owners[0]).toMatch(/^[a-f0-9]{24}$/);
147 expect(forwards).toBe(1);
148 expect(modes.filter((mode) => mode === "start")).toHaveLength(2);
149 const ready = yield* host.current;
150 expect(ready).not.toBeNull();
151 if (ready) {
152 const failed = yield* ready.run("emulator", ["-list-avds"]);
153 expect(failed.code).toBe(1);
154 expect(failed.stdout).toMatch(/^\[truncated\]/);
155 expect(failed.stderr).toBe(failed.stdout.trim());
156 expect(failed.stderr).toMatch(/PANIC: emulator SDK is broken$/);
157 }
158 yield* host.platformAvailability("ios");
159 expect((yield* host.summary).hubInstalled).toBe(true);
160 const failed = yield* host.ensureAgentReady(() => Effect.void).pipe(Effect.result);
161 expect(failed._tag).toBe("Failure");
162 expect(forwards).toBe(0);
163 expect(modes.at(-1)).toBe("stop-agent");
164 expect(yield* host.current).toBeNull();
165 rejectConfig = false;
166 yield* host.ensureAgentReady(() => Effect.void);
167 yield* host.platformAvailability("ios");
168 expect((yield* host.summary).agentDeviceInstalled).toBe(true);
169 // Close releases agent sessions through the forwarded daemon.
170 const agentReady = yield* host.current;
171 yield* agentReady!.releaseAgentSession!("t3-session", "device");
172 expect(releases).toEqual(["Bearer fixture"]);
173 yield* host.stopAgent;
174 expect(forwards).toBe(1);
175 const multiplexingOff = ["ControlMaster=no", "ControlPath=none", "ControlPersist=no"];
176 expect(tunnelArgs.length).toBeGreaterThan(0);
177 for (const args of tunnelArgs) {
178 for (const option of multiplexingOff) {
179 const index = args.indexOf(option);
180 expect(index).toBeGreaterThan(0);
181 expect(args[index - 1]).toBe("-o");
182 }
183 // The tunnel lives only as long as the server holds the write end of its stdin.
184 expect(args).not.toContain("-N");
185 expect(args.slice(args.indexOf("test.example") + 1)).toEqual([
186 "sh",
187 "-c",
188 "'exec cat >/dev/null'",
189 ]);
190 }
191 expect(tunnelStdins).toEqual(tunnelArgs.map(() => "pipe"));
192 expect(commandArgs.length).toBeGreaterThan(0);
193 for (const args of commandArgs) {
194 for (const option of multiplexingOff) expect(args).not.toContain(option);
195 }
196 yield* host.stop;
197 expect(forwards).toBe(0);
198 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
199 );
200
201 it.effect("releases the forward of a bootstrap interrupted before its hub answered", () =>
202 Effect.gen(function* () {
203 const fs = yield* FileSystem.FileSystem;
204 const home = yield* fs.makeTempDirectoryScoped();
205 const probing = yield* Deferred.make<void>();
206 let holdReadiness = true;
207 let forwards = 0;
208 const spawner = ChildProcessSpawner.make((command) =>
209 Effect.gen(function* () {
210 const forwarding = command._tag === "StandardCommand" && command.args.includes("-L");
211 if (forwarding) {
212 forwards++;
213 yield* Effect.addFinalizer(() =>
214 Effect.sync(() => {
215 forwards--;
216 }),
217 );
218 }
219 const output = forwarding
220 ? ""
221 : JSON.stringify({
222 nodePath: "/node",
223 platforms: [{ platform: "ios", available: true }],
224 hubPort: 1234,
225 helpers: { serveSimAxSettings: null, serveSimCli: null },
226 });
227 return ChildProcessSpawner.makeHandle({
228 pid: ChildProcessSpawner.ProcessId(123),
229 stdout: Stream.make(new TextEncoder().encode(output)),
230 stderr: Stream.empty,
231 all: Stream.empty,
232 exitCode: forwarding ? Effect.never : Effect.succeed(ChildProcessSpawner.ExitCode(0)),
233 isRunning: Effect.succeed(forwarding),
234 kill: () => Effect.void,
235 stdin: Sink.drain,
236 getInputFd: () => Sink.drain,
237 getOutputFd: () => Stream.empty,
238 unref: Effect.succeed(Effect.void),
239 });
240 }),
241 );
242 const publishing = yield* Deferred.make<void>();
243 let holdReadyStatus = false;
244 const host = yield* SshDeviceHost.make(
245 {
246 kind: "ssh",
247 id: "test",
248 label: "Test",
249 target: "test.example",
250 },
251 undefined,
252 (status) =>
253 status === "ready" && holdReadyStatus
254 ? Deferred.succeed(publishing, undefined).pipe(Effect.andThen(Effect.never))
255 : Effect.void,
256 ).pipe(
257 Effect.provide(Layer.mergeAll(ServerConfig.layerTest(home, home), Net.layer)),
258 Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
259 Effect.provideService(
260 HttpClient.HttpClient,
261 HttpClient.make((request) =>
262 Effect.gen(function* () {
263 if (holdReadiness) {
264 yield* Deferred.succeed(probing, undefined);
265 return yield* Effect.never;
266 }
267 return HttpClientResponse.fromWeb(request, new Response("ok"));
268 }),
269 ),
270 ),
271 );
272 const first = yield* host.ensureReady(() => Effect.void).pipe(Effect.forkChild);
273 yield* Deferred.await(probing);
274 yield* Fiber.interrupt(first);
275 expect(forwards).toBe(0);
276 holdReadiness = false;
277 yield* host.ensureReady(() => Effect.void);
278 yield* host.stop;
279 expect(forwards).toBe(0);
280 holdReadyStatus = true;
281 const second = yield* host.ensureReady(() => Effect.void).pipe(Effect.forkChild);
282 yield* Deferred.await(publishing);
283 yield* Fiber.interrupt(second);
284 holdReadyStatus = false;
285 yield* host.ensureReady(() => Effect.void);
286 expect(forwards).toBe(1);
287 yield* host.stop;
288 expect(forwards).toBe(0);
289 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
290 );
291
292 it.effect("lists Android devices without probing the host again once it reports Android", () =>
293 Effect.gen(function* () {
294 const fs = yield* FileSystem.FileSystem;
295 const home = yield* fs.makeTempDirectoryScoped();
296 const modes: string[] = [];
297 let androidInstalled = false;
298 const spawner = ChildProcessSpawner.make((command) =>
299 Effect.gen(function* () {
300 if (command._tag !== "StandardCommand") return yield* Effect.die("Unexpected command");
301 const forwarding = command.args.includes("-L");
302 let output = "";
303 if (!forwarding) {
304 const stdin = command.options.stdin;
305 const script =
306 stdin && typeof stdin === "object" && "stream" in stdin && Stream.isStream(stdin.stream)
307 ? yield* stdin.stream.pipe(
308 Stream.decodeText(),
309 Stream.runFold(
310 () => "",
311 (a, b) => a + b,
312 ),
313 )
314 : "";
315 const mode = /const mode = "([^"]+)"/.exec(script)?.[1] ?? "";
316 modes.push(mode);
317 output =
318 mode === ""
319 ? "Pixel_8\n"
320 : JSON.stringify({
321 nodePath: "/node",
322 platforms: [
323 { platform: "ios", available: true },
324 { platform: "android", available: androidInstalled },
325 ],
326 hubPort: 1234,
327 helpers: { serveSimAxSettings: null, serveSimCli: null },
328 });
329 }
330 return ChildProcessSpawner.makeHandle({
331 pid: ChildProcessSpawner.ProcessId(123),
332 stdout: Stream.make(new TextEncoder().encode(output)),
333 stderr: Stream.empty,
334 all: Stream.empty,
335 exitCode: forwarding ? Effect.never : Effect.succeed(ChildProcessSpawner.ExitCode(0)),
336 isRunning: Effect.succeed(forwarding),
337 kill: () => Effect.void,
338 stdin: Sink.drain,
339 getInputFd: () => Sink.drain,
340 getOutputFd: () => Stream.empty,
341 unref: Effect.succeed(Effect.void),
342 });
343 }),
344 );
345 const host = yield* SshDeviceHost.make({
346 kind: "ssh",
347 id: "test",
348 label: "Test",
349 target: "test.example",
350 }).pipe(
351 Effect.provide(Layer.mergeAll(ServerConfig.layerTest(home, home), Net.layer)),
352 Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
353 Effect.provideService(
354 HttpClient.HttpClient,
355 HttpClient.make((request) =>
356 Effect.succeed(
357 HttpClientResponse.fromWeb(
358 request,
359 new Response(
360 request.url.endsWith("/api/devices")
361 ? JSON.stringify({ simulators: [], emulators: [] })
362 : "ok",
363 ),
364 ),
365 ),
366 ),
367 ),
368 );
369 const ready = yield* host.ensureReady(() => Effect.void);
370 const androidNames = ready.devices.list.pipe(
371 Effect.map((list) =>
372 list.devices.filter((device) => device.platform === "android").map((device) => device.name),
373 ),
374 );
375
376 modes.splice(0);
377
378 expect(yield* androidNames).toEqual([]);
379 expect(modes.splice(0)).toEqual(["probe"]);
380 expect(yield* androidNames).toEqual([]);
381 expect(modes.splice(0)).toEqual(["probe"]);
382
383 // The SDK appears after connecting, so the next listing still probes the host.
384 androidInstalled = true;
385 expect(yield* androidNames).toEqual(["Pixel_8"]);
386 expect(modes.splice(0)).toEqual(["probe", ""]);
387
388 // Android is now known to be available, so listing only runs `emulator -list-avds`.
389 expect(yield* androidNames).toEqual(["Pixel_8"]);
390 expect(modes.splice(0)).toEqual([""]);
391
392 androidInstalled = false;
393 expect((yield* host.platformAvailability("android")).available).toBe(false);
394 expect(modes.splice(0)).toEqual(["probe"]);
395 expect(yield* androidNames).toEqual([]);
396 expect(modes.splice(0)).toEqual(["probe"]);
397
398 androidInstalled = true;
399 yield* host.inspect;
400 expect(modes.splice(0)).toEqual(["probe"]);
401 expect(yield* androidNames).toEqual(["Pixel_8"]);
402 expect(modes.splice(0)).toEqual([""]);
403 yield* host.stop;
404 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
405 );
406
407 it.effect(
408 "keeps the SSH forward through slow health probes and reconnects once the hub stays down",
409 () =>
410 Effect.gen(function* () {
411 const fs = yield* FileSystem.FileSystem;
412 const home = yield* fs.makeTempDirectoryScoped();
413 let forwardSpawns = 0;
414 let hubAnswers = true;
415 const spawner = ChildProcessSpawner.make((command) =>
416 Effect.gen(function* () {
417 if (command._tag !== "StandardCommand") return yield* Effect.die("Unexpected command");
418 const forwarding = command.args.includes("-L");
419 // A fresh forward reaches a working hub again.
420 if (forwarding && ++forwardSpawns > 1) hubAnswers = true;
421 const output = JSON.stringify({
422 nodePath: "/node",
423 platforms: [{ platform: "ios", available: true }],
424 hubPort: 1234,
425 helpers: { serveSimAxSettings: null, serveSimCli: null },
426 });
427 return ChildProcessSpawner.makeHandle({
428 pid: ChildProcessSpawner.ProcessId(123),
429 stdout: Stream.make(new TextEncoder().encode(output)),
430 stderr: Stream.empty,
431 all: Stream.empty,
432 exitCode: forwarding ? Effect.never : Effect.succeed(ChildProcessSpawner.ExitCode(0)),
433 isRunning: Effect.succeed(forwarding),
434 kill: () => Effect.void,
435 stdin: Sink.drain,
436 getInputFd: () => Sink.drain,
437 getOutputFd: () => Stream.empty,
438 unref: Effect.succeed(Effect.void),
439 });
440 }),
441 );
442 const host = yield* SshDeviceHost.make({
443 kind: "ssh",
444 id: "test",
445 label: "Test",
446 target: "test.example",
447 }).pipe(
448 Effect.provide(Layer.mergeAll(ServerConfig.layerTest(home, home), Net.layer)),
449 Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
450 Effect.provideService(
451 HttpClient.HttpClient,
452 HttpClient.make((request) =>
453 hubAnswers
454 ? Effect.succeed(HttpClientResponse.fromWeb(request, new Response("ok")))
455 : Effect.never,
456 ),
457 ),
458 );
459 yield* host.ensureReady(() => Effect.void);
460 expect(forwardSpawns).toBe(1);
461
462 // A loaded host can miss a probe or two without being gone; the forward stays up.
463 hubAnswers = false;
464 yield* TestClock.adjust("30 seconds");
465 hubAnswers = true;
466 yield* TestClock.adjust("2 minutes");
467 expect(forwardSpawns).toBe(1);
468
469 // A hub that keeps missing probes is still replaced.
470 hubAnswers = false;
471 // Recovery reset the miss count, so two new misses do not reconnect yet.
472 yield* TestClock.adjust("30 seconds");
473 expect(forwardSpawns).toBe(1);
474 yield* TestClock.adjust("30 seconds");
475 expect(forwardSpawns).toBe(2);
476 yield* host.stop;
477 }).pipe(
478 Effect.scoped,
479 Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer, TestClock.layer())),
480 ),
481 );
482
483 it.effect.each([
484 {
485 name: "a Windows PowerShell login shell",
486 exitCode: 1,
487 stderr: "sh : The term 'sh' is not recognized as the name of a cmdlet\r\n",
488 shellEcho: "%OS%\r\nWindows_NT\r\n",
489 nodePlatform: null,
490 windows: true,
491 },
492 {
493 name: "a Windows cmd login shell",
494 exitCode: 1,
495 stderr: "'sh' is not recognized as an internal or external command,\r\n",
496 shellEcho: "Windows_NT $env:OS\r\n",
497 nodePlatform: null,
498 windows: true,
499 },
500 {
501 name: "a Windows cmd login shell returning 9009",
502 exitCode: 9009,
503 stderr: "'sh' is not recognized as an internal or external command,\r\n",
504 shellEcho: "Windows_NT $env:OS\r\n",
505 nodePlatform: null,
506 windows: true,
507 },
508 {
509 name: "a Windows Git Bash login shell without a spawnable npm",
510 exitCode: 1,
511 stderr: "npm is missing from the non-interactive SSH PATH\n",
512 shellEcho: "%OS% :OS\n",
513 nodePlatform: "win32",
514 windows: true,
515 },
516 {
517 name: "a Linux host without npm",
518 exitCode: 1,
519 stderr: "npm is missing from the non-interactive SSH PATH\n",
520 shellEcho: "%OS% :OS\n",
521 nodePlatform: "linux",
522 windows: false,
523 },
524 {
525 name: "a POSIX host without Node",
526 exitCode: 1,
527 stderr: "Node is missing from the non-interactive SSH PATH\n",
528 shellEcho: "%OS% :OS\n",
529 nodePlatform: null,
530 windows: false,
531 },
532 {
533 name: "an unrecognized SSH failure",
534 exitCode: 255,
535 stderr: "Connection refused\n",
536 shellEcho: "Windows_NT\n",
537 nodePlatform: "win32",
538 windows: false,
539 },
540 {
541 name: "a ProxyCommand permission error",
542 exitCode: 255,
543 stderr: "bash: /usr/local/bin/proxy: Permission denied\n",
544 shellEcho: "",
545 nodePlatform: null,
546 windows: false,
547 },
548 {
549 name: "an untrusted host key",
550 exitCode: 255,
551 stderr: "Host key verification failed.\r\n",
552 shellEcho: "Windows_NT\n",
553 nodePlatform: "win32",
554 windows: false,
555 connect: { reason: "host_key_unknown", detail: "Host key verification failed." },
556 },
557 {
558 name: "a changed host key",
559 exitCode: 255,
560 stderr:
561 "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\nIT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!\nHost key verification failed.\n",
562 shellEcho: "",
563 nodePlatform: null,
564 windows: false,
565 connect: {
566 reason: "host_key_changed",
567 detail: "@ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @",
568 },
569 },
570 {
571 name: "a rejected login",
572 exitCode: 255,
573 stderr: "me@test.example: Permission denied (publickey).\n",
574 shellEcho: "",
575 nodePlatform: null,
576 windows: false,
577 connect: { reason: "auth", detail: "me@test.example: Permission denied (publickey)." },
578 },
579 {
580 name: "an unresolvable host name",
581 exitCode: 255,
582 stderr: "ssh: Could not resolve hostname test.example: Name or service not known\n",
583 shellEcho: "",
584 nodePlatform: null,
585 windows: false,
586 connect: {
587 reason: "resolve",
588 detail: "ssh: Could not resolve hostname test.example: Name or service not known",
589 },
590 },
591 {
592 name: "a refused connection",
593 exitCode: 255,
594 stderr: "ssh: connect to host test.example port 22: Connection refused\n",
595 shellEcho: "",
596 nodePlatform: null,
597 windows: false,
598 connect: {
599 reason: "connect",
600 detail: "ssh: connect to host test.example port 22: Connection refused",
601 },
602 },
603 ])(
604 "probe failure on $name keeps the SSH cause",
605 ({ exitCode, stderr, shellEcho, nodePlatform, windows, connect }) =>
606 Effect.gen(function* () {
607 const fs = yield* FileSystem.FileSystem;
608 const home = yield* fs.makeTempDirectoryScoped();
609 const shellChecks: string[] = [];
610 const spawner = ChildProcessSpawner.make((command) =>
611 Effect.gen(function* () {
612 if (command._tag !== "StandardCommand") return yield* Effect.die("Unexpected command");
613 const remote = command.args.slice(command.args.indexOf("test.example") + 1).join(" ");
614 const shellCheck = remote === "echo %OS% $env:OS";
615 const platformCheck = remote === "node -p process.platform";
616 if (shellCheck || platformCheck) shellChecks.push(remote);
617 return ChildProcessSpawner.makeHandle({
618 pid: ChildProcessSpawner.ProcessId(123),
619 stdout: Stream.make(
620 new TextEncoder().encode(
621 shellCheck ? shellEcho : platformCheck ? `${nodePlatform ?? ""}\n` : "",
622 ),
623 ),
624 stderr: Stream.make(
625 new TextEncoder().encode(shellCheck || platformCheck ? "" : stderr),
626 ),
627 all: Stream.empty,
628 exitCode: Effect.succeed(
629 ChildProcessSpawner.ExitCode(
630 shellCheck ? 0 : platformCheck ? (nodePlatform === null ? 1 : 0) : exitCode,
631 ),
632 ),
633 isRunning: Effect.succeed(false),
634 kill: () => Effect.void,
635 stdin: Sink.drain,
636 getInputFd: () => Sink.drain,
637 getOutputFd: () => Stream.empty,
638 unref: Effect.succeed(Effect.void),
639 });
640 }),
641 );
642 const failure = yield* SshDeviceHost.probe({
643 kind: "ssh",
644 id: "test",
645 label: "Test",
646 target: "test.example",
647 }).pipe(
648 Effect.provide(ServerConfig.layerTest(home, home)),
649 Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
650 Effect.flip,
651 );
652 expect(failure).toMatchObject({ _tag: "DeviceHostError", step: "probe" });
653 const sshFailure = { _tag: "SshCommandError", exitCode, stderr };
654 expect(failure.cause).toMatchObject(
655 windows
656 ? { _tag: "SshWindowsHostError", cause: sshFailure }
657 : connect
658 ? { _tag: "SshConnectError", ...connect, target: "test.example", cause: sshFailure }
659 : sshFailure,
660 );
661 // A transport failure has no remote shell to ask.
662 if (exitCode === 255) expect(shellChecks).toEqual([]);
663 }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
664 );