Fix brain CRDT sync packaging + surface remote runtime integrations (#542)

Author: arul28

apps/ade-cli/scripts/package-native-deps.mjs

@@ -207,6 +207,50 @@ async function writeManifest(bundleRoot, target, packages) {
   await fs.writeFile(path.join(bundleRoot, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
 }
 
+// Targets shipped as the production brain, where cr-sqlite is mandatory. A
+// missing extension for one of these would silently re-ship the exact
+// crsql_internal_sync_bit crash this packaging step exists to prevent, so it's
+// a hard build failure rather than a warning. Other targets (not yet vendored)
+// warn-and-skip until their extension is added.
+const CRSQLITE_REQUIRED_TARGETS = new Set(["darwin-arm64"]);
+
+function crsqliteExtensionFileName(target) {
+  const { platform } = targetParts(target);
+  if (platform === "darwin") return "crsqlite.dylib";
+  if (platform === "linux") return "crsqlite.so";
+  throw new Error(`No cr-sqlite extension filename mapping for platform '${platform}' (target ${target}).`);
+}
+
+async function copyCrsqliteExtension(bundleRoot, target) {
+  // The brain (this runtime) is the default sync host and needs cr-sqlite to
+  // run CRDT replication to paired peers. The desktop app bundle ships it, but
+  // the static/headless install only gets this native tarball — so without
+  // copying it here the installed brain has no CRR engine and every write to a
+  // CRR table crashes on crsql_internal_sync_bit. Mirror the desktop vendor
+  // layout (vendor/crsqlite/<target>/) so crsqliteExtension.ts resolves it from
+  // <ADE_HOME>/runtime/<target>/.
+  const fileName = crsqliteExtensionFileName(target);
+  const source = path.join(packageRoot, "..", "desktop", "vendor", "crsqlite", target, fileName);
+  if (!(await exists(source))) {
+    if (CRSQLITE_REQUIRED_TARGETS.has(target)) {
+      throw new Error(
+        `[package-native-deps] no cr-sqlite extension vendored for required target ${target} (${source}); ` +
+          `the installed brain would crash on every CRR write. Add crsqlite for this target under ` +
+          `apps/desktop/vendor/crsqlite/${target}/.`,
+      );
+    }
+    process.stderr.write(
+      `[package-native-deps] WARNING: no cr-sqlite extension vendored for ${target} ` +
+        `(${source}); the installed brain on this target will lack CRDT sync.\n`,
+    );
+    return false;
+  }
+  const destination = path.join(bundleRoot, "vendor", "crsqlite", target, fileName);
+  await fs.mkdir(path.dirname(destination), { recursive: true });
+  await fs.copyFile(source, destination);
+  return true;
+}
+
 async function copyBuiltTuiClient(bundleRoot) {
   const source = path.join(packageRoot, "dist", "tuiClient", "cli.mjs");
   if (!(await exists(source))) {
@@ -271,6 +315,7 @@ async function main() {
     }
   }
   await copyBuiltTuiClient(bundleRoot);
+  await copyCrsqliteExtension(bundleRoot, args.target);
   await chmodRuntimeExecutables(bundleRoot, args.target);
   await writeManifest(bundleRoot, args.target, copied);
 

apps/desktop/src/main/main.ts

@@ -1535,7 +1535,12 @@ app.whenReady().then(async () => {
     if (!activeProjectRoot || !rootsBoundToWindows().has(activeProjectRoot)) {
       setForegroundProject(firstOpenWindowProjectRoot());
     }
-    emitProjectChangedToWindow(windowId, null);
+    // Do NOT emit a standalone projectChanged(null) before the remote binding.
+    // It would reach the renderer as a separate IPC message and momentarily put
+    // the window into project==null && !remoteBinding && showWelcome==true,
+    // which used to wipe the open-tab lists (see TopBar). The binding-changed
+    // event below fully drives the remote view (AppShell.applyProjectState) and
+    // sets the remote window title itself, so the null precursor is redundant.
     emitProjectBindingChangedToWindow(windowId, binding);
   };
 
@@ -5933,7 +5938,9 @@ app.whenReady().then(async () => {
         await switchProjectFromDialog(args.projectRoot!);
       });
     } else if (restoredRemoteBinding) {
-      emitProjectChangedToWindow(win.id, null);
+      // Binding-changed alone drives the remote view and title; skip the
+      // standalone projectChanged(null) precursor so the renderer never sees a
+      // transient "no project" state that would clear restored tabs.
       emitProjectBindingChangedToWindow(win.id, restoredRemoteBinding);
     } else {
       emitProjectChangedToWindow(win.id, null);

apps/desktop/src/main/services/remoteRuntime/remoteConnectionService.test.ts

@@ -475,26 +475,38 @@ describe("RemoteConnectionService", () => {
     expect(pool.connect).toHaveBeenCalledTimes(10);
   });
 
-  it("does not spend the reconnect budget on ordinary remote action errors", async () => {
+  it("keeps the connection healthy and spends no budget on ordinary remote action errors", async () => {
     const previouslyConnected = target("previously-connected", 1_700_000_000);
     const registry = {
       list: vi.fn(() => [previouslyConnected]),
       get: vi.fn((id: string) =>
         id === previouslyConnected.id ? previouslyConnected : null,
       ),
     } as unknown as RemoteTargetRegistry;
+    let succeed = true;
     const pool = {
       connect: vi.fn(async (target: RemoteRuntimeTarget) =>
         connectResult(target),
       ),
       disconnect: vi.fn(),
       callActionForTarget: vi.fn(async () => {
+        if (succeed) {
+          return { domain: "file", action: "read", result: { ok: true }, statusHints: {} };
+        }
         throw new Error("Action 'pr.listQueueStates' is not callable.");
       }),
       onEntryEvicted: vi.fn(() => () => {}),
     } as unknown as RemoteConnectionPool;
 
     const service = new RemoteConnectionService(registry, pool);
+    // Establish a healthy connection via a successful call.
+    await service.callAction(previouslyConnected.id, "project-1", {
+      domain: "file",
+      action: "read",
+    });
+    expect(service.snapshot().connections[0]?.state).toBe("connected");
+
+    succeed = false;
     for (let attempt = 0; attempt < 10; attempt += 1) {
       await expect(
         service.callAction(previouslyConnected.id, "project-1", {
@@ -504,15 +516,86 @@ describe("RemoteConnectionService", () => {
       ).rejects.toThrow(/not callable/i);
     }
 
+    // An application-level error came back over a live channel — the host is
+    // reachable, so the connection must stay connected (no "unreachable" toast,
+    // no reconnect loop) and the auto-reconnect budget is untouched.
+    expect(pool.callActionForTarget).toHaveBeenCalledTimes(11);
+    expect(service.snapshot().connections[0]?.state).toBe("connected");
+    expect(service.snapshot().connections[0]?.lastError).toBeNull();
+  });
+
+  it("does not flag the remote unreachable when adding a project fails with a host-side error", async () => {
+    const previouslyConnected = target("previously-connected", 1_700_000_000);
+    const registry = {
+      list: vi.fn(() => [previouslyConnected]),
+      get: vi.fn((id: string) =>
+        id === previouslyConnected.id ? previouslyConnected : null,
+      ),
+    } as unknown as RemoteTargetRegistry;
+    const pool = {
+      connect: vi.fn(async (target: RemoteRuntimeTarget) =>
+        connectResult(target),
+      ),
+      disconnect: vi.fn(),
+      addProjectForTarget: vi.fn(async () => {
+        throw new Error(
+          "no such function: crsql_internal_sync_bit [sql=delete from process_definitions where project_id = ?]",
+        );
+      }),
+      onEntryEvicted: vi.fn(() => () => {}),
+    } as unknown as RemoteConnectionPool;
+
+    const service = new RemoteConnectionService(registry, pool);
+    await service.connect(previouslyConnected.id, { explicit: true });
+    expect(service.snapshot().connections[0]?.state).toBe("connected");
+
+    await expect(
+      service.addProject(previouslyConnected.id, "/repo/versic"),
+    ).rejects.toThrow(/crsql_internal_sync_bit/i);
+
+    expect(service.snapshot().connections[0]?.state).toBe("connected");
+    expect(service.snapshot().connections[0]?.lastError).toBeNull();
+  });
+
+  it("flips to error when a remote call fails with a transport-level error", async () => {
+    const previouslyConnected = target("previously-connected", 1_700_000_000);
+    const registry = {
+      list: vi.fn(() => [previouslyConnected]),
+      get: vi.fn((id: string) =>
+        id === previouslyConnected.id ? previouslyConnected : null,
+      ),
+    } as unknown as RemoteTargetRegistry;
+    let succeed = true;
+    const pool = {
+      connect: vi.fn(async (target: RemoteRuntimeTarget) =>
+        connectResult(target),
+      ),
+      disconnect: vi.fn(),
+      callActionForTarget: vi.fn(async () => {
+        if (succeed) {
+          return { domain: "file", action: "read", result: { ok: true }, statusHints: {} };
+        }
+        throw new Error("remote ADE service connection closed");
+      }),
+      onEntryEvicted: vi.fn(() => () => {}),
+    } as unknown as RemoteConnectionPool;
+
+    const service = new RemoteConnectionService(registry, pool);
+    await service.callAction(previouslyConnected.id, "project-1", {
+      domain: "file",
+      action: "read",
+    });
+
+    succeed = false;
     await expect(
       service.callAction(previouslyConnected.id, "project-1", {
-        domain: "pr",
-        action: "listQueueStates",
+        domain: "file",
+        action: "read",
       }),
-    ).rejects.toThrow(/not callable/i);
-    expect(pool.callActionForTarget).toHaveBeenCalledTimes(11);
+    ).rejects.toThrow(/connection closed/i);
+    expect(service.snapshot().connections[0]?.state).toBe("error");
     expect(service.snapshot().connections[0]?.lastError).toMatch(
-      /not callable/i,
+      /connection closed/i,
     );
   });
 });

apps/desktop/src/main/services/remoteRuntime/remoteConnectionService.ts

@@ -329,11 +329,7 @@ export class RemoteConnectionService {
       this.clearAutomaticReconnectBudget(targetId);
       return projects;
     } catch (error) {
-      this.mergeStatus(targetId, {
-        state: "error",
-        lastError: this.recordImplicitFailure(targetId, error),
-        lastAttemptedAt: Date.now(),
-      });
+      this.markCallFailure(targetId, error);
       throw error;
     }
   }
@@ -350,11 +346,7 @@ export class RemoteConnectionService {
       this.clearAutomaticReconnectBudget(targetId);
       return project;
     } catch (error) {
-      this.mergeStatus(targetId, {
-        state: "error",
-        lastError: this.recordImplicitFailure(targetId, error),
-        lastAttemptedAt: Date.now(),
-      });
+      this.markCallFailure(targetId, error);
       throw error;
     }
   }
@@ -368,11 +360,7 @@ export class RemoteConnectionService {
     try {
       return await this.pool.ensureLocalPortForward(target.id, request);
     } catch (error) {
-      this.mergeStatus(targetId, {
-        state: "error",
-        lastError: this.recordImplicitFailure(targetId, error),
-        lastAttemptedAt: Date.now(),
-      });
+      this.markCallFailure(targetId, error);
       throw error;
     }
   }
@@ -482,11 +470,7 @@ export class RemoteConnectionService {
       this.clearAutomaticReconnectBudget(targetId);
       return result;
     } catch (error) {
-      this.mergeStatus(targetId, {
-        state: "error",
-        lastError: this.recordImplicitFailure(targetId, error),
-        lastAttemptedAt: Date.now(),
-      });
+      this.markCallFailure(targetId, error);
       throw error;
     }
   }
@@ -511,11 +495,7 @@ export class RemoteConnectionService {
       this.clearAutomaticReconnectBudget(targetId);
       return result;
     } catch (error) {
-      this.mergeStatus(targetId, {
-        state: "error",
-        lastError: this.recordImplicitFailure(targetId, error),
-        lastAttemptedAt: Date.now(),
-      });
+      this.markCallFailure(targetId, error);
       throw error;
     }
   }
@@ -544,11 +524,7 @@ export class RemoteConnectionService {
       this.clearAutomaticReconnectBudget(targetId);
       return cleanup;
     } catch (error) {
-      this.mergeStatus(targetId, {
-        state: "error",
-        lastError: this.recordImplicitFailure(targetId, error),
-        lastAttemptedAt: Date.now(),
-      });
+      this.markCallFailure(targetId, error);
       throw error;
     }
   }
@@ -571,11 +547,7 @@ export class RemoteConnectionService {
       this.clearAutomaticReconnectBudget(targetId);
       return registry;
     } catch (error) {
-      this.mergeStatus(targetId, {
-        state: "error",
-        lastError: this.recordImplicitFailure(targetId, error),
-        lastAttemptedAt: Date.now(),
-      });
+      this.markCallFailure(targetId, error);
       throw error;
     }
   }
@@ -602,11 +574,7 @@ export class RemoteConnectionService {
       this.clearAutomaticReconnectBudget(targetId);
       return result;
     } catch (error) {
-      this.mergeStatus(targetId, {
-        state: "error",
-        lastError: this.recordImplicitFailure(targetId, error),
-        lastAttemptedAt: Date.now(),
-      });
+      this.markCallFailure(targetId, error);
       throw error;
     }
   }
@@ -670,11 +638,7 @@ export class RemoteConnectionService {
       this.clearAutomaticReconnectBudget(target.id);
       return result;
     } catch (error) {
-      this.mergeStatus(target.id, {
-        state: "error",
-        lastError: this.recordImplicitFailure(target.id, error),
-        lastAttemptedAt: Date.now(),
-      });
+      this.markCallFailure(target.id, error);
       throw error;
     }
   }
