@hermespilot/link 0.2.0 → 0.2.2

package/dist/{chunk-TMCXOV6J.js → chunk-4YF43CT4.js}

@@ -3587,7 +3587,7 @@ async function listCronOutputFiles(profileName, jobId) {
       mtimeMs: fileStat.mtimeMs
     });
   }
-  return files.sort((left, right) => left.mtimeMs - right.mtimeMs).map(({ path: path22, mtime }) => ({ path: path22, mtime }));
+  return files.sort((left, right) => left.mtimeMs - right.mtimeMs).map(({ path: path23, mtime }) => ({ path: path23, mtime }));
 }
 async function readCronOutput(outputPath) {
   const content = await readFile3(outputPath, "utf8");
@@ -4677,7 +4677,7 @@ import os2 from "os";
 import path7 from "path";
 
 // src/constants.ts
-var LINK_VERSION = "0.2.0";
+var LINK_VERSION = "0.2.2";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -7963,10 +7963,10 @@ async function cancelHermesRun(runId, options = {}) {
     );
   }
 }
-async function callHermesApi(path22, init, options) {
+async function callHermesApi(path23, init, options) {
   const method = init.method ?? "GET";
   const startedAt = Date.now();
-  void options.logger?.debug("hermes_api_request_started", { method, path: path22 });
+  void options.logger?.debug("hermes_api_request_started", { method, path: path23 });
   const availability = await ensureHermesApiServerAvailable({
     fetchImpl: options.fetchImpl,
     logger: options.logger,
@@ -7974,21 +7974,21 @@ async function callHermesApi(path22, init, options) {
   });
   let config = availability.configResult.apiServer;
   const fetcher = options.fetchImpl ?? fetch;
-  const request = () => fetchHermesApi(fetcher, config, path22, init, options);
+  const request = () => fetchHermesApi(fetcher, config, path23, init, options);
   let response;
   try {
     response = await request();
   } catch (error) {
-    logHermesApiError(options.logger, method, path22, startedAt, error);
+    logHermesApiError(options.logger, method, path23, startedAt, error);
     throw error;
   }
   if (response.status !== 401) {
-    logHermesApiResponse(options.logger, method, path22, startedAt, response);
+    logHermesApiResponse(options.logger, method, path23, startedAt, response);
     return response;
   }
   void options.logger?.warn("hermes_api_request_retrying_after_401", {
     method,
-    path: path22,
+    path: path23,
     duration_ms: Date.now() - startedAt
   });
   const refreshedAvailability = await ensureHermesApiServerAvailable({
@@ -8001,20 +8001,20 @@ async function callHermesApi(path22, init, options) {
   try {
     response = await request();
   } catch (error) {
-    logHermesApiError(options.logger, method, path22, startedAt, error);
+    logHermesApiError(options.logger, method, path23, startedAt, error);
     throw error;
   }
-  logHermesApiResponse(options.logger, method, path22, startedAt, response);
+  logHermesApiResponse(options.logger, method, path23, startedAt, response);
   return response;
 }
-async function fetchHermesApi(fetcher, config, path22, init, options) {
+async function fetchHermesApi(fetcher, config, path23, init, options) {
   const headers = new Headers(init.headers);
   headers.set("accept", headers.get("accept") ?? "application/json");
   if (config.key) {
     headers.set("x-api-key", config.key);
     headers.set("authorization", `Bearer ${config.key}`);
   }
-  return await fetcher(`http://127.0.0.1:${config.port}${path22}`, {
+  return await fetcher(`http://127.0.0.1:${config.port}${path23}`, {
     ...init,
     headers
   }).catch((error) => {
@@ -8022,7 +8022,7 @@ async function fetchHermesApi(fetcher, config, path22, init, options) {
       throw error;
     }
     void options.logger?.warn("hermes_api_server_connect_failed", {
-      path: path22,
+      path: path23,
       port: config.port ?? null,
       error: error instanceof Error ? error.message : String(error)
     });
@@ -8033,10 +8033,10 @@ async function fetchHermesApi(fetcher, config, path22, init, options) {
     );
   });
 }
-function logHermesApiResponse(logger, method, path22, startedAt, response) {
+function logHermesApiResponse(logger, method, path23, startedAt, response) {
   const fields = {
     method,
-    path: path22,
+    path: path23,
     status: response.status,
     duration_ms: Date.now() - startedAt
   };
@@ -8056,10 +8056,10 @@ async function logHermesApiFailureResponse(logger, fields, response) {
     ...upstreamError ? { upstream_error: upstreamError } : {}
   });
 }
-function logHermesApiError(logger, method, path22, startedAt, error) {
+function logHermesApiError(logger, method, path23, startedAt, error) {
   void logger?.warn("hermes_api_request_failed", {
     method,
-    path: path22,
+    path: path23,
     duration_ms: Date.now() - startedAt,
     ...error instanceof LinkHttpError ? { status: error.status, code: error.code } : {},
     error: error instanceof Error ? error.message : String(error)
@@ -15882,10 +15882,535 @@ function readString14(payload, key) {
 }
 
 // src/link/updates.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { EventEmitter as EventEmitter4 } from "events";
-import { mkdir as mkdir14, readFile as readFile15, rm as rm8 } from "fs/promises";
+import { mkdir as mkdir16, readFile as readFile16, rm as rm10 } from "fs/promises";
+import path21 from "path";
+
+// src/daemon/process.ts
+import { spawn as spawn4 } from "child_process";
+import { mkdir as mkdir15, readFile as readFile15, rm as rm9 } from "fs/promises";
 import path20 from "path";
+
+// src/daemon/service.ts
+import { createServer } from "http";
+import { mkdir as mkdir14, rm as rm8, writeFile as writeFile7 } from "fs/promises";
+
+// src/relay/control-client.ts
+import WebSocket from "ws";
+function connectRelayControl(options) {
+  const wsUrl = new URL(`${options.relayBaseUrl.replace(/\/+$/u, "")}/api/v1/relay/link/connect`);
+  wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+  wsUrl.searchParams.set("link_id", options.linkId);
+  const maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+  const backoffBaseMs = options.backoffBaseMs ?? 1e3;
+  const backoffMaxMs = options.backoffMaxMs ?? 3e4;
+  let reconnectAttempts = 0;
+  let closedByUser = false;
+  let socket = null;
+  let retryTimer = null;
+  let abortControllers = /* @__PURE__ */ new Map();
+  let fatalRelayRejection = null;
+  const connect = () => {
+    options.onStatus?.({ state: "connecting", attempt: reconnectAttempts });
+    fatalRelayRejection = null;
+    socket = new WebSocket(wsUrl, {
+      headers: {
+        "x-hermes-link-version": LINK_VERSION
+      }
+    });
+    socket.on("open", () => {
+      reconnectAttempts = 0;
+      options.onStatus?.({ state: "connected", attempt: reconnectAttempts });
+    });
+    socket.on("message", (raw) => {
+      if (!socket || typeof raw !== "string" && !Buffer.isBuffer(raw)) {
+        return;
+      }
+      void handleFrame(socket, String(raw), options.localPort, abortControllers).catch((error) => {
+        const message = error instanceof Error ? error.message : "Relay request failed";
+        socket?.send(JSON.stringify({ type: "http.error", id: "unknown", status: 502, message }));
+      });
+    });
+    socket.on("error", (error) => {
+      const message = error instanceof Error ? error.message : "Relay websocket error";
+      fatalRelayRejection = resolveFatalRelayRejection(message);
+      options.onStatus?.({
+        state: "disconnected",
+        attempt: reconnectAttempts,
+        message: fatalRelayRejection ?? message
+      });
+    });
+    socket.on("close", () => {
+      abortAll(abortControllers);
+      abortControllers = /* @__PURE__ */ new Map();
+      if (fatalRelayRejection) {
+        options.onStatus?.({
+          state: "failed",
+          attempt: reconnectAttempts,
+          message: fatalRelayRejection
+        });
+        return;
+      }
+      if (closedByUser) {
+        options.onStatus?.({ state: "disconnected", attempt: reconnectAttempts });
+        return;
+      }
+      if (reconnectAttempts >= maxReconnectAttempts) {
+        options.onStatus?.({ state: "failed", attempt: reconnectAttempts, message: "Relay reconnect attempts exhausted" });
+        return;
+      }
+      reconnectAttempts += 1;
+      const delay2 = computeBackoffMs(reconnectAttempts, backoffBaseMs, backoffMaxMs);
+      options.onStatus?.({ state: "retrying", attempt: reconnectAttempts, message: `Retrying in ${delay2}ms` });
+      retryTimer = setTimeout(connect, delay2);
+      retryTimer.unref?.();
+    });
+  };
+  connect();
+  return {
+    close() {
+      closedByUser = true;
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+      }
+      abortAll(abortControllers);
+      socket?.terminate();
+    }
+  };
+}
+function resolveFatalRelayRejection(message) {
+  if (!/Unexpected server response:\s*(400|401|403|426)\b/u.test(message)) {
+    return null;
+  }
+  return "Relay refused the Hermes Link connection. Check Link version and pairing state before retrying.";
+}
+function abortAll(abortControllers) {
+  for (const controller of abortControllers.values()) {
+    controller.abort();
+  }
+  abortControllers.clear();
+}
+function computeBackoffMs(attempt, baseMs, maxMs) {
+  const exponential = Math.min(maxMs, baseMs * 2 ** Math.max(0, attempt - 1));
+  const jitter = Math.floor(Math.random() * Math.min(1e3, exponential * 0.2));
+  return exponential + jitter;
+}
+async function handleFrame(socket, raw, localPort, abortControllers) {
+  const frame = JSON.parse(raw);
+  if (frame.type === "http.cancel") {
+    abortControllers.get(frame.id)?.abort();
+    abortControllers.delete(frame.id);
+    return;
+  }
+  if (frame.type !== "http.request") {
+    return;
+  }
+  const abortController = new AbortController();
+  abortControllers.set(frame.id, abortController);
+  try {
+    const response = await fetch(`http://127.0.0.1:${localPort}${frame.path}`, {
+      method: frame.method,
+      headers: frame.headers ?? {},
+      body: frame.bodyBase64 ? Buffer.from(frame.bodyBase64, "base64") : void 0,
+      signal: abortController.signal
+    });
+    const headers = Object.fromEntries(response.headers.entries());
+    const contentType = response.headers.get("content-type") ?? "";
+    if (response.body && contentType.includes("text/event-stream")) {
+      socket.send(JSON.stringify({ type: "http.stream.start", id: frame.id, status: response.status, headers }));
+      const reader = response.body.getReader();
+      while (true) {
+        const next = await reader.read();
+        if (next.done) {
+          break;
+        }
+        socket.send(JSON.stringify({ type: "http.stream.chunk", id: frame.id, bodyBase64: Buffer.from(next.value).toString("base64") }));
+      }
+      socket.send(JSON.stringify({ type: "http.stream.end", id: frame.id }));
+      return;
+    }
+    const body = Buffer.from(await response.arrayBuffer()).toString("base64");
+    socket.send(JSON.stringify({ type: "http.response", id: frame.id, status: response.status, headers, bodyBase64: body }));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Relay request failed";
+    socket.send(JSON.stringify({ type: "http.error", id: frame.id, status: 502, message }));
+  } finally {
+    abortControllers.delete(frame.id);
+  }
+}
+
+// src/daemon/scheduler.ts
+function startCronDeliveryScheduler(options) {
+  let running = false;
+  const syncCronDeliveries = async () => {
+    if (running) {
+      return;
+    }
+    running = true;
+    try {
+      await syncHermesLinkCronDeliveries(
+        options.paths,
+        options.conversations,
+        options.logger
+      );
+    } catch (error) {
+      void options.logger.warn("cron_link_delivery_sync_failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      running = false;
+    }
+  };
+  const timer = setInterval(() => {
+    void syncCronDeliveries();
+  }, options.intervalMs ?? 3e4);
+  timer.unref?.();
+  return {
+    close() {
+      clearInterval(timer);
+    }
+  };
+}
+
+// src/daemon/service.ts
+async function startLinkService(options = {}) {
+  const paths = options.paths ?? resolveRuntimePaths();
+  const logger = createFileLogger({ paths });
+  const [identity, config] = await Promise.all([loadIdentity(paths), loadConfig(paths)]);
+  await logger.info("service_starting", {
+    port: config.port,
+    mode: identity?.link_id ? "paired" : "local-only"
+  });
+  const migration = await migrateLinkDatabase(paths);
+  if (migration.appliedVersions.length > 0) {
+    await logger.info("database_migrated", {
+      database_file: migration.databaseFile,
+      applied_versions: migration.appliedVersions,
+      current_version: migration.currentVersion
+    });
+  }
+  const conversations = new ConversationService(paths, logger);
+  await conversations.rebuildStatisticsIndex();
+  const app = await createApp({
+    paths,
+    logger,
+    conversations,
+    onPairingClaimed: options.onPairingClaimed
+  });
+  const server = createServer(app.callback());
+  try {
+    await listenServer(server, config.port);
+  } catch (error) {
+    await logger.error("service_start_failed", {
+      port: config.port,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    await logger.flush();
+    throw error;
+  }
+  server.on("error", (error) => {
+    void logger.error("service_error", { error: error.message });
+  });
+  void logger.info("service_started", {
+    port: config.port,
+    link_id: identity?.link_id ?? null
+  });
+  const scheduler = startCronDeliveryScheduler({
+    paths,
+    conversations,
+    logger
+  });
+  let relay = null;
+  if (identity?.link_id) {
+    relay = connectRelayControl({
+      relayBaseUrl: config.relayBaseUrl,
+      linkId: identity.link_id,
+      localPort: config.port,
+      maxReconnectAttempts: options.relayMaxReconnectAttempts ?? 5,
+      backoffBaseMs: 1e3,
+      backoffMaxMs: 3e4,
+      onStatus: (status) => {
+        void logger.info("relay_status", status);
+      }
+    });
+  } else {
+    void logger.info("relay_skipped", { reason: "link_not_paired" });
+  }
+  if (options.writePidFile) {
+    await writePidFile(paths);
+  }
+  return {
+    async close() {
+      scheduler.close();
+      relay?.close();
+      await closeServer(server);
+      await logger.info("service_stopped");
+      await logger.flush();
+      if (options.writePidFile) {
+        await rm8(pidFilePath(paths), { force: true }).catch(() => void 0);
+      }
+    }
+  };
+}
+function pidFilePath(paths = resolveRuntimePaths()) {
+  return `${paths.runDir}/hermeslink.pid`;
+}
+async function writePidFile(paths) {
+  await mkdir14(paths.runDir, { recursive: true, mode: 448 });
+  await writeFile7(pidFilePath(paths), `${process.pid}
+`, { mode: 384 });
+}
+async function closeServer(server) {
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    let forceCloseTimer;
+    let timeoutTimer;
+    const settle = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(forceCloseTimer);
+      clearTimeout(timeoutTimer);
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    };
+    forceCloseTimer = setTimeout(() => {
+      server.closeIdleConnections?.();
+      server.closeAllConnections?.();
+    }, 250);
+    timeoutTimer = setTimeout(() => {
+      server.closeAllConnections?.();
+      settle();
+    }, 5e3);
+    server.close((error) => {
+      if (error) {
+        settle(error);
+        return;
+      }
+      settle();
+    });
+    server.closeIdleConnections?.();
+  });
+}
+async function listenServer(server, port) {
+  await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      server.off("error", onError);
+      server.off("listening", onListening);
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onListening = () => {
+      cleanup();
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port);
+  });
+}
+
+// src/daemon/process.ts
+async function startDaemonProcess(paths = resolveRuntimePaths()) {
+  const config = await loadConfig(paths);
+  let status = await getDaemonStatus(paths);
+  if (status.running) {
+    const probe = await probeLocalLinkService({ port: config.port, timeoutMs: 500 });
+    if (probe.reachable) {
+      return status;
+    }
+    await stopDaemonProcess(paths);
+    status = await getDaemonStatus(paths);
+    if (status.running) {
+      return status;
+    }
+  }
+  await mkdir15(paths.logsDir, { recursive: true, mode: 448 });
+  await mkdir15(paths.runDir, { recursive: true, mode: 448 });
+  const scriptPath = currentCliScriptPath();
+  const child = spawn4(process.execPath, [scriptPath, "daemon-supervisor"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.unref();
+  for (let index = 0; index < 12; index += 1) {
+    await wait(250);
+    const next = await getDaemonStatus(paths);
+    if (next.running && (await probeLocalLinkService({ port: config.port, timeoutMs: 500 })).reachable) {
+      return next;
+    }
+  }
+  return await getDaemonStatus(paths);
+}
+async function runDaemonSupervisor(paths = resolveRuntimePaths()) {
+  await mkdir15(paths.logsDir, { recursive: true, mode: 448 });
+  const log = createRotatingTextLogWriter({
+    paths,
+    fileName: path20.basename(daemonLogFile(paths))
+  });
+  const scriptPath = currentCliScriptPath();
+  const child = spawn4(process.execPath, [scriptPath, "daemon", "--foreground"], {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env
+  });
+  const write = (chunk) => {
+    void log.write(chunk);
+  };
+  write(`[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor started
+`);
+  child.stdout?.on("data", write);
+  child.stderr?.on("data", write);
+  const forwardStop = () => {
+    if (child.pid && isProcessAlive3(child.pid)) {
+      child.kill("SIGTERM");
+    }
+  };
+  process.once("SIGINT", forwardStop);
+  process.once("SIGTERM", forwardStop);
+  const result = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve({ code, signal }));
+  }).catch((error) => {
+    write(`[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor failed: ${error instanceof Error ? error.message : String(error)}
+`);
+    return { code: 1, signal: null };
+  });
+  process.off("SIGINT", forwardStop);
+  process.off("SIGTERM", forwardStop);
+  write(
+    `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon supervisor stopped code=${result.code ?? "null"} signal=${result.signal ?? "null"}
+`
+  );
+  await log.flush();
+  return result.code ?? (result.signal ? 0 : 1);
+}
+async function probeLocalLinkService(options) {
+  const unreachable = {
+    reachable: false,
+    reusable: false,
+    linkId: null,
+    version: null
+  };
+  let response;
+  try {
+    response = await fetch(`http://127.0.0.1:${options.port}/api/v1/bootstrap`, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(options.timeoutMs ?? 1e3)
+    });
+  } catch {
+    return unreachable;
+  }
+  if (!response.ok) {
+    return unreachable;
+  }
+  const payload = await response.json().catch(() => null);
+  if (!payload || payload.api_version !== 1) {
+    return unreachable;
+  }
+  const linkId = typeof payload.link_id === "string" ? payload.link_id : null;
+  return {
+    reachable: true,
+    reusable: options.linkId ? linkId === options.linkId : true,
+    linkId,
+    version: typeof payload.version === "string" ? payload.version : null
+  };
+}
+async function stopDaemonProcess(paths = resolveRuntimePaths()) {
+  const status = await getDaemonStatus(paths);
+  if (!status.running || !status.pid) {
+    return status;
+  }
+  try {
+    process.kill(status.pid, "SIGTERM");
+  } catch {
+    await rm9(pidFilePath(paths), { force: true }).catch(() => void 0);
+    return await getDaemonStatus(paths);
+  }
+  for (let index = 0; index < 20; index += 1) {
+    await wait(250);
+    if (!isProcessAlive3(status.pid)) {
+      break;
+    }
+  }
+  if (isProcessAlive3(status.pid)) {
+    try {
+      process.kill(status.pid, "SIGKILL");
+    } catch {
+    }
+    for (let index = 0; index < 10; index += 1) {
+      await wait(250);
+      if (!isProcessAlive3(status.pid)) {
+        break;
+      }
+    }
+  }
+  if (!isProcessAlive3(status.pid) || !await pidBackedServiceIsReachable(paths)) {
+    await rm9(pidFilePath(paths), { force: true }).catch(() => void 0);
+  }
+  return await getDaemonStatus(paths);
+}
+async function getDaemonStatus(paths = resolveRuntimePaths()) {
+  const pidFile = pidFilePath(paths);
+  const pid = await readPid(pidFile);
+  if (pid && !isProcessAlive3(pid)) {
+    await rm9(pidFile, { force: true }).catch(() => void 0);
+    return {
+      running: false,
+      pid: null,
+      pidFile,
+      logFile: daemonLogFile(paths)
+    };
+  }
+  return {
+    running: Boolean(pid),
+    pid,
+    pidFile,
+    logFile: daemonLogFile(paths)
+  };
+}
+function daemonLogFile(paths = resolveRuntimePaths()) {
+  return getDaemonLogFile(paths);
+}
+function currentCliScriptPath() {
+  return process.argv[1];
+}
+async function readPid(filePath) {
+  const raw = await readFile15(filePath, "utf8").catch(() => null);
+  if (!raw) {
+    return null;
+  }
+  const pid = Number.parseInt(raw.trim(), 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function isProcessAlive3(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pidBackedServiceIsReachable(paths) {
+  const config = await loadConfig(paths).catch(() => null);
+  if (!config) {
+    return false;
+  }
+  return (await probeLocalLinkService({ port: config.port, timeoutMs: 500 })).reachable;
+}
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/link/updates.ts
 var SERVER_LINK_CURRENT_RELEASE_PATH = "/api/v1/link/releases/current";
 var LINK_NPM_PACKAGE = "@hermespilot/link";
 var UPDATE_LOG_FILE2 = "link-update.log";
@@ -15893,6 +16418,7 @@ var UPDATE_LOG_MAX_FILES2 = 3;
 var UPDATE_FETCH_TIMEOUT_MS = 5e3;
 var MAX_UPDATE_LOG_LINES2 = 240;
 var MAX_OUTPUT_LINE_LENGTH3 = 1200;
+var AUTO_RESTART_DELAY_MS = 1500;
 var updateEvents2 = new EventEmitter4();
 var runningUpdate2 = null;
 async function readLinkUpdateCheck(options) {
@@ -15970,7 +16496,7 @@ async function startLinkUpdate(options) {
     error: null,
     manual_command: manualCommand
   };
-  await mkdir14(options.paths.runDir, { recursive: true, mode: 448 });
+  await mkdir16(options.paths.runDir, { recursive: true, mode: 448 });
   await writer.write(
     `
 === link update started ${startedAt} target=${targetVersion} ===
@@ -15979,7 +16505,7 @@ async function startLinkUpdate(options) {
   await writer.write(`$ ${manualCommand}
 `);
   await writeUpdateState2(options.paths, started);
-  const child = spawn4(
+  const child = spawn5(
     resolveNpmBin(),
     ["install", "-g", `${LINK_NPM_PACKAGE}@${targetVersion}`],
     {
@@ -16044,12 +16570,16 @@ async function startLinkUpdate(options) {
         if (succeeded) {
           await writer.write(
             `
-[restart-required] Run \`${LINK_COMMAND} restart\` on this computer if Link does not reconnect automatically.
+[restart-scheduled] Hermes Link will restart automatically. If it does not reconnect, run \`${LINK_COMMAND} restart\` on this computer.
 `
           );
         }
         await writeUpdateState2(options.paths, state);
         await emitUpdateStatus2(options.paths);
+        if (succeeded) {
+          await writer.flush();
+          scheduleAutomaticRestart(options);
+        }
         void options.logger?.info(
           succeeded ? "link_update_restart_required" : "link_update_failed",
           {
@@ -16074,6 +16604,22 @@ async function startLinkUpdate(options) {
   });
   return readLinkUpdateStatus(options.paths);
 }
+function scheduleAutomaticRestart(options) {
+  const scriptPath = currentCliScriptPath();
+  setTimeout(() => {
+    const child = spawn5(process.execPath, [scriptPath, "restart"], {
+      detached: true,
+      stdio: "ignore",
+      env: process.env,
+      windowsHide: true
+    });
+    child.unref();
+    void options.logger?.info("link_update_restart_scheduled", {
+      delay_ms: AUTO_RESTART_DELAY_MS,
+      command: `${LINK_COMMAND} restart`
+    });
+  }, AUTO_RESTART_DELAY_MS).unref();
+}
 async function readLinkUpdateStatus(paths) {
   let state = await readJsonFile(updateStatePath2(paths));
   if (state?.state === "restart_required" && state.target_version) {
@@ -16086,7 +16632,7 @@ async function readLinkUpdateStatus(paths) {
       await writeUpdateState2(paths, state);
     }
   }
-  if (state?.state === "running" && !runningUpdate2 && !isRecentRunningState3(state) && !isProcessAlive3(state.pid)) {
+  if (state?.state === "running" && !runningUpdate2 && !isRecentRunningState3(state) && !isProcessAlive4(state.pid)) {
     state = {
       ...state,
       state: "failed",
@@ -16239,7 +16785,7 @@ async function writeUpdateState2(paths, state) {
   await writeJsonFile(updateStatePath2(paths), state);
 }
 async function readUpdateLogLines2(paths) {
-  const raw = await readFile15(updateLogPath2(paths), "utf8").catch(() => "");
+  const raw = await readFile16(updateLogPath2(paths), "utf8").catch(() => "");
   if (!raw.trim()) {
     return [];
   }
@@ -16248,18 +16794,18 @@ async function readUpdateLogLines2(paths) {
   );
 }
 function updateStatePath2(paths) {
-  return path20.join(paths.runDir, "link-update-state.json");
+  return path21.join(paths.runDir, "link-update-state.json");
 }
 function updateLogPath2(paths) {
-  return path20.join(paths.logsDir, UPDATE_LOG_FILE2);
+  return path21.join(paths.logsDir, UPDATE_LOG_FILE2);
 }
 async function clearUpdateLogFiles2(paths) {
   const primary = updateLogPath2(paths);
   await Promise.all([
-    rm8(primary, { force: true }).catch(() => void 0),
+    rm10(primary, { force: true }).catch(() => void 0),
     ...Array.from(
       { length: UPDATE_LOG_MAX_FILES2 },
-      (_, index) => rm8(`${primary}.${index + 1}`, { force: true }).catch(() => void 0)
+      (_, index) => rm10(`${primary}.${index + 1}`, { force: true }).catch(() => void 0)
     )
   ]);
 }
@@ -16292,7 +16838,7 @@ function isRecentRunningState3(state, now = Date.now()) {
   const startedAt = state.started_at ? Date.parse(state.started_at) : Number.NaN;
   return Number.isFinite(startedAt) && now - startedAt < 1e4;
 }
-function isProcessAlive3(pid) {
+function isProcessAlive4(pid) {
   if (!pid || pid <= 0) {
     return false;
   }
@@ -16315,8 +16861,8 @@ function readString15(payload, key) {
 }
 
 // src/pairing/pairing.ts
-import path21 from "path";
-import { rm as rm9 } from "fs/promises";
+import path22 from "path";
+import { rm as rm11 } from "fs/promises";
 
 // src/relay/bootstrap.ts
 async function bootstrapRelayLink(options) {
@@ -16632,7 +17178,7 @@ async function readPairingClaim(sessionId, paths = resolveRuntimePaths()) {
   };
 }
 async function clearPairingClaim(sessionId, paths = resolveRuntimePaths()) {
-  await rm9(pairingClaimPath(sessionId, paths), { force: true }).catch(() => void 0);
+  await rm11(pairingClaimPath(sessionId, paths), { force: true }).catch(() => void 0);
 }
 async function claimPairing(input) {
   const paths = input.paths ?? resolveRuntimePaths();
@@ -16680,8 +17226,8 @@ async function loadRequiredIdentity2(paths) {
   }
   return identity;
 }
-async function postServerJson(serverBaseUrl, path22, body) {
-  const response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path22}`, {
+async function postServerJson(serverBaseUrl, path23, body) {
+  const response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path23}`, {
     method: "POST",
     headers: {
       accept: "application/json",
@@ -16691,8 +17237,8 @@ async function postServerJson(serverBaseUrl, path22, body) {
   });
   return readJsonResponse2(response);
 }
-async function patchServerJson(serverBaseUrl, path22, token, body) {
-  const response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path22}`, {
+async function patchServerJson(serverBaseUrl, path23, token, body) {
+  const response = await fetch(`${serverBaseUrl.replace(/\/+$/u, "")}${path23}`, {
     method: "PATCH",
     headers: {
       accept: "application/json",
@@ -16726,7 +17272,7 @@ function defaultDisplayName() {
   return `Hermes Link ${process.platform}`;
 }
 function pairingClaimPath(sessionId, paths) {
-  return path21.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.claimed.json`);
+  return path22.join(paths.pairingDir, `${Buffer.from(sessionId).toString("base64url")}.claimed.json`);
 }
 function qrPreferredUrls(routes) {
   return routes.preferredUrls.filter((url) => !url.includes("/api/v1/relay/links/")).slice(0, 1);
@@ -17392,20 +17938,14 @@ async function createApp(options = {}) {
 export {
   LINK_VERSION,
   LINK_COMMAND,
-  migrateLinkDatabase,
   resolveHermesProfileDir,
   resolveHermesConfigPath,
   readHermesApiServerConfig,
   ensureHermesApiServerConfig,
-  syncHermesLinkCronDeliveries,
   LinkHttpError,
   resolveRuntimePaths,
-  createFileLogger,
   getLinkLogFile,
-  getDaemonLogFile,
-  createRotatingTextLogWriter,
   ensureHermesApiServerAvailable,
-  ConversationService,
   loadConfig,
   loadIdentity,
   ensureIdentity,
@@ -17414,6 +17954,14 @@ export {
   preparePairing,
   readPairingClaim,
   clearPairingClaim,
-  createApp
+  createApp,
+  startLinkService,
+  startDaemonProcess,
+  runDaemonSupervisor,
+  probeLocalLinkService,
+  stopDaemonProcess,
+  getDaemonStatus,
+  daemonLogFile,
+  currentCliScriptPath
 };
-//# sourceMappingURL=chunk-TMCXOV6J.js.map
+//# sourceMappingURL=chunk-4YF43CT4.js.map