@jacebenson/jsn 3.3.0 → 3.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacebenson/jsn",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "description": "A command-line interface for ServiceNow that follows the Unix philosophy: simple, composable, and scriptable.",
   "type": "module",
   "bin": {

package/scripts/postinstall.mjs

@@ -55,6 +55,10 @@ function installSkill() {
     return;
   }
 
+  // Symlinks require admin on Windows and are pointless outside Unix/Mac.
+  // Skip on win32 to avoid "system cannot find the path" errors.
+  if (process.platform === 'win32') return;
+
   // Create symlink at ~/.claude/skills/servicenow → ../../.agents/skills/servicenow
   // This is the same pattern basecamp's installer uses: ~/.claude/skills/basecamp → ../../.agents/skills/basecamp
   try {

package/src/cli.js

@@ -210,10 +210,31 @@ export function buildCLI() {
         || argv.json
         || argv.quiet;
 
-      // Auto-check skill on every command (fire-and-forget, non-blocking)
+      // Auto-check skill on every command (once per 24h, non-blocking)
       const skipSkillCheck = ['help', 'version', 'completion', 'skill', 'docs'].includes(cmd)
         || process.env.JSN_NO_SKILL_CHECK === '1'
-        || argv['no-skill-check']
+        || argv['no-skill-check'];
+      if (!skipSkillCheck) {
+        const skillCacheFile = path.join(globalConfigDir(), '.last-skill-check');
+        let shouldCheckSkill = true;
+        try {
+          const mtime = fs.statSync(skillCacheFile).mtimeMs;
+          if (Date.now() - mtime < 86400000) shouldCheckSkill = false;
+        } catch {
+          // File doesn't exist — check
+        }
+
+        if (shouldCheckSkill) {
+          checkSkill().catch(() => {});
+
+          try {
+            fs.mkdirSync(globalConfigDir(), { recursive: true });
+            fs.writeFileSync(skillCacheFile, String(Date.now()), 'utf-8');
+          } catch {
+            // Non-fatal
+          }
+        }
+      }
       if (!skipNpmCheck) {
         const cacheFile = path.join(globalConfigDir(), '.last-npm-check');
         let shouldCheck = true;

package/src/commands/skill.js

@@ -6,6 +6,8 @@ import { fileURLToPath } from 'node:url';
 
 import { execSync } from 'node:child_process';
 
+import { globalConfigPath } from '../config.js';
+
 const SKILL_NAME = 'servicenow';
 const SKILL_REPO_PATH = path.join(
   path.dirname(fileURLToPath(import.meta.url)),
@@ -94,73 +96,75 @@ function readBundledSkill() {
   }
 }
 
-export async function checkSkill() {
-  // Compare all installed skill copies against GitHub.
-  // Uses a single HTTP fetch and reads all harness paths that exist.
-  // Returns the first installed version found for comparison, plus a list
-  // of harnesses where the skill is current vs outdated (or missing).
-  const SKILL_NAME = 'servicenow';
-
-  // Collect all installed copies that actually exist on disk
-  const installedCopies = [];
-  for (const [key, dir] of Object.entries(AGENT_SKILL_DIRS)) {
-    const skillPath = key === 'cursor'
-      ? path.join(dir, `${SKILL_NAME}.mdc`)
-      : path.join(dir, 'SKILL.md');
-    try {
-      const content = fs.readFileSync(skillPath, 'utf-8');
-      installedCopies.push({ harness: key, label: TARGET_NAMES[key], content, path: skillPath });
-    } catch {
-      // Not installed to this harness — skip
-    }
+// ── Skill config helpers — read/write skillLocation / skillVersion / skillLastChecked ──
+
+function loadSkillConfig() {
+  try {
+    const raw = fs.readFileSync(globalConfigPath(), 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
   }
+}
 
-  // Fall back to bundled skill if nothing installed yet
-  const primary = installedCopies[0] || { content: readBundledSkill() };
-  if (!primary.content) return { current: false, error: 'Skill file not found' };
+function saveSkillConfig(updates) {
+  const cfg = loadSkillConfig();
+  Object.assign(cfg, updates);
+  fs.mkdirSync(path.dirname(globalConfigPath()), { recursive: true });
+  fs.writeFileSync(globalConfigPath(), JSON.stringify(cfg, null, 2), { mode: 0o600 });
+}
 
-  const installedVersion = extractVersion(primary.content);
-  if (!installedVersion) return { current: false, error: 'No version field in installed skill' };
+function recordSkillInstall(targetPath) {
+  const bundled = readBundledSkill();
+  const version = extractVersion(bundled) || 'unknown';
+  saveSkillConfig({
+    skillLocation: targetPath,
+    skillVersion: version,
+    skillLastChecked: new Date().toISOString(),
+  });
+}
 
-  try {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 10000);
-    const res = await fetch(SKILL_RAW_URL, { signal: controller.signal });
-    clearTimeout(timer);
-    if (!res.ok) return { current: false, error: `GitHub returned ${res.status}` };
-    const upstream = await res.text();
-    const upstreamVersion = extractVersion(upstream);
-    if (!upstreamVersion) return { current: false, error: 'No version field in upstream skill' };
-
-    const current = installedVersion === upstreamVersion;
-
-    // Check each installed copy for version match
-    const outdated = [];
-    for (const copy of installedCopies) {
-      const v = extractVersion(copy.content);
-      if (v && v !== upstreamVersion) {
-        outdated.push(copy.label);
-      }
-    }
+// ── Skill version check (once per day, uses recorded location) ──
+
+export function checkSkill() {
+  const cfg = loadSkillConfig();
+  const location = cfg.skillLocation;
+  if (!location) return { current: true, note: 'Skill not installed — run "jsn skill install"' };
 
-    const outdatedMsg = outdated.length > 0
-      ? ` Skill outdated for ${outdated.join(', ')} (v${installedVersion} vs GitHub v${upstreamVersion}) — run "jsn skill install" to update`
-      : null;
-
-    return {
-      current,
-      installed_version: installedVersion,
-      upstream_version: upstreamVersion,
-      checked: installedCopies.length,
-      harnesses: {
-        installed: installedCopies.map(c => c.label),
-        outdated,
-      },
-      error: current ? null : outdatedMsg,
-    };
+  // Throttle: skip if checked within last 24 hours
+  if (cfg.skillLastChecked) {
+    const elapsed = Date.now() - new Date(cfg.skillLastChecked).getTime();
+    if (elapsed < 86400000) return { current: true, note: 'Checked within 24h — skipping' };
+  }
+
+  let installed;
+  try {
+    installed = fs.readFileSync(location, 'utf-8');
   } catch {
-    return { current: false, error: 'Could not check — GitHub unreachable' };
+    return { current: true, note: `Skill file not found at ${location} — run "jsn skill install"` };
   }
+
+  const installedVersion = extractVersion(installed);
+  const bundled = readBundledSkill();
+  const bundledVersion = extractVersion(bundled);
+
+  if (!installedVersion || !bundledVersion) {
+    return { current: true, error: 'Could not determine skill version' };
+  }
+
+  const current = installedVersion === bundledVersion;
+
+  if (!current) {
+    process.stderr.write(
+      `\n⚠ jsn: ServiceNow skill is outdated (installed v${installedVersion}, bundled v${bundledVersion}).\n` +
+      `  Run "jsn skill install" to update.\n\n`
+    );
+  }
+
+  // Update last-checked timestamp
+  saveSkillConfig({ skillLastChecked: new Date().toISOString() });
+
+  return { current, installed_version: installedVersion, bundled_version: bundledVersion };
 }
 
 function extractVersion(content) {
@@ -196,28 +200,19 @@ export function skillCmd(wrap) {
         })
         .command({
           command: 'check',
-          describe: 'Check if the bundled skill file is up to date with GitHub',
+          describe: 'Check if the installed skill matches the bundled version',
           handler: wrap(async (_argv, app) => {
-            const result = await checkSkill();
-            const h = result.harnesses || {};
+            const result = checkSkill();
 
-            // Build a summary that shows which harnesses are installed and current
             let summary;
-            if (result.error && !result.current) {
+            if (result.error) {
               summary = result.error;
+            } else if (result.note) {
+              summary = result.note;
             } else if (result.current) {
-              const parts = [`✓ Skill is current (v${result.installed_version})`];
-              if (h.installed && h.installed.length > 0) {
-                parts.push(` — installed for ${h.installed.join(', ')}`);
-              }
-              summary = parts.join('');
+              summary = `✓ Skill is current (v${result.installed_version} matches bundled v${result.bundled_version})`;
             } else {
-              const parts = [`⚠ Skill outdated: installed v${result.installed_version} vs GitHub v${result.upstream_version}`];
-              if (h.outdated && h.outdated.length > 0) {
-                parts.push(` — outdated for ${h.outdated.join(', ')}`);
-              }
-              parts.push(` — run "jsn skill install" to update`);
-              summary = parts.join('');
+              summary = `⚠ Skill outdated: installed v${result.installed_version} vs bundled v${result.bundled_version} — run "jsn skill install" to update`;
             }
 
             app.ok(result, { summary });
@@ -386,6 +381,9 @@ export function skillCmd(wrap) {
               throw new Error(`No targets matched. Valid targets: ${Object.keys(AGENT_SKILL_DIRS).join(', ')}, or "all"`);
             }
 
+            // Record install location so checkSkill knows where to look
+            recordSkillInstall(targets[0].path);
+
             const installed = targets.reduce((acc, t) => { acc[t.name] = t.path; return acc; }, {});
             const summary = targets.length === 1
               ? `Skill installed to ${targets[0].path}`