@hermespilot/link 0.2.0 → 0.2.1

package/dist/cli/index.js

@@ -1,31 +1,32 @@
 #!/usr/bin/env node
 import {
-  ConversationService,
   LINK_COMMAND,
   LINK_VERSION,
   LinkHttpError,
   clearPairingClaim,
-  createApp,
-  createFileLogger,
-  createRotatingTextLogWriter,
+  currentCliScriptPath,
+  daemonLogFile,
   ensureHermesApiServerAvailable,
   ensureHermesApiServerConfig,
   ensureIdentity,
-  getDaemonLogFile,
+  getDaemonStatus,
   getIdentityStatus,
   getLinkLogFile,
   hasActiveDevices,
   loadConfig,
   loadIdentity,
-  migrateLinkDatabase,
   preparePairing,
+  probeLocalLinkService,
   readHermesApiServerConfig,
   readPairingClaim,
   resolveHermesConfigPath,
   resolveHermesProfileDir,
   resolveRuntimePaths,
-  syncHermesLinkCronDeliveries
-} from "../chunk-TMCXOV6J.js";
+  runDaemonSupervisor,
+  startDaemonProcess,
+  startLinkService,
+  stopDaemonProcess
+} from "../chunk-YQX7OQFH.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -33,535 +34,10 @@ import qrcode from "qrcode-terminal";
 
 // src/autostart/autostart.ts
 import { execFile } from "child_process";
