Prepare beta100 exact recovery and truthful health

Cargo.toml

@@ -13,7 +13,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.1.0-beta.99"
+version = "0.1.0-beta.100"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/mdbase-dev/mdbase-connect"

apps/desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mdbase/connect-desktop",
   "productName": "mdbase connect",
-  "version": "0.1.0-beta.99",
+  "version": "0.1.0-beta.100",
   "description": "Connect applications to authorized mdbase collections.",
   "author": "mdbase",
   "private": true,

apps/desktop/scripts/build-main.mjs

@@ -7,6 +7,7 @@ await build({
     "src/main/main.ts",
     "src/main/preload.ts",
     "src/main/agent-startup.ts",
+    "src/main/boot-gate.ts",
     "src/main/daemon-lifecycle.ts",
     "src/main/deep-link.ts",
     "src/main/editor-url.ts",

apps/desktop/src/main/agent-startup.ts

@@ -1,17 +1,32 @@
+import { presentReadiness, type AgentReadiness } from "../shared/readiness";
+export { presentReadiness } from "../shared/readiness";
+
 export interface AgentPing {
   pong: boolean;
   ready?: boolean;
+  readiness?: AgentReadiness;
 }
 
 export interface AgentStartupOptions {
   ping(timeoutMs: number): Promise<AgentPing>;
   launch(): Promise<void>;
   endpointIsUnavailable(error: unknown): boolean;
   incompatibleDaemon(error: unknown): boolean;
+  expectedVersion: string;
   readinessTimeoutMs?: number;
   pollIntervalMs?: number;
 }
 
+class ReadinessError extends Error {}
+
+function isReady(ping: AgentPing, options: AgentStartupOptions): boolean {
+  const health = presentReadiness(ping.readiness, options.expectedVersion);
+  if (!ping.pong || health.state === "attention") throw new ReadinessError(health.label);
+  return health.state === "ready";
+}
+
+const terminal = (error: unknown, options: AgentStartupOptions) =>
+  error instanceof ReadinessError || options.incompatibleDaemon(error);
 const delay = (durationMs: number) =>
   new Promise<void>((resolve) => setTimeout(resolve, durationMs));
 
@@ -20,10 +35,9 @@ export async function waitForAgentReady(options: AgentStartupOptions): Promise<v
   const pollIntervalMs = options.pollIntervalMs ?? 100;
   while (Date.now() < deadline) {
     try {
-      const ping = await options.ping(500);
-      if (ping.ready !== false) return;
+      if (isReady(await options.ping(500), options)) return;
     } catch (error) {
-      if (options.incompatibleDaemon(error)) throw error;
+      if (terminal(error, options)) throw error;
       // The process may still be binding its local endpoint.
     }
     await delay(pollIntervalMs);
@@ -33,29 +47,24 @@ export async function waitForAgentReady(options: AgentStartupOptions): Promise<v
 
 export async function ensureAgentReady(options: AgentStartupOptions): Promise<void> {
   try {
-    const ping = await options.ping(400);
-    if (ping.ready !== false) return;
+    if (isReady(await options.ping(400), options)) return;
     return waitForAgentReady(options);
   } catch (error) {
-    if (options.incompatibleDaemon(error)) throw error;
+    if (terminal(error, options)) throw error;
     if (!options.endpointIsUnavailable(error)) return waitForAgentReady(options);
   }
 
   try {
     await options.launch();
   } catch (launchError) {
     try {
-      const ping = await options.ping(500);
-      if (ping.ready !== false) return;
+      if (isReady(await options.ping(500), options)) return;
     } catch (probeError) {
-      if (options.incompatibleDaemon(probeError)) throw probeError;
+      if (terminal(probeError, options)) throw probeError;
       if (options.endpointIsUnavailable(probeError)) throw launchError;
     }
-    // Starting a persistent service and waiting for its collection scan are
-    // separate operations. The CLI can time out while the service continues
-    // initializing, so keep polling an endpoint that is already available.
+    // A service can still be scanning after the CLI's startup budget expires.
     return waitForAgentReady(options);
   }
-
   await waitForAgentReady(options);
 }

apps/desktop/src/main/boot-gate.ts

@@ -0,0 +1,62 @@
+interface BootGateOptions {
+  initialize(): Promise<void>;
+  start(): Promise<void>;
+  blockedReason(): string | null;
+}
+
+/** One owner for update recovery, startup and daemon-backed IPC admission. */
+export class BootGate {
+  private initialization: Promise<void> | undefined;
+  private startup: Promise<void> | undefined;
+  private installing = false;
+
+  constructor(private readonly options: BootGateOptions) {}
+
+  private initialize(): Promise<void> {
+    // A failed boot stays failed until the application restarts. Ordinary IPC
+    // must not silently bypass a failed persisted update recovery.
+    return this.initialization ??= this.options.initialize();
+  }
+
+  private assertAdmission(): void {
+    const reason = this.installing
+      ? "The application update is in progress."
+      : this.options.blockedReason();
+    if (reason) throw new Error(reason);
+  }
+
+  async ready(): Promise<void> {
+    await this.initialize();
+    this.assertAdmission();
+    this.startup ??= this.options.start().finally(() => { this.startup = undefined; });
+    await this.startup;
+    this.assertAdmission();
+  }
+
+  async request<T>(operation: () => Promise<T>): Promise<T> {
+    await this.ready();
+    this.assertAdmission();
+    return operation();
+  }
+
+  async check<T>(operation: () => Promise<T>): Promise<T> {
+    await this.initialize();
+    this.assertAdmission();
+    return operation();
+  }
+
+  async install<T>(operation: () => Promise<T>): Promise<T> {
+    if (this.installing) throw new Error("The application update is in progress.");
+    this.installing = true;
+    try {
+      await this.initialize();
+      // Never race the CLI startup already admitted before installation began.
+      await this.startup;
+      const reason = this.options.blockedReason();
+      if (reason) throw new Error(reason);
+      return await operation();
+    } finally {
+      this.installing = false;
+    }
+  }
+}

apps/desktop/src/main/control-client.ts

@@ -1,7 +1,7 @@
 import { createConnection } from "node:net";
 import { randomUUID } from "node:crypto";
 
-const LOCAL_CONTROL_PROTOCOL_VERSION = 5;
+export const LOCAL_CONTROL_PROTOCOL_VERSION = 5;
 const MAX_LOCAL_CONTROL_RESPONSE_BYTES = 32 * 1024 * 1024;
 
 export interface ControlResponse<T = unknown> {

apps/desktop/src/main/daemon-lifecycle.ts

@@ -1,3 +1,18 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { promisify } from "node:util";
+
+const execFile = promisify(execFileCallback);
+
+export async function launchDaemon(binary: string, paths: DaemonPaths, packaged: boolean): Promise<void> {
+  if (!existsSync(binary)) throw new Error(`Connector runtime is missing: ${binary}`);
+  await mkdir(paths.stateDir, { recursive: true });
+  await execFile(binary, daemonCliArguments(paths.target, paths.stateDir, paths.endpoint, ["start"]), {
+    env: connectCliEnvironment(packaged), timeout: 30_000, windowsHide: true
+  });
+}
+
 export function connectCliEnvironment(
   packaged: boolean,
   environment: NodeJS.ProcessEnv = process.env
@@ -9,15 +24,27 @@ export function connectCliEnvironment(
   return sanitized;
 }
 
+export type DaemonTarget = "installed_service" | "isolated_profile";
+export interface DaemonPaths { stateDir: string; endpoint: string; target: DaemonTarget }
+
+export function parseDaemonPaths(value: unknown): DaemonPaths {
+  const paths = value as { state_dir?: unknown; endpoint?: unknown; target?: unknown } | null;
+  if (!paths || typeof paths.state_dir !== "string" || typeof paths.endpoint !== "string" ||
+      (paths.target !== "installed_service" && paths.target !== "isolated_profile")) {
+    throw new Error("The connector runtime returned invalid path information.");
+  }
+  return { stateDir: paths.state_dir, endpoint: paths.endpoint, target: paths.target };
+}
+
 export function daemonCliArguments(
-  packaged: boolean,
+  target: DaemonTarget,
   stateDirectory: string,
   endpoint: string,
   command: string[],
   json = false
 ): string[] {
   return [
-    ...(packaged ? [] : ["--state-dir", stateDirectory, "--endpoint", endpoint]),
+    ...(target === "isolated_profile" ? ["--state-dir", stateDirectory, "--endpoint", endpoint] : []),
     ...(json ? ["--json"] : []),
     "connect",
     "daemon",