@saleso.innovations/bridge 0.1.16 → 0.1.17

package/dist/runtimeVersion.js

@@ -0,0 +1,105 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const VERSION_TIMEOUT_MS = 10_000;
+const UPDATE_CHECK_TIMEOUT_MS = 30_000;
+const SEMVER_PATTERN = /\b(\d+\.\d+\.\d+(?:[-+][\w.-]+)?)\b/;
+const COMMIT_PATTERN = /\b([0-9a-f]{7,40})\b/i;
+function combineOutput(stdout, stderr) {
+    return [stdout, stderr].filter((chunk) => chunk.trim().length > 0).join("\n").trim();
+}
+function parseSemver(text) {
+    const match = text.match(SEMVER_PATTERN);
+    return match?.[1] ?? null;
+}
+function parseLatestFromCheckOutput(output, installed) {
+    const lines = output.split("\n").map((line) => line.trim()).filter(Boolean);
+    const tokens = lines.flatMap((line) => {
+        const semverMatches = [...line.matchAll(new RegExp(SEMVER_PATTERN.source, "g"))].map((match) => match[1]);
+        const commitMatches = [...line.matchAll(new RegExp(COMMIT_PATTERN.source, "gi"))].map((match) => match[1]);
+        return [...semverMatches, ...commitMatches];
+    });
+    if (tokens.length === 0) {
+        return null;
+    }
+    if (installed) {
+        const different = tokens.find((token) => token !== installed);
+        if (different) {
+            return different;
+        }
+    }
+    return tokens[tokens.length - 1] ?? null;
+}
+export async function runHermesVersion() {
+    try {
+        const { stdout, stderr } = await execFileAsync("hermes", ["--version"], {
+            timeout: VERSION_TIMEOUT_MS,
+            env: process.env,
+        });
+        return parseSemver(combineOutput(stdout, stderr));
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "stdout" in error && "stderr" in error) {
+            const stdout = String(error.stdout ?? "");
+            const stderr = String(error.stderr ?? "");
+            const parsed = parseSemver(combineOutput(stdout, stderr));
+            if (parsed) {
+                return parsed;
+            }
+        }
+        return null;
+    }
+}
+export async function checkHermesUpdate(installed) {
+    try {
+        const { stdout, stderr } = await execFileAsync("hermes", ["update", "--check"], {
+            timeout: UPDATE_CHECK_TIMEOUT_MS,
+            env: process.env,
+        });
+        const output = combineOutput(stdout, stderr);
+        const latest = parseLatestFromCheckOutput(output, installed);
+        return {
+            latest: latest ?? installed,
+            updateAvailable: false,
+        };
+    }
+    catch (error) {
+        const execError = error;
+        const output = combineOutput(String(execError.stdout ?? ""), String(execError.stderr ?? ""));
+        const exitCode = typeof execError.code === "number" ? execError.code : null;
+        if (exitCode === 1) {
+            const latest = parseLatestFromCheckOutput(output, installed);
+            return {
+                latest,
+                updateAvailable: true,
+            };
+        }
+        if (output.trim().length > 0) {
+            const latest = parseLatestFromCheckOutput(output, installed);
+            if (latest) {
+                return {
+                    latest,
+                    updateAvailable: installed ? latest !== installed : null,
+                };
+            }
+        }
+        const message = execError instanceof Error && execError.message.trim().length > 0
+            ? execError.message.trim()
+            : "Hermes update check failed.";
+        return {
+            latest: null,
+            updateAvailable: null,
+            checkError: message,
+        };
+    }
+}
+export async function fetchHermesRuntimeVersion() {
+    const installed = await runHermesVersion();
+    const check = await checkHermesUpdate(installed);
+    return {
+        installed,
+        latest: check.latest,
+        updateAvailable: check.updateAvailable,
+        ...(check.checkError ? { checkError: check.checkError } : {}),
+    };
+}

package/dist/skillsList.d.ts

@@ -0,0 +1,9 @@
+export type HermesSkillEntry = {
+    name: string;
+    description: string;
+    category?: string;
+};
+export declare function listHermesSkills(): Promise<{
+    skills: HermesSkillEntry[];
+}>;
+//# sourceMappingURL=skillsList.d.ts.map

package/dist/skillsList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillsList.d.ts","sourceRoot":"","sources":["../src/skillsList.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AA4LF,wBAAsB,gBAAgB,IAAI,OAAO,CAAC;IAAE,MAAM,EAAE,gBAAgB,EAAE,CAAA;CAAE,CAAC,CAOhF"}

package/dist/skillsList.js

