feat(cli): open projects in the running desktop app

apps/desktop/src/app/DesktopApp.ts

@@ -11,6 +11,7 @@ import * as ElectronDialog from "../electron/ElectronDialog.ts";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
 import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
+import * as DesktopAppActivation from "./DesktopAppActivation.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
 import * as DesktopClerk from "./DesktopClerk.ts";
 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
@@ -148,6 +149,7 @@ const bootstrap = Effect.gen(function* () {
  const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
  const desktopWindow = yield* DesktopWindow.DesktopWindow;
+ const appActivation = yield* DesktopAppActivation.DesktopAppActivation;
  yield* logBootstrapInfo("bootstrap start");
 
  if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {
@@ -210,6 +212,10 @@ const bootstrap = Effect.gen(function* () {
  }
  yield* primaryBackend.start;
  yield* logBootstrapInfo("bootstrap backend start requested");
+ yield* appActivation.start.pipe(
+ Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
+ Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),
+ );
  // Bring up the WSL backend if the user previously enabled it. The
  // primary is already starting; reconcile fires off the WSL register
  // in parallel rather than blocking primary readiness on a possibly

apps/desktop/src/app/DesktopAppActivation.test.ts

@@ -0,0 +1,140 @@
+// @effect-diagnostics nodeBuiltinImport:off -- This adapter test binds a real local socket or Windows named pipe and verifies its cleanup.
+import * as NodeFSP from "node:fs/promises";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import {
+ ProjectId,
+ ThreadId,
+ type DesktopAppActivationRequest,
+ type DesktopAppActivationResponse,
+} from "@t3tools/contracts";
+import { resolveDesktopAppControlAddress } from "@t3tools/shared/desktopAppControl";
+import { HostProcessPlatform, HostProcessUserId } from "@t3tools/shared/hostProcess";
+import { it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import { afterEach, describe, expect } from "vite-plus/test";
+
+import { startDesktopAppControlServer } from "./DesktopAppActivation.ts";
+
+const openServers: Array<{ close: () => Promise<void> }> = [];
+
+afterEach(async () => {
+ await Promise.all(openServers.splice(0).map((server) => server.close()));
+});
+
+function makeTarget(stateDir: string, platform: NodeJS.Platform, userId: number | undefined) {
+ return resolveDesktopAppControlAddress({
+ stateDir,
+ platform,
+ tempDir: NodeOS.tmpdir(),
+ userId,
+ joinPath: NodePath.join,
+ });
+}
+
+function request(requestId: string, platform: NodeJS.Platform): DesktopAppActivationRequest {
+ return {
+ version: 1,
+ requestId,
+ type: "open-workspace",
+ workspaceRoot: NodePath.join(NodeOS.tmpdir(), "project"),
+ platform: platform === "win32" ? "win32" : platform === "darwin" ? "darwin" : "linux",
+ };
+}
+
+function exchange(address: string, payload: DesktopAppActivationRequest) {
+ return new Promise<DesktopAppActivationResponse>((resolve, reject) => {
+ const socket = NodeNet.createConnection(address);
+ socket.setEncoding("utf8");
+ let buffer = "";
+ socket.once("error", reject);
+ socket.once("connect", () => socket.write(`${JSON.stringify(payload)}\n`));
+ socket.on("data", (chunk) => {
+ buffer += chunk;
+ const newline = buffer.indexOf("\n");
+ if (newline === -1) return;
+ socket.destroy();
+ resolve(JSON.parse(buffer.slice(0, newline)) as DesktopAppActivationResponse);
+ });
+ });
+}
+
+describe("desktop app control server", () => {
+ it.effect("roundtrips a request and removes its socket on shutdown", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-control-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ const received: DesktopAppActivationRequest[] = [];
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: async (input) => {
+ received.push(input);
+ return {
+ version: 1,
+ requestId: input.requestId,
+ ok: true,
+ projectId: ProjectId.make("project-1"),
+ threadId: ThreadId.make("thread-1"),
+ };
+ },
+ cancel: () => undefined,
+ });
+ openServers.push(server);
+
+ const response = await exchange(target.address, request("request-1", platform));
+
+ expect(received).toHaveLength(1);
+ expect(response).toMatchObject({ ok: true, requestId: "request-1" });
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ if (target.directory !== null) {
+ await expect(NodeFSP.stat(target.address)).rejects.toMatchObject({ code: "ENOENT" });
+ }
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+
+ it.effect("cancels a queued request when the client disconnects", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-cancel-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ let resolveCanceled: (requestId: string) => void = () => undefined;
+ const canceled = new Promise<string>((resolve) => {
+ resolveCanceled = resolve;
+ });
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: () => new Promise(() => undefined),
+ cancel: resolveCanceled,
+ });
+ openServers.push(server);
+ const socket = NodeNet.createConnection(target.address);
+ await new Promise<void>((resolve, reject) => {
+ socket.once("error", reject);
+ socket.once("connect", () => {
+ socket.write(`${JSON.stringify(request("request-canceled", platform))}\n`, () => {
+ socket.destroy();
+ resolve();
+ });
+ });
+ });
+
+ await expect(canceled).resolves.toBe("request-canceled");
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+});

apps/desktop/src/app/DesktopApp.ts

@@ -11,6 +11,7 @@ import * as ElectronDialog from "../electron/ElectronDialog.ts";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
 import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
+import * as DesktopAppActivation from "./DesktopAppActivation.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
 import * as DesktopClerk from "./DesktopClerk.ts";
 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
@@ -148,6 +149,7 @@ const bootstrap = Effect.gen(function* () {
  const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
  const desktopWindow = yield* DesktopWindow.DesktopWindow;
+ const appActivation = yield* DesktopAppActivation.DesktopAppActivation;
  yield* logBootstrapInfo("bootstrap start");
 
  if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {
@@ -210,6 +212,10 @@ const bootstrap = Effect.gen(function* () {
  }
  yield* primaryBackend.start;
  yield* logBootstrapInfo("bootstrap backend start requested");
+ yield* appActivation.start.pipe(
+ Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
+ Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),
+ );
  // Bring up the WSL backend if the user previously enabled it. The
  // primary is already starting; reconcile fires off the WSL register
  // in parallel rather than blocking primary readiness on a possibly

apps/desktop/src/app/DesktopAppActivation.test.ts

@@ -0,0 +1,140 @@
+// @effect-diagnostics nodeBuiltinImport:off -- This adapter test binds a real local socket or Windows named pipe and verifies its cleanup.
+import * as NodeFSP from "node:fs/promises";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import {
+ ProjectId,
+ ThreadId,
+ type DesktopAppActivationRequest,
+ type DesktopAppActivationResponse,
+} from "@t3tools/contracts";
+import { resolveDesktopAppControlAddress } from "@t3tools/shared/desktopAppControl";
+import { HostProcessPlatform, HostProcessUserId } from "@t3tools/shared/hostProcess";
+import { it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import { afterEach, describe, expect } from "vite-plus/test";
+
+import { startDesktopAppControlServer } from "./DesktopAppActivation.ts";
+
+const openServers: Array<{ close: () => Promise<void> }> = [];
+
+afterEach(async () => {
+ await Promise.all(openServers.splice(0).map((server) => server.close()));
+});
+
+function makeTarget(stateDir: string, platform: NodeJS.Platform, userId: number | undefined) {
+ return resolveDesktopAppControlAddress({
+ stateDir,
+ platform,
+ tempDir: NodeOS.tmpdir(),
+ userId,
+ joinPath: NodePath.join,
+ });
+}
+
+function request(requestId: string, platform: NodeJS.Platform): DesktopAppActivationRequest {
+ return {
+ version: 1,
+ requestId,
+ type: "open-workspace",
+ workspaceRoot: NodePath.join(NodeOS.tmpdir(), "project"),
+ platform: platform === "win32" ? "win32" : platform === "darwin" ? "darwin" : "linux",
+ };
+}
+
+function exchange(address: string, payload: DesktopAppActivationRequest) {
+ return new Promise<DesktopAppActivationResponse>((resolve, reject) => {
+ const socket = NodeNet.createConnection(address);
+ socket.setEncoding("utf8");
+ let buffer = "";
+ socket.once("error", reject);
+ socket.once("connect", () => socket.write(`${JSON.stringify(payload)}\n`));
+ socket.on("data", (chunk) => {
+ buffer += chunk;
+ const newline = buffer.indexOf("\n");
+ if (newline === -1) return;
+ socket.destroy();
+ resolve(JSON.parse(buffer.slice(0, newline)) as DesktopAppActivationResponse);
+ });
+ });
+}
+
+describe("desktop app control server", () => {
+ it.effect("roundtrips a request and removes its socket on shutdown", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-control-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ const received: DesktopAppActivationRequest[] = [];
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: async (input) => {
+ received.push(input);
+ return {
+ version: 1,
+ requestId: input.requestId,
+ ok: true,
+ projectId: ProjectId.make("project-1"),
+ threadId: ThreadId.make("thread-1"),
+ };
+ },
+ cancel: () => undefined,
+ });
+ openServers.push(server);
+
+ const response = await exchange(target.address, request("request-1", platform));
+
+ expect(received).toHaveLength(1);
+ expect(response).toMatchObject({ ok: true, requestId: "request-1" });
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ if (target.directory !== null) {
+ await expect(NodeFSP.stat(target.address)).rejects.toMatchObject({ code: "ENOENT" });
+ }
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+
+ it.effect("cancels a queued request when the client disconnects", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-cancel-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ let resolveCanceled: (requestId: string) => void = () => undefined;
+ const canceled = new Promise<string>((resolve) => {
+ resolveCanceled = resolve;
+ });
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: () => new Promise(() => undefined),
+ cancel: resolveCanceled,
+ });
+ openServers.push(server);
+ const socket = NodeNet.createConnection(target.address);
+ await new Promise<void>((resolve, reject) => {
+ socket.once("error", reject);
+ socket.once("connect", () => {
+ socket.write(`${JSON.stringify(request("request-canceled", platform))}\n`, () => {
+ socket.destroy();
+ resolve();
+ });
+ });
+ });
+
+ await expect(canceled).resolves.toBe("request-canceled");
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+});

apps/desktop/src/app/DesktopApp.ts

@@ -11,6 +11,7 @@ import * as ElectronDialog from "../electron/ElectronDialog.ts";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
 import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
+import * as DesktopAppActivation from "./DesktopAppActivation.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
 import * as DesktopClerk from "./DesktopClerk.ts";
 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
@@ -148,6 +149,7 @@ const bootstrap = Effect.gen(function* () {
  const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
  const desktopWindow = yield* DesktopWindow.DesktopWindow;
+ const appActivation = yield* DesktopAppActivation.DesktopAppActivation;
  yield* logBootstrapInfo("bootstrap start");
 
  if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {
@@ -210,6 +212,10 @@ const bootstrap = Effect.gen(function* () {
  }
  yield* primaryBackend.start;
  yield* logBootstrapInfo("bootstrap backend start requested");
+ yield* appActivation.start.pipe(
+ Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
+ Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),
+ );
  // Bring up the WSL backend if the user previously enabled it. The
  // primary is already starting; reconcile fires off the WSL register
  // in parallel rather than blocking primary readiness on a possibly

apps/desktop/src/app/DesktopAppActivation.test.ts

@@ -0,0 +1,140 @@
+// @effect-diagnostics nodeBuiltinImport:off -- This adapter test binds a real local socket or Windows named pipe and verifies its cleanup.
+import * as NodeFSP from "node:fs/promises";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import {
+ ProjectId,
+ ThreadId,
+ type DesktopAppActivationRequest,
+ type DesktopAppActivationResponse,
+} from "@t3tools/contracts";
+import { resolveDesktopAppControlAddress } from "@t3tools/shared/desktopAppControl";
+import { HostProcessPlatform, HostProcessUserId } from "@t3tools/shared/hostProcess";
+import { it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import { afterEach, describe, expect } from "vite-plus/test";
+
+import { startDesktopAppControlServer } from "./DesktopAppActivation.ts";
+
+const openServers: Array<{ close: () => Promise<void> }> = [];
+
+afterEach(async () => {
+ await Promise.all(openServers.splice(0).map((server) => server.close()));
+});
+
+function makeTarget(stateDir: string, platform: NodeJS.Platform, userId: number | undefined) {
+ return resolveDesktopAppControlAddress({
+ stateDir,
+ platform,
+ tempDir: NodeOS.tmpdir(),
+ userId,
+ joinPath: NodePath.join,
+ });
+}
+
+function request(requestId: string, platform: NodeJS.Platform): DesktopAppActivationRequest {
+ return {
+ version: 1,
+ requestId,
+ type: "open-workspace",
+ workspaceRoot: NodePath.join(NodeOS.tmpdir(), "project"),
+ platform: platform === "win32" ? "win32" : platform === "darwin" ? "darwin" : "linux",
+ };
+}
+
+function exchange(address: string, payload: DesktopAppActivationRequest) {
+ return new Promise<DesktopAppActivationResponse>((resolve, reject) => {
+ const socket = NodeNet.createConnection(address);
+ socket.setEncoding("utf8");
+ let buffer = "";
+ socket.once("error", reject);
+ socket.once("connect", () => socket.write(`${JSON.stringify(payload)}\n`));
+ socket.on("data", (chunk) => {
+ buffer += chunk;
+ const newline = buffer.indexOf("\n");
+ if (newline === -1) return;
+ socket.destroy();
+ resolve(JSON.parse(buffer.slice(0, newline)) as DesktopAppActivationResponse);
+ });
+ });
+}
+
+describe("desktop app control server", () => {
+ it.effect("roundtrips a request and removes its socket on shutdown", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-control-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ const received: DesktopAppActivationRequest[] = [];
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: async (input) => {
+ received.push(input);
+ return {
+ version: 1,
+ requestId: input.requestId,
+ ok: true,
+ projectId: ProjectId.make("project-1"),
+ threadId: ThreadId.make("thread-1"),
+ };
+ },
+ cancel: () => undefined,
+ });
+ openServers.push(server);
+
+ const response = await exchange(target.address, request("request-1", platform));
+
+ expect(received).toHaveLength(1);
+ expect(response).toMatchObject({ ok: true, requestId: "request-1" });
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ if (target.directory !== null) {
+ await expect(NodeFSP.stat(target.address)).rejects.toMatchObject({ code: "ENOENT" });
+ }
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+
+ it.effect("cancels a queued request when the client disconnects", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-cancel-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ let resolveCanceled: (requestId: string) => void = () => undefined;
+ const canceled = new Promise<string>((resolve) => {
+ resolveCanceled = resolve;
+ });
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: () => new Promise(() => undefined),
+ cancel: resolveCanceled,
+ });
+ openServers.push(server);
+ const socket = NodeNet.createConnection(target.address);
+ await new Promise<void>((resolve, reject) => {
+ socket.once("error", reject);
+ socket.once("connect", () => {
+ socket.write(`${JSON.stringify(request("request-canceled", platform))}\n`, () => {
+ socket.destroy();
+ resolve();
+ });
+ });
+ });
+
+ await expect(canceled).resolves.toBe("request-canceled");
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+});

apps/desktop/src/app/DesktopApp.ts

@@ -11,6 +11,7 @@ import * as ElectronDialog from "../electron/ElectronDialog.ts";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
 import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
+import * as DesktopAppActivation from "./DesktopAppActivation.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
 import * as DesktopClerk from "./DesktopClerk.ts";
 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
@@ -148,6 +149,7 @@ const bootstrap = Effect.gen(function* () {
  const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
  const desktopWindow = yield* DesktopWindow.DesktopWindow;
+ const appActivation = yield* DesktopAppActivation.DesktopAppActivation;
  yield* logBootstrapInfo("bootstrap start");
 
  if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {
@@ -210,6 +212,10 @@ const bootstrap = Effect.gen(function* () {
  }
  yield* primaryBackend.start;
  yield* logBootstrapInfo("bootstrap backend start requested");
+ yield* appActivation.start.pipe(
+ Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
+ Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),
+ );
  // Bring up the WSL backend if the user previously enabled it. The
  // primary is already starting; reconcile fires off the WSL register
  // in parallel rather than blocking primary readiness on a possibly

apps/desktop/src/app/DesktopAppActivation.test.ts

@@ -0,0 +1,140 @@
+// @effect-diagnostics nodeBuiltinImport:off -- This adapter test binds a real local socket or Windows named pipe and verifies its cleanup.
+import * as NodeFSP from "node:fs/promises";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import {
+ ProjectId,
+ ThreadId,
+ type DesktopAppActivationRequest,
+ type DesktopAppActivationResponse,
+} from "@t3tools/contracts";
+import { resolveDesktopAppControlAddress } from "@t3tools/shared/desktopAppControl";
+import { HostProcessPlatform, HostProcessUserId } from "@t3tools/shared/hostProcess";
+import { it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import { afterEach, describe, expect } from "vite-plus/test";
+
+import { startDesktopAppControlServer } from "./DesktopAppActivation.ts";
+
+const openServers: Array<{ close: () => Promise<void> }> = [];
+
+afterEach(async () => {
+ await Promise.all(openServers.splice(0).map((server) => server.close()));
+});
+
+function makeTarget(stateDir: string, platform: NodeJS.Platform, userId: number | undefined) {
+ return resolveDesktopAppControlAddress({
+ stateDir,
+ platform,
+ tempDir: NodeOS.tmpdir(),
+ userId,
+ joinPath: NodePath.join,
+ });
+}
+
+function request(requestId: string, platform: NodeJS.Platform): DesktopAppActivationRequest {
+ return {
+ version: 1,
+ requestId,
+ type: "open-workspace",
+ workspaceRoot: NodePath.join(NodeOS.tmpdir(), "project"),
+ platform: platform === "win32" ? "win32" : platform === "darwin" ? "darwin" : "linux",
+ };
+}
+
+function exchange(address: string, payload: DesktopAppActivationRequest) {
+ return new Promise<DesktopAppActivationResponse>((resolve, reject) => {
+ const socket = NodeNet.createConnection(address);
+ socket.setEncoding("utf8");
+ let buffer = "";
+ socket.once("error", reject);
+ socket.once("connect", () => socket.write(`${JSON.stringify(payload)}\n`));
+ socket.on("data", (chunk) => {
+ buffer += chunk;
+ const newline = buffer.indexOf("\n");
+ if (newline === -1) return;
+ socket.destroy();
+ resolve(JSON.parse(buffer.slice(0, newline)) as DesktopAppActivationResponse);
+ });
+ });
+}
+
+describe("desktop app control server", () => {
+ it.effect("roundtrips a request and removes its socket on shutdown", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-control-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ const received: DesktopAppActivationRequest[] = [];
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: async (input) => {
+ received.push(input);
+ return {
+ version: 1,
+ requestId: input.requestId,
+ ok: true,
+ projectId: ProjectId.make("project-1"),
+ threadId: ThreadId.make("thread-1"),
+ };
+ },
+ cancel: () => undefined,
+ });
+ openServers.push(server);
+
+ const response = await exchange(target.address, request("request-1", platform));
+
+ expect(received).toHaveLength(1);
+ expect(response).toMatchObject({ ok: true, requestId: "request-1" });
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ if (target.directory !== null) {
+ await expect(NodeFSP.stat(target.address)).rejects.toMatchObject({ code: "ENOENT" });
+ }
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+
+ it.effect("cancels a queued request when the client disconnects", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-cancel-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ let resolveCanceled: (requestId: string) => void = () => undefined;
+ const canceled = new Promise<string>((resolve) => {
+ resolveCanceled = resolve;
+ });
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: () => new Promise(() => undefined),
+ cancel: resolveCanceled,
+ });
+ openServers.push(server);
+ const socket = NodeNet.createConnection(target.address);
+ await new Promise<void>((resolve, reject) => {
+ socket.once("error", reject);
+ socket.once("connect", () => {
+ socket.write(`${JSON.stringify(request("request-canceled", platform))}\n`, () => {
+ socket.destroy();
+ resolve();
+ });
+ });
+ });
+
+ await expect(canceled).resolves.toBe("request-canceled");
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+});

apps/desktop/src/app/DesktopApp.ts

@@ -11,6 +11,7 @@ import * as ElectronDialog from "../electron/ElectronDialog.ts";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
 import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
+import * as DesktopAppActivation from "./DesktopAppActivation.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
 import * as DesktopClerk from "./DesktopClerk.ts";
 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
@@ -148,6 +149,7 @@ const bootstrap = Effect.gen(function* () {
  const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
  const desktopWindow = yield* DesktopWindow.DesktopWindow;
+ const appActivation = yield* DesktopAppActivation.DesktopAppActivation;
  yield* logBootstrapInfo("bootstrap start");
 
  if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {
@@ -210,6 +212,10 @@ const bootstrap = Effect.gen(function* () {
  }
  yield* primaryBackend.start;
  yield* logBootstrapInfo("bootstrap backend start requested");
+ yield* appActivation.start.pipe(
+ Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
+ Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),
+ );
  // Bring up the WSL backend if the user previously enabled it. The
  // primary is already starting; reconcile fires off the WSL register
  // in parallel rather than blocking primary readiness on a possibly

apps/desktop/src/app/DesktopAppActivation.test.ts

@@ -0,0 +1,140 @@
+// @effect-diagnostics nodeBuiltinImport:off -- This adapter test binds a real local socket or Windows named pipe and verifies its cleanup.
+import * as NodeFSP from "node:fs/promises";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import {
+ ProjectId,
+ ThreadId,
+ type DesktopAppActivationRequest,
+ type DesktopAppActivationResponse,
+} from "@t3tools/contracts";
+import { resolveDesktopAppControlAddress } from "@t3tools/shared/desktopAppControl";
+import { HostProcessPlatform, HostProcessUserId } from "@t3tools/shared/hostProcess";
+import { it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import { afterEach, describe, expect } from "vite-plus/test";
+
+import { startDesktopAppControlServer } from "./DesktopAppActivation.ts";
+
+const openServers: Array<{ close: () => Promise<void> }> = [];
+
+afterEach(async () => {
+ await Promise.all(openServers.splice(0).map((server) => server.close()));
+});
+
+function makeTarget(stateDir: string, platform: NodeJS.Platform, userId: number | undefined) {
+ return resolveDesktopAppControlAddress({
+ stateDir,
+ platform,
+ tempDir: NodeOS.tmpdir(),
+ userId,
+ joinPath: NodePath.join,
+ });
+}
+
+function request(requestId: string, platform: NodeJS.Platform): DesktopAppActivationRequest {
+ return {
+ version: 1,
+ requestId,
+ type: "open-workspace",
+ workspaceRoot: NodePath.join(NodeOS.tmpdir(), "project"),
+ platform: platform === "win32" ? "win32" : platform === "darwin" ? "darwin" : "linux",
+ };
+}
+
+function exchange(address: string, payload: DesktopAppActivationRequest) {
+ return new Promise<DesktopAppActivationResponse>((resolve, reject) => {
+ const socket = NodeNet.createConnection(address);
+ socket.setEncoding("utf8");
+ let buffer = "";
+ socket.once("error", reject);
+ socket.once("connect", () => socket.write(`${JSON.stringify(payload)}\n`));
+ socket.on("data", (chunk) => {
+ buffer += chunk;
+ const newline = buffer.indexOf("\n");
+ if (newline === -1) return;
+ socket.destroy();
+ resolve(JSON.parse(buffer.slice(0, newline)) as DesktopAppActivationResponse);
+ });
+ });
+}
+
+describe("desktop app control server", () => {
+ it.effect("roundtrips a request and removes its socket on shutdown", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-control-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ const received: DesktopAppActivationRequest[] = [];
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: async (input) => {
+ received.push(input);
+ return {
+ version: 1,
+ requestId: input.requestId,
+ ok: true,
+ projectId: ProjectId.make("project-1"),
+ threadId: ThreadId.make("thread-1"),
+ };
+ },
+ cancel: () => undefined,
+ });
+ openServers.push(server);
+
+ const response = await exchange(target.address, request("request-1", platform));
+
+ expect(received).toHaveLength(1);
+ expect(response).toMatchObject({ ok: true, requestId: "request-1" });
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ if (target.directory !== null) {
+ await expect(NodeFSP.stat(target.address)).rejects.toMatchObject({ code: "ENOENT" });
+ }
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+
+ it.effect("cancels a queued request when the client disconnects", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-cancel-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ let resolveCanceled: (requestId: string) => void = () => undefined;
+ const canceled = new Promise<string>((resolve) => {
+ resolveCanceled = resolve;
+ });
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: () => new Promise(() => undefined),
+ cancel: resolveCanceled,
+ });
+ openServers.push(server);
+ const socket = NodeNet.createConnection(target.address);
+ await new Promise<void>((resolve, reject) => {
+ socket.once("error", reject);
+ socket.once("connect", () => {
+ socket.write(`${JSON.stringify(request("request-canceled", platform))}\n`, () => {
+ socket.destroy();
+ resolve();
+ });
+ });
+ });
+
+ await expect(canceled).resolves.toBe("request-canceled");
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+});

apps/desktop/src/app/DesktopApp.ts

@@ -11,6 +11,7 @@ import * as ElectronDialog from "../electron/ElectronDialog.ts";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
 import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
+import * as DesktopAppActivation from "./DesktopAppActivation.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
 import * as DesktopClerk from "./DesktopClerk.ts";
 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
@@ -148,6 +149,7 @@ const bootstrap = Effect.gen(function* () {
  const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
  const desktopWindow = yield* DesktopWindow.DesktopWindow;
+ const appActivation = yield* DesktopAppActivation.DesktopAppActivation;
  yield* logBootstrapInfo("bootstrap start");
 
  if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {
@@ -210,6 +212,10 @@ const bootstrap = Effect.gen(function* () {
  }
  yield* primaryBackend.start;
  yield* logBootstrapInfo("bootstrap backend start requested");
+ yield* appActivation.start.pipe(
+ Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
+ Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),
+ );
  // Bring up the WSL backend if the user previously enabled it. The
  // primary is already starting; reconcile fires off the WSL register
  // in parallel rather than blocking primary readiness on a possibly

apps/desktop/src/app/DesktopAppActivation.test.ts

@@ -0,0 +1,140 @@
+// @effect-diagnostics nodeBuiltinImport:off -- This adapter test binds a real local socket or Windows named pipe and verifies its cleanup.
+import * as NodeFSP from "node:fs/promises";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import {
+ ProjectId,
+ ThreadId,
+ type DesktopAppActivationRequest,
+ type DesktopAppActivationResponse,
+} from "@t3tools/contracts";
+import { resolveDesktopAppControlAddress } from "@t3tools/shared/desktopAppControl";
+import { HostProcessPlatform, HostProcessUserId } from "@t3tools/shared/hostProcess";
+import { it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import { afterEach, describe, expect } from "vite-plus/test";
+
+import { startDesktopAppControlServer } from "./DesktopAppActivation.ts";
+
+const openServers: Array<{ close: () => Promise<void> }> = [];
+
+afterEach(async () => {
+ await Promise.all(openServers.splice(0).map((server) => server.close()));
+});
+
+function makeTarget(stateDir: string, platform: NodeJS.Platform, userId: number | undefined) {
+ return resolveDesktopAppControlAddress({
+ stateDir,
+ platform,
+ tempDir: NodeOS.tmpdir(),
+ userId,
+ joinPath: NodePath.join,
+ });
+}
+
+function request(requestId: string, platform: NodeJS.Platform): DesktopAppActivationRequest {
+ return {
+ version: 1,
+ requestId,
+ type: "open-workspace",
+ workspaceRoot: NodePath.join(NodeOS.tmpdir(), "project"),
+ platform: platform === "win32" ? "win32" : platform === "darwin" ? "darwin" : "linux",
+ };
+}
+
+function exchange(address: string, payload: DesktopAppActivationRequest) {
+ return new Promise<DesktopAppActivationResponse>((resolve, reject) => {
+ const socket = NodeNet.createConnection(address);
+ socket.setEncoding("utf8");
+ let buffer = "";
+ socket.once("error", reject);
+ socket.once("connect", () => socket.write(`${JSON.stringify(payload)}\n`));
+ socket.on("data", (chunk) => {
+ buffer += chunk;
+ const newline = buffer.indexOf("\n");
+ if (newline === -1) return;
+ socket.destroy();
+ resolve(JSON.parse(buffer.slice(0, newline)) as DesktopAppActivationResponse);
+ });
+ });
+}
+
+describe("desktop app control server", () => {
+ it.effect("roundtrips a request and removes its socket on shutdown", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-control-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ const received: DesktopAppActivationRequest[] = [];
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: async (input) => {
+ received.push(input);
+ return {
+ version: 1,
+ requestId: input.requestId,
+ ok: true,
+ projectId: ProjectId.make("project-1"),
+ threadId: ThreadId.make("thread-1"),
+ };
+ },
+ cancel: () => undefined,
+ });
+ openServers.push(server);
+
+ const response = await exchange(target.address, request("request-1", platform));
+
+ expect(received).toHaveLength(1);
+ expect(response).toMatchObject({ ok: true, requestId: "request-1" });
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ if (target.directory !== null) {
+ await expect(NodeFSP.stat(target.address)).rejects.toMatchObject({ code: "ENOENT" });
+ }
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+
+ it.effect("cancels a queued request when the client disconnects", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-cancel-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ let resolveCanceled: (requestId: string) => void = () => undefined;
+ const canceled = new Promise<string>((resolve) => {
+ resolveCanceled = resolve;
+ });
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: () => new Promise(() => undefined),
+ cancel: resolveCanceled,
+ });
+ openServers.push(server);
+ const socket = NodeNet.createConnection(target.address);
+ await new Promise<void>((resolve, reject) => {
+ socket.once("error", reject);
+ socket.once("connect", () => {
+ socket.write(`${JSON.stringify(request("request-canceled", platform))}\n`, () => {
+ socket.destroy();
+ resolve();
+ });
+ });
+ });
+
+ await expect(canceled).resolves.toBe("request-canceled");
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+});

apps/desktop/src/app/DesktopApp.ts

@@ -11,6 +11,7 @@ import * as ElectronDialog from "../electron/ElectronDialog.ts";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
 import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
+import * as DesktopAppActivation from "./DesktopAppActivation.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
 import * as DesktopClerk from "./DesktopClerk.ts";
 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
@@ -148,6 +149,7 @@ const bootstrap = Effect.gen(function* () {
  const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
  const desktopWindow = yield* DesktopWindow.DesktopWindow;
+ const appActivation = yield* DesktopAppActivation.DesktopAppActivation;
  yield* logBootstrapInfo("bootstrap start");
 
  if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {
@@ -210,6 +212,10 @@ const bootstrap = Effect.gen(function* () {
  }
  yield* primaryBackend.start;
  yield* logBootstrapInfo("bootstrap backend start requested");
+ yield* appActivation.start.pipe(
+ Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
+ Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),
+ );
  // Bring up the WSL backend if the user previously enabled it. The
  // primary is already starting; reconcile fires off the WSL register
  // in parallel rather than blocking primary readiness on a possibly

apps/desktop/src/app/DesktopAppActivation.test.ts

@@ -0,0 +1,140 @@
+// @effect-diagnostics nodeBuiltinImport:off -- This adapter test binds a real local socket or Windows named pipe and verifies its cleanup.
+import * as NodeFSP from "node:fs/promises";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import {
+ ProjectId,
+ ThreadId,
+ type DesktopAppActivationRequest,
+ type DesktopAppActivationResponse,
+} from "@t3tools/contracts";
+import { resolveDesktopAppControlAddress } from "@t3tools/shared/desktopAppControl";
+import { HostProcessPlatform, HostProcessUserId } from "@t3tools/shared/hostProcess";
+import { it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import { afterEach, describe, expect } from "vite-plus/test";
+
+import { startDesktopAppControlServer } from "./DesktopAppActivation.ts";
+
+const openServers: Array<{ close: () => Promise<void> }> = [];
+
+afterEach(async () => {
+ await Promise.all(openServers.splice(0).map((server) => server.close()));
+});
+
+function makeTarget(stateDir: string, platform: NodeJS.Platform, userId: number | undefined) {
+ return resolveDesktopAppControlAddress({
+ stateDir,
+ platform,
+ tempDir: NodeOS.tmpdir(),
+ userId,
+ joinPath: NodePath.join,
+ });
+}
+
+function request(requestId: string, platform: NodeJS.Platform): DesktopAppActivationRequest {
+ return {
+ version: 1,
+ requestId,
+ type: "open-workspace",
+ workspaceRoot: NodePath.join(NodeOS.tmpdir(), "project"),
+ platform: platform === "win32" ? "win32" : platform === "darwin" ? "darwin" : "linux",
+ };
+}
+
+function exchange(address: string, payload: DesktopAppActivationRequest) {
+ return new Promise<DesktopAppActivationResponse>((resolve, reject) => {
+ const socket = NodeNet.createConnection(address);
+ socket.setEncoding("utf8");
+ let buffer = "";
+ socket.once("error", reject);
+ socket.once("connect", () => socket.write(`${JSON.stringify(payload)}\n`));
+ socket.on("data", (chunk) => {
+ buffer += chunk;
+ const newline = buffer.indexOf("\n");
+ if (newline === -1) return;
+ socket.destroy();
+ resolve(JSON.parse(buffer.slice(0, newline)) as DesktopAppActivationResponse);
+ });
+ });
+}
+
+describe("desktop app control server", () => {
+ it.effect("roundtrips a request and removes its socket on shutdown", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-control-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ const received: DesktopAppActivationRequest[] = [];
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: async (input) => {
+ received.push(input);
+ return {
+ version: 1,
+ requestId: input.requestId,
+ ok: true,
+ projectId: ProjectId.make("project-1"),
+ threadId: ThreadId.make("thread-1"),
+ };
+ },
+ cancel: () => undefined,
+ });
+ openServers.push(server);
+
+ const response = await exchange(target.address, request("request-1", platform));
+
+ expect(received).toHaveLength(1);
+ expect(response).toMatchObject({ ok: true, requestId: "request-1" });
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ if (target.directory !== null) {
+ await expect(NodeFSP.stat(target.address)).rejects.toMatchObject({ code: "ENOENT" });
+ }
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+
+ it.effect("cancels a queued request when the client disconnects", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-cancel-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ let resolveCanceled: (requestId: string) => void = () => undefined;
+ const canceled = new Promise<string>((resolve) => {
+ resolveCanceled = resolve;
+ });
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: () => new Promise(() => undefined),
+ cancel: resolveCanceled,
+ });
+ openServers.push(server);
+ const socket = NodeNet.createConnection(target.address);
+ await new Promise<void>((resolve, reject) => {
+ socket.once("error", reject);
+ socket.once("connect", () => {
+ socket.write(`${JSON.stringify(request("request-canceled", platform))}\n`, () => {
+ socket.destroy();
+ resolve();
+ });
+ });
+ });
+
+ await expect(canceled).resolves.toBe("request-canceled");
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+});

apps/desktop/src/app/DesktopApp.ts

@@ -11,6 +11,7 @@ import * as ElectronDialog from "../electron/ElectronDialog.ts";
 import * as ElectronProtocol from "../electron/ElectronProtocol.ts";
 import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
 import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts";
+import * as DesktopAppActivation from "./DesktopAppActivation.ts";
 import * as DesktopAppIdentity from "./DesktopAppIdentity.ts";
 import * as DesktopClerk from "./DesktopClerk.ts";
 import * as DesktopApplicationMenu from "../window/DesktopApplicationMenu.ts";
@@ -148,6 +149,7 @@ const bootstrap = Effect.gen(function* () {
  const serverExposure = yield* DesktopServerExposure.DesktopServerExposure;
  const wslBackend = yield* DesktopWslBackend.DesktopWslBackend;
  const desktopWindow = yield* DesktopWindow.DesktopWindow;
+ const appActivation = yield* DesktopAppActivation.DesktopAppActivation;
  yield* logBootstrapInfo("bootstrap start");
 
  if (environment.isDevelopment && Option.isNone(environment.configuredBackendPort)) {
@@ -210,6 +212,10 @@ const bootstrap = Effect.gen(function* () {
  }
  yield* primaryBackend.start;
  yield* logBootstrapInfo("bootstrap backend start requested");
+ yield* appActivation.start.pipe(
+ Effect.tap(() => logBootstrapInfo("desktop app control socket ready")),
+ Effect.catch((error) => logStartupError("desktop app control socket unavailable", { error })),
+ );
  // Bring up the WSL backend if the user previously enabled it. The
  // primary is already starting; reconcile fires off the WSL register
  // in parallel rather than blocking primary readiness on a possibly

apps/desktop/src/app/DesktopAppActivation.test.ts

@@ -0,0 +1,140 @@
+// @effect-diagnostics nodeBuiltinImport:off -- This adapter test binds a real local socket or Windows named pipe and verifies its cleanup.
+import * as NodeFSP from "node:fs/promises";
+import * as NodeNet from "node:net";
+import * as NodeOS from "node:os";
+import * as NodePath from "node:path";
+
+import {
+ ProjectId,
+ ThreadId,
+ type DesktopAppActivationRequest,
+ type DesktopAppActivationResponse,
+} from "@t3tools/contracts";
+import { resolveDesktopAppControlAddress } from "@t3tools/shared/desktopAppControl";
+import { HostProcessPlatform, HostProcessUserId } from "@t3tools/shared/hostProcess";
+import { it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import { afterEach, describe, expect } from "vite-plus/test";
+
+import { startDesktopAppControlServer } from "./DesktopAppActivation.ts";
+
+const openServers: Array<{ close: () => Promise<void> }> = [];
+
+afterEach(async () => {
+ await Promise.all(openServers.splice(0).map((server) => server.close()));
+});
+
+function makeTarget(stateDir: string, platform: NodeJS.Platform, userId: number | undefined) {
+ return resolveDesktopAppControlAddress({
+ stateDir,
+ platform,
+ tempDir: NodeOS.tmpdir(),
+ userId,
+ joinPath: NodePath.join,
+ });
+}
+
+function request(requestId: string, platform: NodeJS.Platform): DesktopAppActivationRequest {
+ return {
+ version: 1,
+ requestId,
+ type: "open-workspace",
+ workspaceRoot: NodePath.join(NodeOS.tmpdir(), "project"),
+ platform: platform === "win32" ? "win32" : platform === "darwin" ? "darwin" : "linux",
+ };
+}
+
+function exchange(address: string, payload: DesktopAppActivationRequest) {
+ return new Promise<DesktopAppActivationResponse>((resolve, reject) => {
+ const socket = NodeNet.createConnection(address);
+ socket.setEncoding("utf8");
+ let buffer = "";
+ socket.once("error", reject);
+ socket.once("connect", () => socket.write(`${JSON.stringify(payload)}\n`));
+ socket.on("data", (chunk) => {
+ buffer += chunk;
+ const newline = buffer.indexOf("\n");
+ if (newline === -1) return;
+ socket.destroy();
+ resolve(JSON.parse(buffer.slice(0, newline)) as DesktopAppActivationResponse);
+ });
+ });
+}
+
+describe("desktop app control server", () => {
+ it.effect("roundtrips a request and removes its socket on shutdown", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-control-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ const received: DesktopAppActivationRequest[] = [];
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: async (input) => {
+ received.push(input);
+ return {
+ version: 1,
+ requestId: input.requestId,
+ ok: true,
+ projectId: ProjectId.make("project-1"),
+ threadId: ThreadId.make("thread-1"),
+ };
+ },
+ cancel: () => undefined,
+ });
+ openServers.push(server);
+
+ const response = await exchange(target.address, request("request-1", platform));
+
+ expect(received).toHaveLength(1);
+ expect(response).toMatchObject({ ok: true, requestId: "request-1" });
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ if (target.directory !== null) {
+ await expect(NodeFSP.stat(target.address)).rejects.toMatchObject({ code: "ENOENT" });
+ }
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+
+ it.effect("cancels a queued request when the client disconnects", () =>
+ Effect.gen(function* () {
+ const platform = yield* HostProcessPlatform;
+ const userId = yield* HostProcessUserId;
+ yield* Effect.promise(async () => {
+ const root = await NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "t3-app-cancel-test-"));
+ const target = makeTarget(NodePath.join(root, "userdata"), platform, userId);
+ let resolveCanceled: (requestId: string) => void = () => undefined;
+ const canceled = new Promise<string>((resolve) => {
+ resolveCanceled = resolve;
+ });
+ const server = await startDesktopAppControlServer({
+ ...target,
+ userId,
+ handle: () => new Promise(() => undefined),
+ cancel: resolveCanceled,
+ });
+ openServers.push(server);
+ const socket = NodeNet.createConnection(target.address);
+ await new Promise<void>((resolve, reject) => {
+ socket.once("error", reject);
+ socket.once("connect", () => {
+ socket.write(`${JSON.stringify(request("request-canceled", platform))}\n`, () => {
+ socket.destroy();
+ resolve();
+ });
+ });
+ });
+
+ await expect(canceled).resolves.toBe("request-canceled");
+ await server.close();
+ openServers.splice(openServers.indexOf(server), 1);
+ await NodeFSP.rm(root, { recursive: true, force: true });
+ });
+ }),
+ );
+});