@gethmy/mcp 2.8.0 → 2.8.1

package/src/skills.ts

@@ -1,7 +1,15 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
 import { HarmonyApiClient } from "./api-client.js";
 import { areSkillsInstalled, isConfigured } from "./config.js";
+import { loadHmyConfig } from "./hmy-config.js";
 
 /**
  * Legacy workflow prompt used by Codex / Cursor agents. Kept inline because
@@ -112,10 +120,45 @@ export interface FetchedSkill {
  * deploys where the API hasn't been upgraded yet.
  */
 export function buildSkillFile(skill: FetchedSkill): string {
-  if (skill.skillVersion !== undefined && !hasMetadataVersion(skill.content)) {
-    return injectMetadataVersion(skill.content, skill.skillVersion);
+  const content = stripSkillPreamble(skill.content);
+  if (skill.skillVersion !== undefined && !hasMetadataVersion(content)) {
+    return injectMetadataVersion(content, skill.skillVersion);
   }
-  return skill.content;
+  return content;
+}
+
+const PREAMBLE_START = "<!-- hmy-skills-preamble:start -->";
+const PREAMBLE_END = "<!-- hmy-skills-preamble:end -->";
+
+/**
+ * Remove the legacy auto-update bash block from a rendered SKILL.md before it
+ * lands on disk. harmony-api no longer emits this block, but cached renders and
+ * already-installed files may still carry it — and that block is exactly what
+ * Claude Code's auto-mode classifier denies (curl → chmod +x → exec). Stripping
+ * on write means upgraded clients stop hitting the classifier on the next
+ * refresh. No-op when the markers are absent.
+ */
+export function stripSkillPreamble(content: string): string {
+  const start = content.indexOf(PREAMBLE_START);
+  const end = content.indexOf(PREAMBLE_END);
+  if (start === -1 || end === -1 || end < start) return content;
+  const stripped =
+    content.slice(0, start) + content.slice(end + PREAMBLE_END.length);
+  // Collapse the blank-line run the removal leaves behind; keep a trailing \n.
+  return `${stripped.replace(/\n{3,}/g, "\n\n").replace(/\s+$/, "")}\n`;
+}
+
+/**
+ * Write a file atomically: write to a sibling temp file, then rename over the
+ * target (atomic on the same filesystem). Avoids a half-written SKILL.md if the
+ * process dies mid-write during a silent background refresh.
+ */
+function atomicWrite(filePath: string, content: string): void {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  writeFileSync(tmp, content);
+  renameSync(tmp, filePath);
 }
 
 function hasMetadataVersion(content: string): boolean {
@@ -181,25 +224,72 @@ function findSkillFiles(
   return results;
 }
 
+const HMY_DIR = join(homedir(), ".hmy");
+const HMY_VERSION_FILE = join(HMY_DIR, "VERSION");
+const LAST_CHECK_FILE = join(HMY_DIR, "last-update-check");
+/** Probe the API for skill updates at most once per day per client. */
+const CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+
+/** True if we performed a network check within CHECK_TTL_MS. */
+function checkedRecently(now: number = Date.now()): boolean {
+  try {
+    if (!existsSync(LAST_CHECK_FILE)) return false;
+    const ts = Number.parseInt(
+      readFileSync(LAST_CHECK_FILE, "utf-8").trim(),
+      10,
+    );
+    if (!Number.isFinite(ts)) return false;
+    return now - ts < CHECK_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+
+/** Record that a network check just happened, resetting the TTL window. */
+function recordCheck(now: number = Date.now()): void {
+  try {
+    if (!existsSync(HMY_DIR)) mkdirSync(HMY_DIR, { recursive: true });
+    writeFileSync(LAST_CHECK_FILE, String(now));
+  } catch {
+    // Best effort — a failed timestamp write only costs an extra probe.
+  }
+}
+
 /**
  * Silently refresh installed skill files if remote versions are newer.
- * Called at MCP server startup. Non-blocking — any error (offline, 401,
- * partial install) is caught and the existing files are left in place.
+ * Called at MCP server `serve` startup (cli.ts). Non-blocking — any error
+ * (offline, 401, partial install) is caught and the existing files are left in
+ * place. Returns whether any file was rewritten so the caller can fire a
+ * `notifications/resources/list_changed` once the transport is connected.
+ *
+ * Honors `~/.hmy/config.yaml`: `update_check: false` disables it entirely and a
+ * `pin` freezes the installed version. The network probe is gated to once per
+ * `CHECK_TTL_MS` (tracked in `~/.hmy/last-update-check`) so starting many
+ * sessions in a day doesn't re-probe the API each time — pass `force` to skip
+ * the gate.
  *
  * Phase 3b: per-skill compare. Each skill_resource row carries its own
- * monotonic `version`. The mcp-server fetches each skill's `/v1/skills/<name>`
- * once, reads the per-skill `skillVersion` from the response, and rewrites
- * only the local files that are behind. An admin bumping `hmy` no longer
- * triggers a re-fetch of `hmy-plan`, `hmy-cleanup`, etc.
+ * monotonic `version`; only files that are behind are rewritten. Writes are
+ * atomic (temp + rename) and the legacy auto-update bash block is stripped on
+ * the way to disk (see buildSkillFile / stripSkillPreamble).
  */
-export async function refreshSkills(): Promise<void> {
+export async function refreshSkills(
+  opts: { force?: boolean } = {},
+): Promise<{ updated: boolean }> {
   try {
-    if (!isConfigured()) return;
+    if (!isConfigured()) return { updated: false };
+
+    const cfg = loadHmyConfig();
+    if (!cfg.updateCheck || cfg.pin) return { updated: false };
+    if (!opts.force && checkedRecently()) return { updated: false };
+
     const status = areSkillsInstalled();
-    if (!status.installed) return;
+    if (!status.installed) return { updated: false };
 
     const client = new HarmonyApiClient();
     const versionInfo = await client.fetchSkillsVersion();
+    // We hit the network — reset the TTL window regardless of outcome.
+    recordCheck();
 
     const skillFiles = findSkillFiles(status.paths, versionInfo.skills);
 
@@ -222,7 +312,7 @@ export async function refreshSkills(): Promise<void> {
         }
       }
     }
-    if (skillFiles.length === 0) return;
+    if (skillFiles.length === 0) return { updated: false };
 
     let updated = false;
     for (const { name, filePath } of skillFiles) {
@@ -243,10 +333,7 @@ export async function refreshSkills(): Promise<void> {
           continue;
         }
 
-        const newContent = buildSkillFile(fetched);
-        const dir = dirname(filePath);
-        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-        writeFileSync(filePath, newContent);
+        atomicWrite(filePath, buildSkillFile(fetched));
         updated = true;
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -254,9 +341,18 @@ export async function refreshSkills(): Promise<void> {
       }
     }
     if (updated) {
+      // VERSION is diagnostic now (the bash preamble that read it is gone),
+      // but keep it current so `hmy-mcp status` and support reflect reality.
+      try {
+        atomicWrite(HMY_VERSION_FILE, versionInfo.version);
+      } catch {
+        // best effort
+      }
       console.error("Harmony: Refreshed skills from server");
     }
+    return { updated };
   } catch {
     // Non-blocking — offline / 401 / partial install all fall through here.
+    return { updated: false };
   }
 }

package/src/tui/setup.ts

@@ -271,9 +271,9 @@ async function getAgentFiles(
   switch (agentId) {
     case "claude": {
       // Claude Code skills come from /v1/skills (DB-backed). Fetch the
-      // canonical list, then each body. hmy-update-check is intentionally
-      // skipped — it's a shell script the auto-update preamble curls on
-      // demand, not an installed SKILL.md.
+      // canonical list, then each body. hmy-update-check is skipped here — it's
+      // a shell script, not an installed SKILL.md. buildSkillFile() strips any
+      // legacy auto-update bash block before the content lands on disk.
       const client = new HarmonyApiClient();
       const versionInfo = await client.fetchSkillsVersion();
       const installableNames = versionInfo.skills.filter(
@@ -319,11 +319,11 @@ async function getAgentFiles(
         );
       }
 
-      // Pre-populate ~/.hmy/VERSION and ~/.hmy/bin/hmy-update-check so the
-      // lazy bootstrap inside the skill preamble is bypassed on first run.
-      // Without this, the bootstrap writes "1.0.0" as a fallback whenever the
-      // version fetch times out (edge function cold start) — triggering a
-      // spurious "upgrade to v6" prompt the moment the skill is first invoked.
+      // Seed ~/.hmy/VERSION (the baseline the server's refreshSkills compares
+      // against and keeps current) and ~/.hmy/bin/hmy-update-check. The script
+      // is no longer invoked by a skill preamble — auto-update now runs in the
+      // MCP server process — but it's kept as a standalone diagnostic and is
+      // integrity-checked here against its published sha256.
       try {
         const updateCheckFetched = await client.fetchSkill("hmy-update-check");
         const actualHash = createHash("sha256")