@@ -0,0 +1,187 @@
+import { execFile } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, relative } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const HERMES_SKILLS_DIR = join(homedir(), ".hermes", "skills");
+const LIST_TIMEOUT_MS = 30_000;
+const MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
+const SKILL_FILE_NAME = "SKILL.md";
+const HIDDEN_DIR_NAMES = new Set([".hub", ".git"]);
+function normalizeSkillsPayload(value) {
+    if (Array.isArray(value)) {
+        return { skills: value.flatMap((item) => parseSkillRecord(item)) };
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        for (const key of ["skills", "items", "data", "results"]) {
+            if (Array.isArray(record[key])) {
+                return { skills: record[key].flatMap((item) => parseSkillRecord(item)) };
+            }
+        }
+    }
+    return { skills: [] };
+}
+function parseSkillRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return [];
+    }
+    const record = value;
+    const name = pickString(record, ["name", "id", "skill", "skill_name"]);
+    if (!name) {
+        return [];
+    }
+    const description = pickString(record, ["description", "desc", "summary"]) ?? "";
+    const category = pickString(record, ["category", "path", "group"]);
+    const entry = { name, description };
+    if (category) {
+        entry.category = category;
+    }
+    return [entry];
+}
+function pickString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string") {
+            const trimmed = value.trim();
+            if (trimmed.length > 0) {
+                return trimmed;
+            }
+        }
+    }
+    return undefined;
+}
+function parseFrontmatter(raw) {
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) {
+        return {};
+    }
+    const frontmatter = {};
+    const body = match[1];
+    if (!body) {
+        return {};
+    }
+    for (const line of body.split(/\r?\n/)) {
+        const separator = line.indexOf(":");
+        if (separator <= 0) {
+            continue;
+        }
+        const key = line.slice(0, separator).trim();
+        let value = line.slice(separator + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (key.length > 0) {
+            frontmatter[key] = value;
+        }
+    }
+    return frontmatter;
+}
+function deriveCategory(skillsRoot, skillFilePath) {
+    const skillDir = join(skillFilePath, "..");
+    const relativePath = relative(skillsRoot, skillDir);
+    if (!relativePath || relativePath === ".") {
+        return undefined;
+    }
+    const segments = relativePath.split(/[/\\]/).filter((segment) => segment.length > 0);
+    if (segments.length <= 1) {
+        return undefined;
+    }
+    return segments[0];
+}
+function readSkillsFromDirectory() {
+    if (!existsSync(HERMES_SKILLS_DIR)) {
+        return { skills: [] };
+    }
+    const skills = [];
+    function walk(currentDir) {
+        let names;
+        try {
+            names = readdirSync(currentDir);
+        }
+        catch {
+            return;
+        }
+        for (const entryName of names) {
+            if (entryName.startsWith(".") && HIDDEN_DIR_NAMES.has(entryName)) {
+                continue;
+            }
+            const fullPath = join(currentDir, entryName);
+            let isDirectory = false;
+            let isFile = false;
+            try {
+                const stats = statSync(fullPath);
+                isDirectory = stats.isDirectory();
+                isFile = stats.isFile();
+            }
+            catch {
+                continue;
+            }
+            if (isDirectory) {
+                walk(fullPath);
+                continue;
+            }
+            if (!isFile || entryName !== SKILL_FILE_NAME) {
+                continue;
+            }
+            let raw = "";
+            try {
+                raw = readFileSync(fullPath, "utf8");
+            }
+            catch {
+                continue;
+            }
+            const frontmatter = parseFrontmatter(raw);
+            const relativePath = relative(HERMES_SKILLS_DIR, join(fullPath, ".."));
+            const fallbackName = relativePath.split(/[/\\]/).filter(Boolean).pop() ?? relativePath;
+            const name = frontmatter.name?.trim() || fallbackName;
+            if (!name) {
+                continue;
+            }
+            const description = frontmatter.description?.trim() ?? "";
+            const category = deriveCategory(HERMES_SKILLS_DIR, fullPath);
+            const skill = { name, description };
+            if (category) {
+                skill.category = category;
+            }
+            skills.push(skill);
+        }
+    }
+    walk(HERMES_SKILLS_DIR);
+    skills.sort((left, right) => {
+        const categoryCompare = (left.category ?? "").localeCompare(right.category ?? "", undefined, {
+            sensitivity: "base",
+        });
+        if (categoryCompare !== 0) {
+            return categoryCompare;
+        }
+        return left.name.localeCompare(right.name, undefined, { sensitivity: "base" });
+    });
+    return { skills };
+}
+async function runHermesSkillsListJson() {
+    try {
+        const { stdout } = await execFileAsync("hermes", ["skills", "list", "--json"], {
+            timeout: LIST_TIMEOUT_MS,
+            maxBuffer: MAX_OUTPUT_BYTES,
+            env: process.env,
+        });
+        const trimmed = stdout.trim();
+        if (!trimmed) {
+            return null;
+        }
+        return normalizeSkillsPayload(JSON.parse(trimmed));
+    }
+    catch {
+        return null;
+    }
+}
+export async function listHermesSkills() {
+    const jsonResult = await runHermesSkillsListJson();
+    if (jsonResult != null) {
+        return jsonResult;
+    }
+    return readSkillsFromDirectory();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saleso.innovations/bridge",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Connect your Hermes agent to the Cleos iOS app via pairing code.",
   "type": "module",
   "license": "MIT",
@@ -9,14 +9,23 @@
     "url": "git+https://github.com/RemiRonning/cleos.git",
     "directory": "packages/cleos-hermes-connect"
   },
-  "keywords": ["cleos", "hermes", "agent", "relay"],
+  "keywords": [
+    "cleos",
+    "hermes",
+    "agent",
+    "relay"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     }
   },
-  "files": ["dist", "README.md", "INTEGRATION.md"],
+  "files": [
+    "dist",
+    "README.md",
+    "INTEGRATION.md"
+  ],
   "bin": {
     "cleos-bridge": "./dist/cli.js",
     "hermes-relay": "./dist/cli.js"
@@ -30,11 +39,13 @@
     "test": "echo 'No @saleso.innovations/bridge tests configured'"
   },
   "dependencies": {
+    "better-sqlite3": "^11.10.0",
     "ws": "^8.18.3"
   },
   "devDependencies": {
     "@repo/eslint-config": "*",
     "@repo/typescript-config": "*",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.4.0",
     "@types/ws": "^8.18.1",
     "eslint": "^9.39.1",