@@ -711,6 +675,25 @@ export class RemoteConnectionService {
     this.automaticReconnectPausedTargetIds.delete(targetId);
   }
 
+  /**
+   * Classify a failure from an RPC call made over an already-established
+   * connection. If the response came back over a live channel, the host is
+   * reachable and the error is application-level (e.g. a host-side SQL or
+   * validation failure). Such errors must NOT flip the connection to
+   * "error"/reconnecting — doing so surfaces a false "host is unreachable"
+   * toast and a reconnect loop for what is really a per-action failure. Only
+   * genuine transport failures update the connection status and reconnect
+   * budget; everything else is left to rethrow to the caller untouched.
+   */
+  private markCallFailure(targetId: string, error: unknown): void {
+    if (!isImplicitConnectionFailure(error)) return;
+    this.mergeStatus(targetId, {
+      state: "error",
+      lastError: this.recordImplicitFailure(targetId, error),
+      lastAttemptedAt: Date.now(),
+    });
+  }
+
   private recordImplicitFailure(targetId: string, error: unknown): string {
     if (!isImplicitConnectionFailure(error)) return errorMessage(error);
     if (isConnectionBackoffThrottle(error)) return errorMessage(error);

apps/desktop/src/main/services/state/crsqliteExtension.ts

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 
 function extensionFileName(): string {
@@ -52,10 +53,14 @@ export function resolveCrsqliteExtensionPath(): string | null {
     const moduleRepoRoot = findRepoRoot(moduleDir);
     if (moduleRepoRoot) repoRootSet.add(moduleRepoRoot);
   }
+  const adeHome = process.env.ADE_HOME ?? path.join(os.homedir(), ".ade");
   const candidates = [
     process.resourcesPath ? path.join(process.resourcesPath, `${packagedAsarName()}.unpacked`, relativePath) : null,
     process.resourcesPath ? path.join(process.resourcesPath, "app.asar.unpacked", relativePath) : null,
     process.resourcesPath ? path.join(process.resourcesPath, relativePath) : null,
+    // Installed static/headless brain: native tarball is extracted to
+    // <ADE_HOME>/runtime/<target>/, carrying crsqlite at vendor/crsqlite/<arch>/.
+    path.join(adeHome, "runtime", platformArchDir(), relativePath),
     path.resolve(process.cwd(), relativePath),
     path.resolve(process.cwd(), "apps", "desktop", relativePath),
     ...Array.from(repoRootSet, (repoRoot) => path.join(repoRoot, "apps", "desktop", relativePath)),