@jacebenson/jsn 3.3.0 → 3.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacebenson/jsn",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "A command-line interface for ServiceNow that follows the Unix philosophy: simple, composable, and scriptable.",
   "type": "module",
   "bin": {
@@ -10,7 +10,6 @@
   "scripts": {
     "test": "NODE_OPTIONS=--require=./suppress-warnings.cjs node --test $(find test -name '*.test.js')",
     "lint": "npx eslint src/ bin/ test/",
-    "postinstall": "node scripts/postinstall.mjs",
     "start": "NODE_OPTIONS=--require=./suppress-warnings.cjs node bin/jsn.js",
     "tag-reminder": "node scripts/tag-reminder.js",
     "release": "node scripts/release.js"

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)),
@@ -18,6 +20,9 @@ const SKILL_RAW_URL = 'https://raw.githubusercontent.com/jacebenson/jsn/nodejs/s
  * Resolve the user's real home directory, even when Hermes overrides $HOME.
  */
 function realHomeDir() {
+  // getent doesn't exist on Windows; os.homedir() is reliable there.
+  if (process.platform === 'win32') return os.homedir();
+
   try {
     const result = execSync('getent passwd ' + process.env.USER + ' 2>/dev/null', { encoding: 'utf-8', timeout: 3000 });
     const home = result.trim().split(':')[5];
@@ -94,73 +99,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 +203,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 +384,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}`

package/scripts/postinstall.mjs

@@ -1,80 +0,0 @@
-#!/usr/bin/env node
-/**
- * postinstall.mjs — Copies the bundled ServiceNow SKILL.md to agent skill directories
- * on npm global install. Mirrors what `basecamp`'s installer does for their skill.
- *
- * Only runs when `npm install -g @jacebenson/jsn`.
- * On `npm install` (local dependency), it's a no-op.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SKILL_SOURCE = path.resolve(__dirname, '..', 'skills', 'servicenow', 'SKILL.md');
-const AGENTS_DIR = path.join(os.homedir(), '.agents', 'skills', 'servicenow');
-const AGENTS_SKILL = path.join(AGENTS_DIR, 'SKILL.md');
-const CLAUDE_SKILL_DIR = path.join(os.homedir(), '.claude', 'skills');
-const CLAUDE_SYMLINK = path.join(CLAUDE_SKILL_DIR, 'servicenow');
-
-function isGlobalInstall() {
-  return (
-    process.env.npm_config_global === 'true' ||
-    process.env.npm_lifecycle_event === 'postinstall'
-  );
-}
-
-function installSkill() {
-  // Check if running in a non-interactive/CI environment where .agents
-  // doesn't make sense. Skip silently.
-  if (!AGENTS_DIR.startsWith(os.homedir())) {
-    return;
-  }
-
-  if (!fs.existsSync(SKILL_SOURCE)) {
-    console.warn('  ⚠ jsn: ServiceNow SKILL.md not found at', SKILL_SOURCE);
-    return;
-  }
-
-  // Create ~/.agents/skills/servicenow/
-  try {
-    fs.mkdirSync(AGENTS_DIR, { recursive: true });
-  } catch {
-    // user's home might not be writable in container/CI
-    return;
-  }
-
-  // Copy the bundled skill file
-  try {
-    fs.copyFileSync(SKILL_SOURCE, AGENTS_SKILL);
-    console.log('  ✓ jsn: ServiceNow skill installed to ' + AGENTS_SKILL);
-  } catch (err) {
-    console.warn('  ⚠ jsn: Could not copy skill to ' + AGENTS_SKILL, err.message);
-    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 {
-    fs.mkdirSync(CLAUDE_SKILL_DIR, { recursive: true });
-
-    // Remove stale symlink or directory if it exists
-    try {
-      fs.unlinkSync(CLAUDE_SYMLINK);
-    } catch {
-      // doesn't exist — fine
-    }
-
-    // Relative symlink so it survives user home dir moves
-    const relativeTarget = path.relative(CLAUDE_SKILL_DIR, AGENTS_DIR);
-    fs.symlinkSync(relativeTarget, CLAUDE_SYMLINK, 'dir');
-    console.log('  ✓ jsn: Claude Code skill link at ' + CLAUDE_SYMLINK);
-  } catch (err) {
-    // Claude Code skill dir might not be expected — non-fatal
-    console.warn('  ⚠ jsn: Could not create Claude Code symlink:', err.message);
-  }
-}
-
-installSkill();