-import { mkdir as mkdir3, readFile as readFile2, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
 import os from "os";
-import path2 from "path";
-import { promisify } from "util";
-
-// src/daemon/process.ts
-import { spawn } from "child_process";
-import { mkdir as mkdir2, readFile, rm as rm2 } from "fs/promises";
 import path from "path";
-
-// src/daemon/service.ts
-import { createServer } from "http";
-import { mkdir, rm, writeFile } 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 delay = computeBackoffMs(reconnectAttempts, backoffBaseMs, backoffMaxMs);
-      options.onStatus?.({ state: "retrying", attempt: reconnectAttempts, message: `Retrying in ${delay}ms` });
-      retryTimer = setTimeout(connect, delay);
-      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 rm(pidFilePath(paths), { force: true }).catch(() => void 0);
-      }
-    }
-  };
-}
-function pidFilePath(paths = resolveRuntimePaths()) {
-  return `${paths.runDir}/hermeslink.pid`;
-}
-async function writePidFile(paths) {
-  await mkdir(paths.runDir, { recursive: true, mode: 448 });
-  await writeFile(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 mkdir2(paths.logsDir, { recursive: true, mode: 448 });
-  await mkdir2(paths.runDir, { recursive: true, mode: 448 });
-  const scriptPath = currentCliScriptPath();
-  const child = spawn(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 mkdir2(paths.logsDir, { recursive: true, mode: 448 });
-  const log = createRotatingTextLogWriter({
-    paths,
-    fileName: path.basename(daemonLogFile(paths))
-  });
-  const scriptPath = currentCliScriptPath();
-  const child = spawn(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 && isProcessAlive(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 rm2(pidFilePath(paths), { force: true }).catch(() => void 0);
-    return await getDaemonStatus(paths);
-  }
-  for (let index = 0; index < 20; index += 1) {
-    await wait(250);
-    if (!isProcessAlive(status.pid)) {
-      break;
-    }
-  }
-  if (isProcessAlive(status.pid)) {
-    try {
-      process.kill(status.pid, "SIGKILL");
-    } catch {
-    }
-    for (let index = 0; index < 10; index += 1) {
-      await wait(250);
-      if (!isProcessAlive(status.pid)) {
-        break;
-      }
-    }
-  }
-  if (!isProcessAlive(status.pid) || !await pidBackedServiceIsReachable(paths)) {
-    await rm2(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 && !isProcessAlive(pid)) {
-    await rm2(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 readFile(filePath, "utf8").catch(() => null);
-  if (!raw) {
-    return null;
-  }
-  const pid = Number.parseInt(raw.trim(), 10);
-  return Number.isInteger(pid) && pid > 0 ? pid : null;
-}
-function isProcessAlive(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/autostart/autostart.ts
+import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var MACOS_LABEL = "com.hermespilot.link";
 async function enableAutostart() {
@@ -569,14 +45,14 @@ async function enableAutostart() {
   if (!definition) {
     return unsupportedStatus();
   }
-  await mkdir3(path2.dirname(definition.filePath), { recursive: true, mode: 448 });
-  await writeFile2(definition.filePath, definition.content, { mode: 384 });
+  await mkdir(path.dirname(definition.filePath), { recursive: true, mode: 448 });
+  await writeFile(definition.filePath, definition.content, { mode: 384 });
   if (definition.method === "systemd-user") {
-    await execFileAsync("systemctl", ["--user", "enable", path2.basename(definition.filePath)]).catch(async () => {
-      await rm3(definition.filePath, { force: true }).catch(() => void 0);
+    await execFileAsync("systemctl", ["--user", "enable", path.basename(definition.filePath)]).catch(async () => {
+      await rm(definition.filePath, { force: true }).catch(() => void 0);
       const fallback = xdgAutostartDefinition();
-      await mkdir3(path2.dirname(fallback.filePath), { recursive: true, mode: 448 });
-      await writeFile2(fallback.filePath, fallback.content, { mode: 384 });
+      await mkdir(path.dirname(fallback.filePath), { recursive: true, mode: 448 });
+      await writeFile(fallback.filePath, fallback.content, { mode: 384 });
     });
   }
   return await getAutostartStatus();
@@ -585,9 +61,9 @@ async function disableAutostart() {
   const definitions = await allAutostartDefinitions();
   for (const definition of definitions) {
     if (definition.method === "systemd-user") {
-      await execFileAsync("systemctl", ["--user", "disable", path2.basename(definition.filePath)]).catch(() => void 0);
+      await execFileAsync("systemctl", ["--user", "disable", path.basename(definition.filePath)]).catch(() => void 0);
     }
-    await rm3(definition.filePath, { force: true }).catch(() => void 0);
+    await rm(definition.filePath, { force: true }).catch(() => void 0);
   }
   return await getAutostartStatus();
 }
@@ -597,7 +73,7 @@ async function getAutostartStatus() {
     return unsupportedStatus();
   }
   for (const definition of definitions) {
-    const content = await readFile2(definition.filePath, "utf8").catch(() => null);
+    const content = await readFile(definition.filePath, "utf8").catch(() => null);
     if (content !== null) {
       return {
         supported: true,
@@ -648,7 +124,7 @@ async function hasSystemctlUser() {
   }
 }
 function launchdDefinition() {
-  const filePath = path2.join(os.homedir(), "Library", "LaunchAgents", `${MACOS_LABEL}.plist`);
+  const filePath = path.join(os.homedir(), "Library", "LaunchAgents", `${MACOS_LABEL}.plist`);
   return {
     method: "launchd",
     filePath,
@@ -674,7 +150,7 @@ function launchdDefinition() {
   };
 }
 function systemdUserDefinition() {
-  const filePath = path2.join(os.homedir(), ".config", "systemd", "user", "hermeslink.service");
+  const filePath = path.join(os.homedir(), ".config", "systemd", "user", "hermeslink.service");
   return {
     method: "systemd-user",
     filePath,
@@ -693,7 +169,7 @@ WantedBy=default.target
   };
 }
 function xdgAutostartDefinition() {
-  const filePath = path2.join(os.homedir(), ".config", "autostart", "hermeslink.desktop");
+  const filePath = path.join(os.homedir(), ".config", "autostart", "hermeslink.desktop");
   return {
     method: "xdg-autostart",
     filePath,
@@ -707,8 +183,8 @@ X-GNOME-Autostart-enabled=true
   };
 }
 function windowsStartupDefinition() {
-  const appData = process.env.APPDATA ?? path2.join(os.homedir(), "AppData", "Roaming");
-  const filePath = path2.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "HermesLink.cmd");
+  const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+  const filePath = path.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "HermesLink.cmd");
   return {
     method: "windows-startup",
     filePath,
@@ -955,12 +431,12 @@ function parseLanguage(value) {
 
 // src/pairing/preflight.ts
 import { access, stat } from "fs/promises";
-import path3 from "path";
+import path2 from "path";
 async function assertPairingPreflightReady(options = {}) {
   const profileName = normalizeProfileName(options.profileName);
   const hermesHome = resolveHermesProfileDir(profileName);
   const configPath = resolveHermesConfigPath(profileName);
-  const envPath = path3.join(hermesHome, ".env");
+  const envPath = path2.join(hermesHome, ".env");
   const failures = [];
   if (!await isDirectory(hermesHome)) {
     failures.push({