feat(app): add native sessions and durable local memory

packages/app/.prettierignore

@@ -1,5 +1,6 @@
 /dist
 /coverage
+/.automation
 /.vite
 .vite/
 /out
@@ -11,4 +12,4 @@ README.md
 template/**
 template/
 
-src/renderer/routes/routeTree.gen.ts
+src/renderer/routes/routeTree.gen.ts

packages/app/automation/check-runtime.ts

@@ -0,0 +1,11 @@
+import { assertSupportedAutomationNodeVersion } from "./runtime.js";
+
+try {
+  assertSupportedAutomationNodeVersion();
+} catch (error) {
+  console.error(
+    "Cannot prepare Electron automation:",
+    error instanceof Error ? error.message : error,
+  );
+  process.exitCode = 1;
+}

packages/app/automation/driver.ts

@@ -10,8 +10,10 @@ import { EnvHttpProxyAgent, setGlobalDispatcher } from "undici";
 import {
   APP_ROOT,
   automationProfilePath,
+  electronBinaryPath,
   preparedChromedriverPath,
   RUNTIME_DIR,
+  withAutomationLoopbackNoProxy,
   WORKSPACE_ROOT,
 } from "./runtime.js";
 
@@ -22,6 +24,11 @@ import {
  * UND_ERR_INVALID_ARG. Install a real Undici dispatcher that also respects the
  * user's proxy and NO_PROXY settings.
  */
+const automationNoProxy = withAutomationLoopbackNoProxy(
+  process.env.NO_PROXY ?? process.env.no_proxy,
+);
+process.env.NO_PROXY = automationNoProxy;
+process.env.no_proxy = automationNoProxy;
 setGlobalDispatcher(new EnvHttpProxyAgent());
 
 const DEFAULT_ENTRY_POINT = path.join(APP_ROOT, ".vite", "build", "main.js");
@@ -208,9 +215,14 @@ export class ConveraDriver {
       appArgs.push(`--user-data-dir=${userDataPath}`);
     }
 
-    const launchTarget = binaryPath
-      ? { appBinaryPath: binaryPath }
-      : { appEntryPoint: entryPoint };
+    // electron-service's appEntryPoint conversion resolves
+    // node_modules/.bin/electron, which is a short-lived JavaScript launcher.
+    // Chromedriver must own the actual Electron executable or it reports the
+    // launcher's clean exit as a misleading user-data-directory lock.
+    if (!binaryPath) appArgs.unshift(`--app=${entryPoint}`);
+    const launchTarget = {
+      appBinaryPath: binaryPath ?? electronBinaryPath(),
+    };
     const capabilities = Object.assign(
       createElectronCapabilities({
         ...launchTarget,

packages/app/automation/runtime.test.ts

@@ -0,0 +1,48 @@
+import { existsSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import {
+  assertSupportedAutomationNodeVersion,
+  chromiumVersion,
+  electronBinaryPath,
+  normalizeElectronBinaryPath,
+  withAutomationLoopbackNoProxy,
+} from "./runtime.js";
+
+describe("automation runtime discovery", () => {
+  it("keeps every local WebDriver endpoint out of host proxies", () => {
+    expect(withAutomationLoopbackNoProxy("example.com,127.0.0.1")).toBe(
+      "example.com,127.0.0.1,localhost,0.0.0.0,::1",
+    );
+    expect(withAutomationLoopbackNoProxy("*")).toBe("*");
+  });
+
+  it("normalizes whitespace accidentally retained by Electron path metadata", () => {
+    expect(normalizeElectronBinaryPath(" /tmp/Electron\n")).toBe(
+      "/tmp/Electron",
+    );
+    expect(() => normalizeElectronBinaryPath(" \n ")).toThrow(
+      "Electron did not provide an executable path",
+    );
+  });
+
+  it("discovers an executable Electron and its Chromium version", () => {
+    expect(existsSync(electronBinaryPath())).toBe(true);
+    expect(chromiumVersion()).toMatch(/^\d+\.\d+\.\d+\.\d+$/);
+  });
+
+  it.each(["20.20.2", "22.18.0", "24.4.1"])(
+    "accepts supported Node %s",
+    (version) => {
+      expect(() => assertSupportedAutomationNodeVersion(version)).not.toThrow();
+    },
+  );
+
+  it.each(["19.9.0", "26.0.0", "invalid"])(
+    "rejects unsupported Node %s",
+    (version) => {
+      expect(() => assertSupportedAutomationNodeVersion(version)).toThrow(
+        /requires Node 20-24/,
+      );
+    },
+  );
+});

packages/app/automation/runtime.ts

@@ -12,8 +12,43 @@ export const RUNTIME_DIR = path.join(APP_ROOT, ".automation");
 
 const require = createRequire(import.meta.url);
 
+const LOOPBACK_NO_PROXY_HOSTS = [
+  "localhost",
+  "127.0.0.1",
+  "0.0.0.0",
+  "::1",
+] as const;
+
+export function withAutomationLoopbackNoProxy(value?: string): string {
+  const entries = (value ?? "")
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  if (entries.includes("*")) return "*";
+  return [...new Set([...entries, ...LOOPBACK_NO_PROXY_HOSTS])].join(",");
+}
+
+export function normalizeElectronBinaryPath(value: unknown): string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error("Electron did not provide an executable path.");
+  }
+  return value.trim();
+}
+
+export function assertSupportedAutomationNodeVersion(
+  version = process.versions.node,
+): void {
+  const major = Number.parseInt(version.split(".", 1)[0] ?? "", 10);
+  if (!Number.isInteger(major) || major < 20 || major >= 26) {
+    throw new Error(
+      `Electron automation packaging requires Node 20-24; received Node ${version}. ` +
+        "Electron Forge 7 can exit before writing the packaged app under Node 26.",
+    );
+  }
+}
+
 export function electronBinaryPath() {
-  return require("electron") as string;
+  return normalizeElectronBinaryPath(require("electron"));
 }
 
 export function automationProfilePath(profileId: string) {
@@ -37,11 +72,11 @@ export function chromiumVersion() {
       env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" },
     },
   );
-  const version = result.stdout.trim();
+  const version = result.stdout?.trim() ?? "";
   if (result.status !== 0 || !/^\d+\.\d+\.\d+\.\d+$/.test(version)) {
-    throw new Error(
-      `Could not read Chromium version from Electron: ${result.stderr.trim() || "unknown error"}`,
-    );
+    const detail =
+      result.error?.message || result.stderr?.trim() || "unknown error";
+    throw new Error(`Could not read Chromium version from Electron: ${detail}`);
   }
   return version;
 }