@hermespilot/link 0.4.7 → 0.4.8

package/dist/{chunk-PRYXZRQI.js → chunk-B42L327D.js}

@@ -4117,7 +4117,8 @@ function isConversationMissingError(error) {
 
 // src/hermes/gateway.ts
 import { execFile as execFile2, spawn } from "child_process";
-import { access, readFile as readFile5, stat as stat4 } from "fs/promises";
+import { constants as fsConstants } from "fs";
+import { access, readFile as readFile5, realpath, stat as stat4 } from "fs/promises";
 import path7 from "path";
 import { setTimeout as delay } from "timers/promises";
 import { promisify as promisify2 } from "util";
@@ -4132,7 +4133,7 @@ import os2 from "os";
 import path5 from "path";
 
 // src/constants.ts
-var LINK_VERSION = "0.4.7";
+var LINK_VERSION = "0.4.8";
 var LINK_COMMAND = "hermeslink";
 var LINK_DEFAULT_PORT = 52379;
 var LINK_RUNTIME_DIR_NAME = ".hermeslink";
@@ -4631,6 +4632,8 @@ var PROFILE_NAME_PATTERN = /^[a-zA-Z0-9._-]{1,64}$/u;
 var DASHBOARD_STATUS_URL = "http://127.0.0.1:9119/api/status";
 var DASHBOARD_STATUS_TIMEOUT_MS = 1500;
 var DEFAULT_VERSION_CACHE_TTL_MS = 6e4;
+var VERSION_METADATA_TIMEOUT_MS = 3e3;
+var VERSION_COMMAND_TIMEOUT_MS = 5e3;
 var MAX_VERSION_LOG_OUTPUT_LENGTH = 1200;
 var HERMES_GATEWAY_ENV_BLOCKLIST_PREFIXES = ["API_SERVER_"];
 var gatewayStartInFlightByProfile = /* @__PURE__ */ new Map();
@@ -4826,9 +4829,26 @@ async function readHermesVersion(options = {}) {
 }
 async function execHermesVersion(hermesBin, logger) {
   const failures = [];
+  try {
+    const metadataVersion = await readHermesPythonMetadataVersion(
+      hermesBin,
+      VERSION_METADATA_TIMEOUT_MS
+    );
+    if (metadataVersion) {
+      return metadataVersion;
+    }
+  } catch (error) {
+    const failure = describeVersionMetadataFailure(hermesBin, error);
+    failures.push(failure);
+    void logger?.debug("hermes_version_metadata_probe_failed", failure.fields);
+  }
   for (const args of [["--version"], ["version"]]) {
     try {
-      return await spawnHermesVersionCommand(hermesBin, args, 5e3);
+      return await spawnHermesVersionCommand(
+        hermesBin,
+        args,
+        VERSION_COMMAND_TIMEOUT_MS
+      );
     } catch (error) {
       const failure = describeVersionCommandFailure(hermesBin, args, error);
       failures.push(failure);
@@ -4844,6 +4864,109 @@ async function execHermesVersion(hermesBin, logger) {
   });
   throw new Error(summary);
 }
+async function readHermesPythonMetadataVersion(hermesBin, timeoutMs) {
+  const hermesPath = await resolveExecutablePath(hermesBin);
+  if (!hermesPath) {
+    return null;
+  }
+  const firstLine = await readFirstLine(hermesPath);
+  const interpreter = parsePythonShebang(firstLine);
+  if (!interpreter) {
+    return null;
+  }
+  return await spawnHermesMetadataCommand(interpreter, timeoutMs);
+}
+async function spawnHermesMetadataCommand(interpreter, timeoutMs) {
+  const script = [
+    "import importlib.metadata as metadata",
+    "try:",
+    '    version = metadata.version("hermes-agent")',
+    '    release_date = ""',
+    "except Exception:",
+    "    import hermes_cli",
+    '    version = getattr(hermes_cli, "__version__", "")',
+    '    release_date = getattr(hermes_cli, "__release_date__", "")',
+    "if not version:",
+    '    raise SystemExit("Hermes Agent version metadata not found")',
+    'suffix = f" ({release_date})" if release_date else ""',
+    'print(f"Hermes Agent v{version}{suffix}")',
+    ""
+  ].join("\n");
+  return await new Promise((resolve, reject) => {
+    const child = spawn(
+      interpreter.command,
+      [...interpreter.args, "-c", script],
+      {
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        env: { ...process.env, HERMES_NONINTERACTIVE: "1" }
+      }
+    );
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      finish(() => {
+        reject(
+          createVersionCommandError(
+            `Hermes Python metadata probe timed out after ${timeoutMs}ms`,
+            { stdout, stderr, killed: true }
+          )
+        );
+      }, true);
+    }, timeoutMs);
+    const finish = (callback, kill = false) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      if (kill && child.pid && !child.killed) {
+        child.kill();
+      }
+      callback();
+    };
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.once("error", (error) => {
+      finish(() => {
+        reject(
+          createVersionCommandError(error.message, {
+            stdout,
+            stderr,
+            cause: error
+          })
+        );
+      });
+    });
+    child.once("close", (code, signal) => {
+      finish(() => {
+        const raw = `${stdout}
+${stderr}`.trim();
+        if (code === 0 && parseHermesVersion(raw)) {
+          resolve({ stdout: raw });
+          return;
+        }
+        reject(
+          createVersionCommandError(
+            `Hermes Python metadata probe exited with code ${code ?? "null"}`,
+            {
+              stdout,
+              stderr,
+              code,
+              signal,
+              killed: child.killed
+            }
+          )
+        );
+      });
+    });
+  });
+}
 async function spawnHermesVersionCommand(hermesBin, args, timeoutMs) {
   return await new Promise((resolve, reject) => {
     const child = spawn(hermesBin, args, {
@@ -5424,6 +5547,20 @@ function createVersionCommandError(message, details) {
   }
   return error;
 }
+function describeVersionMetadataFailure(hermesBin, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const details = readExecErrorDetails(error, message);
+  return {
+    summary: `${hermesBin} Python metadata probe failed: ${message}`,
+    fields: {
+      hermes_bin: hermesBin,
+      command: "python-metadata",
+      cwd: process.cwd(),
+      error: message,
+      ...details
+    }
+  };
+}
 function describeVersionCommandFailure(hermesBin, args, error) {
   const message = error instanceof Error ? error.message : String(error);
   const details = readExecErrorDetails(error, message);
@@ -5473,6 +5610,91 @@ function readExecErrorDetails(error, message) {
 function truncateVersionLogOutput(value) {
   return value.length > MAX_VERSION_LOG_OUTPUT_LENGTH ? `${value.slice(0, MAX_VERSION_LOG_OUTPUT_LENGTH)}...` : value;
 }
+async function resolveExecutablePath(command) {
+  const candidates = executablePathCandidates(command);
+  for (const candidate of candidates) {
+    try {
+      await access(candidate, fsConstants.X_OK);
+      return await realpath(candidate).catch(() => candidate);
+    } catch {
+    }
+  }
+  return null;
+}
+function executablePathCandidates(command) {
+  const normalized = command.trim();
+  if (!normalized) {
+    return [];
+  }
+  if (/[\\/]/u.test(normalized)) {
+    return withWindowsExecutableExtensions(normalized);
+  }
+  const pathEntries = (process.env.PATH ?? "").split(path7.delimiter).filter(Boolean);
+  return pathEntries.flatMap(
+    (entry) => withWindowsExecutableExtensions(path7.join(entry, normalized))
+  );
+}
+function withWindowsExecutableExtensions(filePath) {
+  if (process.platform !== "win32" || path7.extname(filePath)) {
+    return [filePath];
+  }
+  const extensions = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean);
+  return [filePath, ...extensions.map((extension) => `${filePath}${extension}`)];
+}
+async function readFirstLine(filePath) {
+  const raw = await readFile5(filePath, "utf8");
+  return raw.split(/\r?\n/u, 1)[0] ?? "";
+}
+function parsePythonShebang(line) {
+  if (!line.startsWith("#!")) {
+    return null;
+  }
+  const parts = splitShellWords(line.slice(2).trim());
+  if (parts.length === 0) {
+    return null;
+  }
+  const commandName = path7.basename(parts[0] ?? "").toLowerCase();
+  if (commandName === "env") {
+    const args = expandEnvShebangArgs(parts.slice(1));
+    const pythonIndex = args.findIndex((part) => isPythonCommandName(part));
+    if (pythonIndex < 0) {
+      return null;
+    }
+    return {
+      command: parts[0],
+      args
+    };
+  }
+  if (!isPythonCommandName(commandName)) {
+    return null;
+  }
+  return {
+    command: parts[0],
+    args: parts.slice(1)
+  };
+}
+function isPythonCommandName(command) {
+  return /^python(?:\d+(?:\.\d+)?)?$/iu.test(path7.basename(command));
+}
+function expandEnvShebangArgs(args) {
+  const expanded = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "-S" && args[index + 1]) {
+      expanded.push(...splitShellWords(args[index + 1]));
+      index += 1;
+      continue;
+    }
+    if (arg !== "-S") {
+      expanded.push(arg);
+    }
+  }
+  return expanded;
+}
+function splitShellWords(value) {
+  const matches = value.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/gu);
+  return [...matches].map((match) => match[1] ?? match[2] ?? match[3] ?? "");
+}
 function compareSemver(left, right) {
   const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
   const rightParts = right.split(".").map((part) => Number.parseInt(part, 10));
@@ -12677,7 +12899,7 @@ async function resolveHermesPythonCommand() {
   if (explicit) {
     return { command: explicit, args: [] };
   }
-  const hermesBin = await resolveExecutablePath(resolveHermesBin());
+  const hermesBin = await resolveExecutablePath2(resolveHermesBin());
   if (hermesBin) {
     const shebang = await readShebang(hermesBin);
     const command = shebangToPythonCommand(shebang);
@@ -12690,7 +12912,7 @@ async function resolveHermesPythonCommand() {
     args: []
   };
 }
-async function resolveExecutablePath(command) {
+async function resolveExecutablePath2(command) {
   if (path17.isAbsolute(command)) {
     return await isExecutableFile(command) ? command : null;
   }

package/dist/cli/index.js

@@ -36,7 +36,7 @@ import {
   startDaemonProcess,
   startLinkService,
   stopDaemonProcess
-} from "../chunk-PRYXZRQI.js";
+} from "../chunk-B42L327D.js";
 
 // src/cli/index.ts
 import { Command } from "commander";

package/dist/http/app.js

@@ -1,6 +1,6 @@
 import {
   createApp
-} from "../chunk-PRYXZRQI.js";
+} from "../chunk-B42L327D.js";
 export {
   createApp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hermespilot/link",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "private": false,
   "description": "Hermes Link companion service and CLI for connecting hermes-agent through HermesPilot",
   "license": "MIT",