Commit bf55408a5cddbb0f3f7f50d538398e315b5407d0 | the-knife

apps/server/src/device/AgentDeviceShim.ts+3-2

 @@ -1,11 +1,12 @@
 // @effect-diagnostics preferSchemaOverJson:off - JSON string literals embed paths safely into generated JavaScript.
 /**
  * A directory holding an `agent-device` launcher that runs the pinned install
- * with the server's Node. Prepended to provider subprocess PATHs so the agent
+ * with a Node runtime. Prepended to provider subprocess PATHs so the agent
  * types `agent-device …` and gets the version the injected instructions were
  * written for, regardless of what is or is not globally installed.
  */
 import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import { resolveNodeExecutable } from "@t3tools/shared/nodeRuntime";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 @@ -20,9 +21,9 @@ export const ensureAgentDeviceShim = Effect.fn("AgentDeviceShim.ensure")(functio
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const platform = yield* HostProcessPlatform;
+  const node = yield* resolveNodeExecutable("Device automation");
   const shimDir = path.join(input.stateDir, SHIM_DIR);
   yield* fs.makeDirectory(shimDir, { recursive: true });
-  const node = process.execPath;
   const launcherPath = path.join(shimDir, "agent-device-launcher.mjs");
   yield* fs.writeFileString(
     launcherPath,

apps/server/src/device/AgentDeviceTarget.test.ts+11-2

 @@ -1,5 +1,9 @@
 // @effect-diagnostics nodeBuiltinImport:off - exercises concurrent real CLI subprocesses.
-import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import {
+  HostProcessExecutablePath,
+  HostProcessIsExecutable,
+  HostProcessPlatform,
+} from "@t3tools/shared/hostProcess";
 import { describe, expect, it } from "@effect/vitest";
 import * as NodeChildProcess from "node:child_process";
 import * as NodeUtil from "node:util";
 @@ -84,6 +88,11 @@ if (process.env.AGENT_DEVICE_DAEMON_BASE_URL) process.exit(2);`,
           ).rejects.toThrow("Call device_open first"),
         );
       }
-    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+    }).pipe(
+      Effect.scoped,
+      Effect.provideService(HostProcessIsExecutable, true),
+      Effect.provideService(HostProcessExecutablePath, "/packaged/t3"),
+      Effect.provide(NodeServices.layer),
+    ),
   );
 });

apps/server/src/device/DeviceHost.ts+6-2

 @@ -18,6 +18,7 @@ import type {
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+import type { NodeRuntimeUnavailableError } from "@t3tools/shared/nodeRuntime";
 export class DeviceHostError extends Schema.TaggedError<DeviceHostError>()("DeviceHostError", {
   hostId: Schema.String,
 @@ -88,11 +89,14 @@ export class DeviceHost extends Context.Service<
      */
     readonly ensureReady: (
       onPhase: (phase: "installing" | "starting") => Effect.Effect<void>,
-    ) => Effect.Effect<DeviceHostReady, DeviceHostError>;
+    ) => Effect.Effect<DeviceHostReady, DeviceHostError | NodeRuntimeUnavailableError>;
     /** Installs and starts agent-device after the user grants agent access. */
     readonly ensureAgentReady: (
       onPhase: (phase: "installing" | "starting") => Effect.Effect<void>,
-    ) => Effect.Effect<DeviceHostAgentReady, DeviceHostError | DeviceHostTimeoutError>;
+    ) => Effect.Effect<
+      DeviceHostAgentReady,
+      DeviceHostError | DeviceHostTimeoutError | NodeRuntimeUnavailableError
+    >;
     /** Current endpoints when already running, without starting anything. */
     readonly current: Effect.Effect<DeviceHostReady | null>;
     /** Stops only agent-device. Manual viewing through the hub stays available. */

apps/server/src/device/DeviceService.test.ts+41

...	@@ -15,6 +15,7 @@ import * as Stream from "effect/Stream";	...	@@ -15,6 +15,7 @@ import * as Stream from "effect/Stream";
15	import { HttpClient, HttpClientResponse } from "effect/unstable/http";	15	import { HttpClient, HttpClientResponse } from "effect/unstable/http";
16	import { ServerSettingsService } from "../serverSettings.ts";	16	import { ServerSettingsService } from "../serverSettings.ts";
17	import * as DeviceHost from "./DeviceHost.ts";	17	import * as DeviceHost from "./DeviceHost.ts";
		18	import { NodeRuntimeUnavailableError } from "@t3tools/shared/nodeRuntime";
18		19
19	import { type DeviceService, makeWithHosts, stateStream } from "./DeviceService.ts";	20	import { type DeviceService, makeWithHosts, stateStream } from "./DeviceService.ts";
20		21
...	@@ -61,6 +62,7 @@ const fixture = Effect.fn("fixture")(function* (	...	@@ -61,6 +62,7 @@ const fixture = Effect.fn("fixture")(function* (
61	onBoot: Effect.Effect<void> = Effect.void,	62	onBoot: Effect.Effect<void> = Effect.void,
62	bootError?: string,	63	bootError?: string,
63	failListAfterShutdown = false,	64	failListAfterShutdown = false,
		65	runtimeFailure?: NodeRuntimeUnavailableError,
64	) {	66	) {
65	const settings = yield* Ref.make(DEFAULT_SERVER_SETTINGS);	67	const settings = yield* Ref.make(DEFAULT_SERVER_SETTINGS);
66	const starts: string[] = [];	68	const starts: string[] = [];
...	@@ -88,12 +90,14 @@ const fixture = Effect.fn("fixture")(function* (	...	@@ -88,12 +90,14 @@ const fixture = Effect.fn("fixture")(function* (
88	platformAvailability: (platform) => Effect.succeed({ platform, available: true }),	90	platformAvailability: (platform) => Effect.succeed({ platform, available: true }),
89	ensureReady: (onPhase) =>	91	ensureReady: (onPhase) =>
90	Effect.gen(function* () {	92	Effect.gen(function* () {
		93	if (runtimeFailure) return yield* runtimeFailure;
91	starts.push("start");	94	starts.push("start");
92	yield* onPhase("starting");	95	yield* onPhase("starting");
93	return ready;	96	return ready;
94	}),	97	}),
95	ensureAgentReady: (onPhase) =>	98	ensureAgentReady: (onPhase) =>
96	Effect.gen(function* () {	99	Effect.gen(function* () {
		100	if (runtimeFailure) return yield* runtimeFailure;
97	agentStarts.push("start");	101	agentStarts.push("start");
98	yield* onPhase("starting");	102	yield* onPhase("starting");
99	return {	103	return {
...	@@ -188,6 +192,43 @@ const fixture = Effect.fn("fixture")(function* (	...	@@ -188,6 +192,43 @@ const fixture = Effect.fn("fixture")(function* (
188	});	192	});
189		193
190	describe("device setup consent", () => {	194	describe("device setup consent", () => {
		195	it.effect(
		196	"preserves missing-runtime guidance and causes through manual and agent readiness",
		197	() =>
		198	Effect.gen(function* () {
		199	const underlying = new Error("private lookup diagnostics");
		200	const runtimeFailure = new NodeRuntimeUnavailableError({
		201	feature: "Local device support",
		202	cause: underlying,
		203	});
		204	const { service, settings, requests } = yield* fixture(
		205	Effect.void,
		206	undefined,
		207	false,
		208	runtimeFailure,
		209	);
		210	yield* Ref.update(settings, (current) => ({
		211	...current,
		212	enableDeviceSupport: true,
		213	enableAgentDeviceAccess: true,
		214	}));
		215	for (const readiness of [service.readiness(), service.agentReadinessIfSupported()]) {
		216	const error = yield* readiness.pipe(Effect.flip);
		217	expect(error).toMatchObject({
		218	_tag: "DeviceHostUnavailableError",
		219	reason: expect.stringContaining("Install Node.js"),
		220	cause: runtimeFailure,
		221	});
		222	expect(error.message).not.toContain(underlying.message);
		223	}
		224	expect((yield* service.state).hostStatuses[LOCAL_DEVICE_HOST_ID]).toMatchObject({
		225	status: "failed",
		226	detail: expect.stringContaining("Install Node.js"),
		227	});
		228	expect(requests).toEqual([]);
		229	}).pipe(Effect.scoped),
		230	);
		231
191	it.effect("listing and provider startup do not start helpers before consent", () =>	232	it.effect("listing and provider startup do not start helpers before consent", () =>
192	Effect.gen(function* () {	233	Effect.gen(function* () {
193	const { service, starts, requests } = yield* fixture();	234	const { service, starts, requests } = yield* fixture();

apps/server/src/device/DeviceService.ts+35-10

 @@ -36,6 +36,7 @@ import {
   type ThreadId,
 } from "@t3tools/contracts";
 import * as FileSystem from "effect/FileSystem";
+import { resolveNodeExecutable, nodeRuntimeUnavailableMessage } from "@t3tools/shared/nodeRuntime";
 import * as Path from "effect/Path";
 import { ensureAgentDevice } from "./DeviceToolchain.ts";
 import * as ServerConfig from "../config.ts";
 @@ -262,7 +263,15 @@ export const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function*
             setHostStatus(host.id, { status: "failed", detail: error.message }),
           ),
           Effect.mapError(
-            (error) => new DeviceHostUnavailableError({ hostId: host.id, reason: error.message }),
+            (error) =>
+              new DeviceHostUnavailableError({
+                hostId: host.id,
+                reason:
+                  error._tag === "NodeRuntimeUnavailableError"
+                    ? nodeRuntimeUnavailableMessage("Local device support")
+                    : `Device host ${error.hostId} failed while ${error.step}.`,
+                cause: error,
+              }),
           ),
         );
       if (hosts.get(host.id) !== host)
 @@ -305,7 +314,17 @@ export const makeWithHosts = Effect.fn("DeviceService.makeWithHosts")(function*
             setHostStatus(host.id, { status: "failed", detail: error.message }),
           ),
           Effect.mapError(
-            (error) => new DeviceHostUnavailableError({ hostId: host.id, reason: error.message }),
+            (error) =>
+              new DeviceHostUnavailableError({
+                hostId: host.id,
+                reason:
+                  error._tag === "NodeRuntimeUnavailableError"
+                    ? nodeRuntimeUnavailableMessage("Local device support")
+                    : error._tag === "DeviceHostTimeoutError"
+                      ? `Device host ${error.hostId} did not start agent tools within ${error.timeoutMs} ms.`
+                      : `Device host ${error.hostId} failed while ${error.step}.`,
+                cause: error,
+              }),
           ),
         );
       const hostSummaries = yield* Effect.forEach(hosts.values(), (candidate) => candidate.summary);
 @@ -1003,18 +1022,24 @@ export const make = Effect.gen(function* () {
   );
   return {
     ...service,
-    agentCli: ensureAgentDevice(config.baseDir).pipe(
+    agentCli: resolveNodeExecutable("Device automation").pipe(
+      Effect.flatMap(() => ensureAgentDevice(config.baseDir)),
       Effect.provideService(FileSystem.FileSystem, fs),
       Effect.provideService(Path.Path, path),
       Effect.provideService(ProcessRunner.ProcessRunner, runner),
       Effect.map((tool) => tool.entryPath),
-      Effect.mapError(
+      Effect.mapError((error) =>
-        (error) =>
+        error._tag === "NodeRuntimeUnavailableError"
-          new DeviceOperationError({
+          ? new DeviceHostUnavailableError({
-            operation: "install agent CLI",
+              hostId: LOCAL_DEVICE_HOST_ID,
-            reason: "command_failed",
+              reason: nodeRuntimeUnavailableMessage("Device automation"),
-            cause: error,
+              cause: error,
-          }),
+            })
+          : new DeviceOperationError({
+              operation: "install agent CLI",
+              reason: "command_failed",
+              cause: error,
+            }),
       ),
     ),
   };

apps/server/src/device/DeviceToolchain.ts+2-2

...	@@ -4,7 +4,7 @@	...	@@ -4,7 +4,7 @@
4	* `expo-device-hub` streams simulator and emulator screens and `agent-device`	4	* `expo-device-hub` streams simulator and emulator screens and `agent-device`
5	* drives them. Each is npm-installed separately after its matching consent	5	* drives them. Each is npm-installed separately after its matching consent
6	* step into `<baseDir>/tools/<name>/<version>` and executed from there with the	6	* step into `<baseDir>/tools/<name>/<version>` and executed from there with the
7	* server's own Node, never `npx`: an ephemeral	7	* resolved Node runtime, never `npx`: an ephemeral
8	* npx cache would make every first `device_open` after a reboot depend on the	8	* npx cache would make every first `device_open` after a reboot depend on the
9	* registry, and the pinned versions are part of the contract the injected	9	* registry, and the pinned versions are part of the contract the injected
10	* agent instructions describe.	10	* agent instructions describe.
...	@@ -34,7 +34,7 @@ const installLock = Semaphore.makeUnsafe(1);	...	@@ -34,7 +34,7 @@ const installLock = Semaphore.makeUnsafe(1);
34		34
35	export interface DeviceToolPaths {	35	export interface DeviceToolPaths {
36	readonly installDir: string;	36	readonly installDir: string;
37	/** Absolute path of the tool's entry script, run with the server's Node. */	37	/** Absolute path of the tool's entry script, run with a resolved Node runtime. */
38	readonly entryPath: string;	38	readonly entryPath: string;
39	readonly sentinelPath: string;	39	readonly sentinelPath: string;
40	}	40	}

apps/server/src/device/LocalDeviceHost.test.ts+10-1

 @@ -1,6 +1,10 @@
 import { describe, expect, it } from "@effect/vitest";
 import * as NodePath from "@effect/platform-node/NodePath";
-import { HostProcessEnvironment, HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import {
+  HostProcessEnvironment,
+  HostProcessPlatform,
+  HostProcessIsExecutable,
+} from "@t3tools/shared/hostProcess";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 @@ -157,6 +161,11 @@ it.effect(
         ),
       );
       expect(yield* host.current).toBeNull();
+      const error = yield* host
+        .ensureReady(() => Effect.die("Must not install without Node"))
+        .pipe(Effect.flip, Effect.provideService(HostProcessIsExecutable, true));
+      expect(error.message).toContain("Local device support requires Node.js");
+      expect(error.message).toContain("Install Node.js");
       yield* host.stop;
       expect(yield* fs.exists(`${baseDir}/tools`)).toBe(false);
     }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),

apps/server/src/device/LocalDeviceHost.ts+32-13

 @@ -18,6 +18,10 @@ import {
 } from "@t3tools/contracts";
 import { waitForHttpReady } from "@t3tools/shared/httpReadiness";
 import { HostProcessEnvironment, HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import {
+  resolveNodeExecutable,
+  type NodeRuntimeUnavailableError,
+} from "@t3tools/shared/nodeRuntime";
 import * as NetService from "@t3tools/shared/Net";
 import { isCommandAvailable } from "@t3tools/shared/shell";
 import * as Clock from "effect/Clock";
 @@ -76,6 +80,7 @@ const AgentDeviceDaemonFile = Schema.Struct({
 const decodeDaemonFile = Schema.decodeUnknownEffect(Schema.fromJsonString(AgentDeviceDaemonFile));
 interface HubProcess {
+  readonly nodePath: string;
   readonly child: ChildProcessSpawner.ChildProcessHandle;
   readonly scope: Scope.Closeable;
   readonly origin: string;
 @@ -310,6 +315,7 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
   const spawnHub = Effect.fn("LocalDeviceHost.spawnHub")(function* (
     hubTool: DeviceToolPaths,
+    nodePath: string,
   ): Effect.fn.Return<HubProcess, DeviceHost.DeviceHostError> {
     yield* reapStaleHub;
     yield* fs
 @@ -330,7 +336,7 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
     const child = yield* spawner
       .spawn(
         ChildProcess.make(
-          process.execPath,
+          nodePath,
           [
             hubTool.entryPath,
             "--port",
 @@ -361,7 +367,7 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
         ),
       );
     const startedAtMillis = yield* Clock.currentTimeMillis;
-    const hub: HubProcess = { child, scope, origin, startedAtMillis };
+    const hub: HubProcess = { child, scope, origin, startedAtMillis, nodePath };
     yield* Effect.forkIn(observeHubOutput(hub), scope);
     yield* waitForHttpReady({
       baseUrl: origin,
 @@ -418,7 +424,7 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
         Effect.gen(function* () {
           const current = yield* Ref.get(runningRef);
           if (current?.hub.child.pid !== hub.child.pid) return;
-          const replacement = yield* spawnHub(hubTool);
+          const replacement = yield* spawnHub(hubTool, hub.nodePath);
           yield* Ref.set(runningRef, { ...current, hub: replacement });
           yield* Effect.forkDetach(superviseHub(replacement, hubTool));
         }),
 @@ -441,6 +447,7 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
    */
   const startAgentDeviceDaemon = Effect.fn("LocalDeviceHost.startAgentDeviceDaemon")(function* (
     agentTool: DeviceToolPaths,
+    nodePath: string,
   ): Effect.fn.Return<DeviceHost.AgentDeviceEndpoint, DeviceHost.DeviceHostTimeoutError> {
     const stateDir = agentDeviceStateDir(path, config.stateDir);
     yield* fs.makeDirectory(stateDir, { recursive: true }).pipe(Effect.ignore);
 @@ -481,7 +488,7 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
     // daemon and blocks until it answers. `devices` is the cheapest one.
     yield* runner
       .run({
-        command: process.execPath,
+        command: nodePath,
         args: [agentTool.entryPath, "devices", "--json"],
         env: daemonEnvironment,
         timeout: Duration.millis(DAEMON_READY_TIMEOUT_MS),
 @@ -502,11 +509,13 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
     }
   });
-  const stopAgentDeviceDaemon = (agentTool: DeviceToolPaths | null) =>
+  const stopAgentDeviceDaemon = (
+    agentTool: { readonly entryPath: string; readonly nodePath: string } | null,
+  ) =>
     agentTool
       ? runner
           .run({
-            command: process.execPath,
+            command: agentTool.nodePath,
             args: [
               agentTool.entryPath,
               "daemon",
 @@ -521,17 +530,22 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
           .pipe(Effect.ignore)
       : Effect.void;
-  let agentToolRef: DeviceToolPaths | null = null;
+  let agentToolRef: { readonly entryPath: string; readonly nodePath: string } | null = null;
   const ensureHubReady = Effect.fn("LocalDeviceHost.ensureHubReady")(function* (
     onPhase: (phase: "installing" | "starting") => Effect.Effect<void>,
-  ): Effect.fn.Return<RunningHost, DeviceHost.DeviceHostError> {
+  ): Effect.fn.Return<RunningHost, DeviceHost.DeviceHostError | NodeRuntimeUnavailableError> {
     const running = yield* Ref.get(runningRef);
     if (running) {
       const alive = yield* running.hub.child.isRunning.pipe(Effect.orElseSucceed(() => false));
       if (alive) return running;
       yield* Ref.set(runningRef, null);
     }
+    const nodePath = yield* resolveNodeExecutable("Local device support", hostEnvironment).pipe(
+      Effect.provideService(FileSystem.FileSystem, fs),
+      Effect.provideService(Path.Path, path),
+      Effect.provideService(HostProcessPlatform, hostPlatform),
+    );
     const installed = yield* isDeviceHubInstalled(config.baseDir).pipe(
       Effect.provideService(FileSystem.FileSystem, fs),
       Effect.provideService(Path.Path, path),
 @@ -551,7 +565,7 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
       ),
     );
     yield* onPhase("starting");
-    const hub = yield* spawnHub(hubTool);
+    const hub = yield* spawnHub(hubTool, nodePath);
     const candidate = helperPaths(hubTool);
     const [axExists, cliExists] = yield* Effect.all([
       fs.exists(candidate.serveSimAxSettings).pipe(Effect.orElseSucceed(() => false)),
 @@ -577,7 +591,12 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
   const ensureAgentReady: DeviceHost.DeviceHost["Service"]["ensureAgentReady"] = (onPhase) =>
     startLock.withPermits(1)(
       Effect.gen(function* (): Generator<
-        Effect.Effect<unknown, DeviceHost.DeviceHostError | DeviceHost.DeviceHostTimeoutError>,
+        Effect.Effect<
+          unknown,
+          | DeviceHost.DeviceHostError
+          | DeviceHost.DeviceHostTimeoutError
+          | NodeRuntimeUnavailableError
+        >,
         DeviceHost.DeviceHostAgentReady
       > {
         const running = yield* ensureHubReady(onPhase);
 @@ -600,9 +619,9 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
               }),
           ),
         );
-        agentToolRef = agentTool;
+        agentToolRef = { entryPath: agentTool.entryPath, nodePath: running.hub.nodePath };
         yield* onPhase("starting");
-        const agentDevice = yield* startAgentDeviceDaemon(agentTool);
+        const agentDevice = yield* startAgentDeviceDaemon(agentTool, running.hub.nodePath);
         const next = { ...running, agentDevice };
         yield* Ref.set(runningRef, next);
         return { ...toReady(next), agentDevice };
 @@ -652,7 +671,7 @@ export const make = Effect.fn("LocalDeviceHost.make")(function* () {
   const toReady = (running: RunningHost): DeviceHost.DeviceHostReady => ({
     hub: { origin: running.hub.origin } satisfies DeviceHost.DeviceHubEndpoint,
-    nodePath: process.execPath,
+    nodePath: running.hub.nodePath,
     run,
     helpers: running.helpers,
   });

apps/server/src/mcp/toolkits/device/handlers.ts+7-2

 @@ -12,6 +12,7 @@ import * as Path from "effect/Path";
 import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
 import { ServerConfig } from "../../../config.ts";
 import { ensureAgentDeviceShim } from "../../../device/AgentDeviceShim.ts";
+import { nodeRuntimeUnavailableMessage } from "@t3tools/shared/nodeRuntime";
 import * as DeviceService from "../../../device/DeviceService.ts";
 import * as McpInvocationContext from "../../McpInvocationContext.ts";
 @@ -182,9 +183,13 @@ const handlers = {
         stateDir: config.stateDir,
       }).pipe(
         Effect.mapError(
-          () =>
+          (error) =>
             new DeviceToolUnavailableError({
-              reason: "Could not prepare the agent-device launcher.",
+              reason:
+                error._tag === "NodeRuntimeUnavailableError"
+                  ? nodeRuntimeUnavailableMessage("Device automation")
+                  : "Could not prepare the agent-device launcher.",
+              cause: error,
             }),
         ),
       );

apps/server/src/provider/AntigravityInstallation.test.ts+14

...	@@ -3,6 +3,7 @@ import { expect, it } from "@effect/vitest";	...	@@ -3,6 +3,7 @@ import { expect, it } from "@effect/vitest";
3	import {	3	import {
4	HostProcessArchitecture,	4	HostProcessArchitecture,
5	HostProcessEnvironment,	5	HostProcessEnvironment,
		6	HostProcessIsExecutable,
6	HostProcessPlatform,	7	HostProcessPlatform,
7	} from "@t3tools/shared/hostProcess";	8	} from "@t3tools/shared/hostProcess";
8	import * as Deferred from "effect/Deferred";	9	import * as Deferred from "effect/Deferred";
...	@@ -242,6 +243,19 @@ const expectPreviousRelease = Effect.fn("test.expectPreviousAntigravityRelease")	...	@@ -242,6 +243,19 @@ const expectPreviousRelease = Effect.fn("test.expectPreviousAntigravityRelease")
242	});	243	});
243		244
244	it.layer(NodeServices.layer)("Antigravity installation", (it) => {	245	it.layer(NodeServices.layer)("Antigravity installation", (it) => {
		246	it.effect("reports missing Node before downloading the standalone provider runtime", () =>
		247	Effect.gen(function* () {
		248	const { installation, requests, validations } = yield* makeHarness();
		249	yield* installation.start;
		250	expect(yield* terminalState(installation)).toMatchObject({
		251	phase: "failed",
		252	message: expect.stringContaining("Install Node.js"),
		253	});
		254	expect(requests).toEqual([]);
		255	expect(validations).toEqual([]);
		256	}).pipe(Effect.provideService(HostProcessIsExecutable, true)),
		257	);
		258
245	it.effect("verifies both files before activating a streamed download", () =>	259	it.effect("verifies both files before activating a streamed download", () =>
246	Effect.gen(function* () {	260	Effect.gen(function* () {
247	const enteredValidation = yield* Deferred.make<void>();	261	const enteredValidation = yield* Deferred.make<void>();

apps/server/src/provider/AntigravityInstallation.ts+9

 @@ -6,6 +6,7 @@ import {
   HostProcessEnvironment,
   HostProcessPlatform,
 } from "@t3tools/shared/hostProcess";
+import { resolveNodeExecutable, nodeRuntimeUnavailableMessage } from "@t3tools/shared/nodeRuntime";
 import * as Clock from "effect/Clock";
 import * as Cause from "effect/Cause";
 import * as Context from "effect/Context";
 @@ -517,6 +518,14 @@ export const makeAntigravityInstallation = Effect.fn("AntigravityInstallation.ma
   const install = Effect.fn("AntigravityInstallation.install")(
     function* (asset: AntigravityReleaseAsset) {
+      yield* resolveNodeExecutable("Antigravity", environment).pipe(
+        Effect.provideService(FileSystem.FileSystem, fs),
+        Effect.provideService(Path.Path, path),
+        Effect.provideService(HostProcessPlatform, platform),
+        Effect.mapError((cause) =>
+          installationError("verify", nodeRuntimeUnavailableMessage("Antigravity"), cause),
+        ),
+      );
       const report = (phase: ProviderInstallState["phase"], message: string | null) =>
         SubscriptionRef.update(state, (current) => ({ ...current, phase, message }));
       yield* fs.makeDirectory(versionsDirectory, { recursive: true });

apps/server/src/provider/Drivers/AntigravityDriver.test.ts+16

...	@@ -8,6 +8,7 @@ import {	...	@@ -8,6 +8,7 @@ import {
8	import {	8	import {
9	HostProcessEnvironment,	9	HostProcessEnvironment,
10	HostProcessExecutablePath,	10	HostProcessExecutablePath,
		11	HostProcessIsExecutable,
11	HostProcessPlatform,	12	HostProcessPlatform,
12	} from "@t3tools/shared/hostProcess";	13	} from "@t3tools/shared/hostProcess";
13	import * as Effect from "effect/Effect";	14	import * as Effect from "effect/Effect";
...	@@ -260,6 +261,21 @@ const testLayer = ServerConfig.layerTest(process.cwd(), {	...	@@ -260,6 +261,21 @@ const testLayer = ServerConfig.layerTest(process.cwd(), {
260	);	261	);
261		262
262	it.layer(testLayer)("AntigravityDriver", (it) => {	263	it.layer(testLayer)("AntigravityDriver", (it) => {
		264	it.effect.skipIf(windowsHost)(
		265	"preserves the Node install message when starting a standalone provider",
		266	() =>
		267	Effect.gen(function* () {
		268	const h = yield* makeHarness();
		269	const error = yield* h.refresh().pipe(Effect.flip);
		270	expect(error.detail).toContain("Install Node.js");
		271	expect(h.launches).toEqual([]);
		272	}).pipe(
		273	Effect.scoped,
		274	Effect.provideService(HostProcessIsExecutable, true),
		275	Effect.provideService(HostProcessEnvironment, { PATH: "" }),
		276	),
		277	);
		278
263	it.effect.skipIf(windowsHost)("does not launch a process for a disabled instance", () =>	279	it.effect.skipIf(windowsHost)("does not launch a process for a disabled instance", () =>
264	Effect.gen(function* () {	280	Effect.gen(function* () {
265	const h = yield* makeHarness();	281	const h = yield* makeHarness();

apps/server/src/provider/Drivers/AntigravityDriver.ts+17-1

 @@ -1,6 +1,10 @@
 import { withAgentDeviceEnvironment } from "../../mcp/McpProviderSession.ts";
 import { AntigravitySettings, ProviderDriverKind, ProviderSetupError } from "@t3tools/contracts";
 import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import {
+  NodeRuntimeUnavailableError,
+  nodeRuntimeUnavailableMessage,
+} from "@t3tools/shared/nodeRuntime";
 import * as Crypto from "effect/Crypto";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 @@ -59,6 +63,7 @@ import { discoverAntigravitySkills, resolveAntigravityUserHome } from "./Antigra
 const DRIVER = ProviderDriverKind.make("antigravity");
 const decodeSettings = Schema.decodeSync(AntigravitySettings);
+const isNodeRuntimeUnavailableError = Schema.is(NodeRuntimeUnavailableError);
 export type AntigravityDriverEnv =
   | AntigravityInstallation
 @@ -164,6 +169,16 @@ export const AntigravityDriver: ProviderDriver<AntigravitySettings, AntigravityD
           Effect.provideService(FileSystem.FileSystem, fileSystem),
           Effect.provideService(Path.Path, path),
           Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+          Effect.mapError((cause) =>
+            isNodeRuntimeUnavailableError(cause.cause)
+              ? new ProviderSetupError({
+                  instanceId,
+                  operation: "start",
+                  detail: nodeRuntimeUnavailableMessage("Antigravity sign-in"),
+                  cause,
+                })
+              : cause,
+          ),
         );
         // Each process unpacks into its own directory that dies with the
         // runtime scope, after the child is killed. A shared directory would
 @@ -422,7 +437,8 @@ export const AntigravityDriver: ProviderDriver<AntigravitySettings, AntigravityD
                 instanceId,
                 detail: isAntigravitySignInRequiredError(cause)
                   ? "Sign in to Antigravity in provider settings before refreshing models."
-                  : cause._tag === "ProviderSetupError" && cause.operation === "configure"
+                  : cause._tag === "ProviderSetupError" &&
+                      (cause.operation === "configure" || cause.operation === "start")
                     ? cause.detail
                     : "Could not refresh Antigravity models. The previous model list is unchanged.",
                 cause,

apps/server/src/provider/antigravityAuthSupport.test.ts+47-1

...	@@ -3,7 +3,11 @@ import * as NodeChildProcess from "node:child_process";	...	@@ -3,7 +3,11 @@ import * as NodeChildProcess from "node:child_process";
3		3
4	import * as NodeServices from "@effect/platform-node/NodeServices";	4	import * as NodeServices from "@effect/platform-node/NodeServices";
5	import { ProviderInstanceId } from "@t3tools/contracts";	5	import { ProviderInstanceId } from "@t3tools/contracts";
6	import { HostProcessPlatform } from "@t3tools/shared/hostProcess";	6	import {
		7	HostProcessExecutablePath,
		8	HostProcessIsExecutable,
		9	HostProcessPlatform,
		10	} from "@t3tools/shared/hostProcess";
7	import { describe, expect, it } from "@effect/vitest";	11	import { describe, expect, it } from "@effect/vitest";
8	import * as Effect from "effect/Effect";	12	import * as Effect from "effect/Effect";
9	import * as FileSystem from "effect/FileSystem";	13	import * as FileSystem from "effect/FileSystem";
...	@@ -531,6 +535,48 @@ describe("Antigravity stderr compatibility", () => {	...	@@ -531,6 +535,48 @@ describe("Antigravity stderr compatibility", () => {
531	});	535	});
532		536
533	it.layer(NodeServices.layer)("Antigravity profile preparation", (it) => {	537	it.layer(NodeServices.layer)("Antigravity profile preparation", (it) => {
		538	it.effect("runs the browser helper with installed Node in standalone builds", () =>
		539	Effect.gen(function* () {
		540	const fs = yield* FileSystem.FileSystem;
		541	const path = yield* Path.Path;
		542	const directory = yield* fs.makeTempDirectoryScoped();
		543	const profile = yield* prepareAntigravityProfile({
		544	profileDirectory: path.join(directory, "profile"),
		545	baseEnv: { PATH: path.dirname(process.execPath) },
		546	});
		547	expect(profile.browserCommand).not.toContain("/packaged/t3");
		548	expect(yield* fs.exists(profile.acpDirectory)).toBe(true);
		549	}).pipe(
		550	Effect.provideService(HostProcessIsExecutable, true),
		551	Effect.provideService(HostProcessExecutablePath, "/packaged/t3"),
		552	),
		553	);
		554
		555	it.effect("reports missing Node before creating the standalone sign-in profile", () =>
		556	Effect.gen(function* () {
		557	const fs = yield* FileSystem.FileSystem;
		558	const path = yield* Path.Path;
		559	const directory = yield* fs.makeTempDirectoryScoped();
		560	const profileDirectory = path.join(directory, "profile");
		561	const result = yield* prepareAntigravityProfile({
		562	profileDirectory,
		563	baseEnv: { PATH: "" },
		564	}).pipe(Effect.result);
		565	expect(Result.isFailure(result)).toBe(true);
		566	if (Result.isFailure(result)) {
		567	expect(result.failure).toMatchObject({
		568	_tag: "AcpTransportError",
		569	detail: expect.stringContaining("Install Node.js"),
		570	cause: {
		571	_tag: "NodeRuntimeUnavailableError",
		572	cause: { _tag: "CommandResolutionError" },
		573	},
		574	});
		575	}
		576	expect(yield* fs.exists(profileDirectory)).toBe(false);
		577	}).pipe(Effect.provideService(HostProcessIsExecutable, true)),
		578	);
		579
534	it.effect("preflights the no-browser helper and creates private directories only", () =>	580	it.effect("preflights the no-browser helper and creates private directories only", () =>
535	Effect.gen(function* () {	581	Effect.gen(function* () {
536	const fs = yield* FileSystem.FileSystem;	582	const fs = yield* FileSystem.FileSystem;

apps/server/src/provider/antigravityAuthSupport.ts+13-2

 @@ -5,7 +5,8 @@ import * as NodeFSP from "node:fs/promises";
 import * as NodePath from "node:path";
 import type { AntigravityAuthMethod, ProviderInstanceId } from "@t3tools/contracts";
-import { HostProcessExecutablePath, HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import { resolveNodeExecutable, nodeRuntimeUnavailableMessage } from "@t3tools/shared/nodeRuntime";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
 @@ -307,7 +308,17 @@ export const prepareAntigravityProfile = Effect.fn("prepareAntigravityProfile")(
   const platform = input.platform ?? (yield* HostProcessPlatform);
   const userHome =
     input.userHome ?? resolveAntigravityUserHome(platform, input.baseEnv ?? process.env);
-  const runtimeExecutablePath = input.runtimeExecutablePath ?? (yield* HostProcessExecutablePath);
+  const runtimeExecutablePath =
+    input.runtimeExecutablePath ??
+    (yield* resolveNodeExecutable("Antigravity sign-in", input.baseEnv).pipe(
+      Effect.mapError(
+        (cause) =>
+          new AcpErrors.AcpTransportError({
+            detail: nodeRuntimeUnavailableMessage("Antigravity sign-in"),
+            cause,
+          }),
+      ),
+    ));
   const helperExecutable =
     platform === "win32" ? runtimeExecutablePath.replaceAll("\\", "/") : runtimeExecutablePath;
   const browserArguments = [helperExecutable, "-e", browserHelperSource, "--", "%s"];

packages/contracts/src/device.ts+2

...	@@ -340,6 +340,7 @@ export class DeviceHostUnavailableError extends Schema.TaggedError<DeviceHostUna	...	@@ -340,6 +340,7 @@ export class DeviceHostUnavailableError extends Schema.TaggedError<DeviceHostUna
340	{	340	{
341	hostId: DeviceHostId,	341	hostId: DeviceHostId,
342	reason: Schema.String,	342	reason: Schema.String,
		343	cause: Schema.optional(Schema.Defect()),
343	},	344	},
344	) {	345	) {
345	override get message(): string {	346	override get message(): string {
...	@@ -527,6 +528,7 @@ export class DeviceToolUnavailableError extends Schema.TaggedError<DeviceToolUna	...	@@ -527,6 +528,7 @@ export class DeviceToolUnavailableError extends Schema.TaggedError<DeviceToolUna
527	"DeviceToolUnavailableError",	528	"DeviceToolUnavailableError",
528	{	529	{
529	reason: Schema.String,	530	reason: Schema.String,
		531	cause: Schema.optional(Schema.Defect()),
530	},	532	},
531	) {	533	) {
532	override get message(): string {	534	override get message(): string {

packages/shared/package.json+4

 @@ -267,6 +267,10 @@
       "types": "./src/chatList.ts",
       "import": "./src/chatList.ts"
     },
+    "./nodeRuntime": {
+      "types": "./src/nodeRuntime.ts",
+      "import": "./src/nodeRuntime.ts"
+    },
     "./hostProcess": {
       "types": "./src/hostProcess.ts",
       "import": "./src/hostProcess.ts"

packages/shared/src/nodeRuntime.test.ts created+193

...	@@ -0,0 +1,193 @@
1	import * as NodeServices from "@effect/platform-node/NodeServices";
2	import { describe, expect, it } from "@effect/vitest";
3	import * as Effect from "effect/Effect";
4	import * as FileSystem from "effect/FileSystem";
5	import * as Path from "effect/Path";
6	import * as Result from "effect/Result";
7
8	import {
9	HostProcessExecutablePath,
10	HostProcessIsExecutable,
11	HostProcessPlatform,
12	} from "./hostProcess.ts";
13	import { resolveNodeExecutable } from "./nodeRuntime.ts";
14	import { symlinksSupported } from "./testing/symlinks.ts";
15
16	describe("Node runtime selection", () => {
17	it.effect("keeps the current Node or Electron runtime without requiring Node on PATH", () =>
18	Effect.gen(function* () {
19	for (const executable of ["/runtime/node", "/Applications/T3 Code.app/Electron"]) {
20	expect(
21	yield* resolveNodeExecutable("Local device support", { PATH: "" }).pipe(
22	Effect.provideService(HostProcessExecutablePath, executable),
23	Effect.provideService(HostProcessIsExecutable, false),
24	),
25	).toBe(executable);
26	}
27	}).pipe(Effect.provide(NodeServices.layer)),
28	);
29
30	it.effect("uses installed Node instead of the standalone T3 executable", () =>
31	Effect.gen(function* () {
32	const path = yield* Path.Path;
33	expect(
34	yield* resolveNodeExecutable("Local device support", {
35	PATH: path.dirname(process.execPath),
36	}),
37	).toBe(process.execPath);
38	}).pipe(
39	Effect.provideService(HostProcessExecutablePath, "/packaged/t3"),
40	Effect.provideService(HostProcessIsExecutable, true),
41	Effect.provide(NodeServices.layer),
42	),
43	);
44
45	it.effect("explains how to install Node when a standalone helper has no runtime", () =>
46	Effect.gen(function* () {
47	const error = yield* resolveNodeExecutable("Local device support", { PATH: "" }).pipe(
48	Effect.flip,
49	);
50	expect(error._tag).toBe("NodeRuntimeUnavailableError");
51	expect(error.message).toContain("Local device support requires Node.js");
52	expect(error.message).toContain("Install Node.js");
53	}).pipe(
54	Effect.provideService(HostProcessIsExecutable, true),
55	Effect.provide(NodeServices.layer),
56	),
57	);
58
59	it.effect("finds a newly installed runtime immediately after a failed lookup", () =>
60	Effect.gen(function* () {
61	const fs = yield* FileSystem.FileSystem;
62	const path = yield* Path.Path;
63	const directory = yield* fs.makeTempDirectoryScoped();
64	const platform = yield* HostProcessPlatform;
65	const node = path.join(directory, platform === "win32" ? "node.exe" : "node");
66	const env = { PATH: directory };
67	expect(
68	Result.isFailure(
69	yield* resolveNodeExecutable("Local device support", env).pipe(Effect.result),
70	),
71	).toBe(true);
72	yield* fs.copyFile(process.execPath, node);
73	yield* fs.chmod(node, 0o755);
74	expect(yield* resolveNodeExecutable("Local device support", env)).toBe(node);
75	}).pipe(
76	Effect.scoped,
77	Effect.provideService(HostProcessExecutablePath, "/packaged/t3"),
78	Effect.provideService(HostProcessIsExecutable, true),
79	Effect.provide(NodeServices.layer),
80	),
81	);
82
83	it.effect("uses node.exe even when Windows batch wrappers appear first on PATH", () =>
84	Effect.gen(function* () {
85	const fs = yield* FileSystem.FileSystem;
86	const path = yield* Path.Path;
87	const directory = yield* fs.makeTempDirectoryScoped();
88	const wrappers = path.join(directory, "wrappers");
89	const runtime = path.join(directory, "runtime");
90	yield* fs.makeDirectory(wrappers);
91	yield* fs.makeDirectory(runtime);
92	yield* fs.writeFileString(path.join(wrappers, "node.cmd"), "@echo off");
93	yield* fs.writeFileString(path.join(wrappers, "node.bat"), "@echo off");
94	const node = path.join(runtime, "node.exe");
95	yield* fs.copyFile(process.execPath, node);
96	expect(
97	yield* resolveNodeExecutable("Local device support", {
98	PATH: `${wrappers};${runtime}`,
99	PATHEXT: ".CMD;.BAT",
100	}),
101	).toBe(node);
102	}).pipe(
103	Effect.scoped,
104	Effect.provideService(HostProcessExecutablePath, "/packaged/t3"),
105	Effect.provideService(HostProcessIsExecutable, true),
106	Effect.provideService(HostProcessPlatform, "win32"),
107	Effect.provide(NodeServices.layer),
108	),
109	);
110
111	it.effect("reports install guidance when Windows only has batch runtime wrappers", () =>
112	Effect.gen(function* () {
113	const fs = yield* FileSystem.FileSystem;
114	const path = yield* Path.Path;
115	const directory = yield* fs.makeTempDirectoryScoped();
116	yield* fs.writeFileString(path.join(directory, "node.cmd"), "@echo off");
117	yield* fs.writeFileString(path.join(directory, "node.bat"), "@echo off");
118	const error = yield* resolveNodeExecutable("Local device support", {
119	PATH: directory,
120	PATHEXT: ".CMD;.BAT;.EXE",
121	}).pipe(Effect.flip);
122	expect(error._tag).toBe("NodeRuntimeUnavailableError");
123	expect(error.message).toContain("Install Node.js");
124	}).pipe(
125	Effect.scoped,
126	Effect.provideService(HostProcessIsExecutable, true),
127	Effect.provideService(HostProcessPlatform, "win32"),
128	Effect.provide(NodeServices.layer),
129	),
130	);
131
132	it.effect("rejects a hard-linked node alias pointing back at the standalone app", () =>
133	Effect.gen(function* () {
134	const fs = yield* FileSystem.FileSystem;
135	const path = yield* Path.Path;
136	const directory = yield* fs.makeTempDirectoryScoped();
137	const platform = yield* HostProcessPlatform;
138	const executable = path.join(directory, platform === "win32" ? "t3.exe" : "t3");
139	const node = path.join(directory, platform === "win32" ? "node.exe" : "node");
140	yield* fs.writeFileString(executable, "standalone executable fixture");
141	yield* fs.chmod(executable, 0o755);
142	yield* fs.link(executable, node);
143	const error = yield* resolveNodeExecutable("Local device support", { PATH: directory }).pipe(
144	Effect.provideService(HostProcessExecutablePath, executable),
145	Effect.flip,
146	);
147	expect(error._tag).toBe("NodeRuntimeUnavailableError");
148	expect(error.message).toContain("Install Node.js");
149	}).pipe(
150	Effect.scoped,
151	Effect.provideService(HostProcessIsExecutable, true),
152	Effect.provide(NodeServices.layer),
153	),
154	);
155
156	it.effect.skipIf(!symlinksSupported)("preserves the node alias used by runtime launchers", () =>
157	Effect.gen(function* () {
158	const fs = yield* FileSystem.FileSystem;
159	const path = yield* Path.Path;
160	const directory = yield* fs.makeTempDirectoryScoped();
161	const platform = yield* HostProcessPlatform;
162	const node = path.join(directory, platform === "win32" ? "node.exe" : "node");
163	yield* fs.symlink(process.execPath, node);
164	expect(yield* resolveNodeExecutable("Local device support", { PATH: directory })).toBe(node);
165	}).pipe(
166	Effect.scoped,
167	Effect.provideService(HostProcessExecutablePath, "/packaged/t3"),
168	Effect.provideService(HostProcessIsExecutable, true),
169	Effect.provide(NodeServices.layer),
170	),
171	);
172
173	it.effect.skipIf(!symlinksSupported)(
174	"rejects a node alias pointing back at the standalone app",
175	() =>
176	Effect.gen(function* () {
177	const fs = yield* FileSystem.FileSystem;
178	const path = yield* Path.Path;
179	const directory = yield* fs.makeTempDirectoryScoped();
180	const platform = yield* HostProcessPlatform;
181	const node = path.join(directory, platform === "win32" ? "node.exe" : "node");
182	yield* fs.symlink(process.execPath, node);
183	const error = yield* resolveNodeExecutable("Local device support", {
184	PATH: directory,
185	}).pipe(Effect.flip);
186	expect(error.message).toContain("Install Node.js");
187	}).pipe(
188	Effect.scoped,
189	Effect.provideService(HostProcessIsExecutable, true),
190	Effect.provide(NodeServices.layer),
191	),
192	);
193	});

packages/shared/src/nodeRuntime.ts created+78

...	@@ -0,0 +1,78 @@
1	import * as Effect from "effect/Effect";
2	import * as FileSystem from "effect/FileSystem";
3	import * as Path from "effect/Path";
4	import * as Option from "effect/Option";
5	import * as Schema from "effect/Schema";
6
7	import {
8	HostProcessEnvironment,
9	HostProcessExecutablePath,
10	HostProcessIsExecutable,
11	HostProcessPlatform,
12	} from "./hostProcess.ts";
13	import { CommandResolutionCache, resolveCommandPath } from "./shell.ts";
14
15	const NodeRuntimeFeature = Schema.Literals([
16	"Local device support",
17	"Device automation",
18	"Antigravity",
19	"Antigravity sign-in",
20	]);
21
22	export const nodeRuntimeUnavailableMessage = (feature: typeof NodeRuntimeFeature.Type): string =>
23	`${feature} requires Node.js. Install Node.js and make sure node is on PATH, then retry.`;
24
25	export class NodeRuntimeUnavailableError extends Schema.TaggedError<NodeRuntimeUnavailableError>()(
26	"NodeRuntimeUnavailableError",
27	{ feature: NodeRuntimeFeature, cause: Schema.optional(Schema.Defect()) },
28	) {
29	override get message(): string {
30	return nodeRuntimeUnavailableMessage(this.feature);
31	}
32	}
33
34	/** A standalone T3 binary runs its embedded CLI, regardless of script arguments. */
35	export const resolveNodeExecutable = Effect.fn("nodeRuntime.resolveNodeExecutable")(function* (
36	feature: typeof NodeRuntimeFeature.Type,
37	environment?: NodeJS.ProcessEnv,
38	) {
39	const executablePath = yield* HostProcessExecutablePath;
40	if (!(yield* HostProcessIsExecutable)) return executablePath;
41
42	const fs = yield* FileSystem.FileSystem;
43	const path = yield* Path.Path;
44	const platform = yield* HostProcessPlatform;
45	const env = environment ?? (yield* HostProcessEnvironment);
46	const nodePath = yield* resolveCommandPath(platform === "win32" ? "node.exe" : "node", {
47	// Batch wrappers require a shell; helper callers launch the runtime directly.
48	env: platform === "win32" ? { ...env, PATHEXT: ".EXE" } : env,
49	}).pipe(
50	// Refresh immediately after the user installs Node and retries setup.
51	Effect.provideService(CommandResolutionCache, new Map()),
52	Effect.map((commandPath) => path.resolve(commandPath)),
53	Effect.mapError((cause) => new NodeRuntimeUnavailableError({ feature, cause })),
54	);
55	// A launcher or symlink named node must not point back at the standalone app.
56	const resolvedPath = yield* fs
57	.realPath(nodePath)
58	.pipe(Effect.mapError((cause) => new NodeRuntimeUnavailableError({ feature, cause })));
59	if (resolvedPath === executablePath) return yield* new NodeRuntimeUnavailableError({ feature });
60	const [hostInfo, nodeInfo] = yield* Effect.all([
61	fs.stat(executablePath).pipe(Effect.option),
62	fs.stat(nodePath).pipe(Effect.option),
63	]);
64	if (
65	Option.isSome(hostInfo) &&
66	Option.isSome(nodeInfo) &&
67	hostInfo.value.dev === nodeInfo.value.dev &&
68	Option.isSome(hostInfo.value.ino) &&
69	Option.isSome(nodeInfo.value.ino) &&
70	Number.isSafeInteger(hostInfo.value.ino.value) &&
71	hostInfo.value.ino.value > 0 &&
72	hostInfo.value.ino.value === nodeInfo.value.ino.value
73	) {
74	return yield* new NodeRuntimeUnavailableError({ feature });
75	}
76	// Launchers such as Vite+ dispatch by argv[0]; keep the node name intact.
77	return nodePath;
78	});

author	Julius Marminge <julius0216@outlook.com> 2026-09-15 23:42:27-07:00
committer	GitHub <noreply@github.com> 2026-09-15 23:42:27-07:00
log	bf55408a5cddbb0f3f7f50d538398e315b5407d0
tree	23f53d74394ba054ee66d5b2ab0399d8167a15f9
parent	6ee03240bccd9287a8c2246e9547697aa5857998
signature	Signed by PGP key B5690EEEBB952194

fix(server): resolve Node for standalone helper scripts (#12033)