happyskills 0.30.0 → 0.31.0

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.31.0] - 2026-04-06
+
+### Added
+- Add `enable` command (alias: `on`) to restore agent symlinks for previously disabled skills
+- Add `disable` command (alias: `off`) to remove agent symlinks without uninstalling — physical files and lock entries are preserved
+- Add Enabled column to `list` output showing whether each managed skill has active agent symlinks
+- Add `enabled` boolean field to `list --json` output for managed skills
+- Add `--agents` flag to `list` for controlling which agents are checked for enabled/disabled detection
+
+### Changed
+- Install, update, and refresh now respect disabled state — disabled skills are not re-linked after updates
+
+## [0.30.1] - 2026-04-05
+
+### Fixed
+- Fix frequent unnecessary re-login caused by transient refresh failures (network errors, Lambda/NeonDB cold starts) destroying the credentials file — now only clears credentials on permanent failures (Cognito token rejection), preserves the refresh token for transient errors so the next CLI invocation can retry
+- Add diagnostic logging to token refresh failures (`print_warn` to stderr) with actual error reason, replacing silent failure that made auth issues impossible to diagnose
+- Add single retry on transient refresh failure within the same CLI invocation
+
 ## [0.30.0] - 2026-04-03
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "happyskills",
-	"version": "0.30.0",
+	"version": "0.31.0",
 	"description": "Package manager for AI agent skills",
 	"license": "SEE LICENSE IN LICENSE",
 	"author": "Nicolas Dao <nic@cloudlesslabs.com> (https://cloudlesslabs.com)",

package/src/agents/index.js

@@ -1,9 +1,11 @@
 const { AGENTS, get_agent, get_all_agent_ids } = require('./registry')
 const { detect_agents, resolve_agents } = require('./detector')
 const { link_to_agents, unlink_from_agents, is_symlink } = require('./linker')
+const { is_skill_enabled, get_skills_enabled_map } = require('./status')
 
 module.exports = {
 	AGENTS, get_agent, get_all_agent_ids,
 	detect_agents, resolve_agents,
-	link_to_agents, unlink_from_agents, is_symlink
+	link_to_agents, unlink_from_agents, is_symlink,
+	is_skill_enabled, get_skills_enabled_map
 }

package/src/agents/linker.test.js

@@ -0,0 +1,202 @@
+'use strict'
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+const { link_to_agents, unlink_from_agents, is_symlink } = require('./linker')
+
+const make_tmp = () => fs.mkdtempSync(path.join(os.tmpdir(), 'hs-linker-test-'))
+const cleanup = (dir) => fs.rmSync(dir, { recursive: true, force: true })
+
+const make_agent = (id, skills_dir_rel) => ({
+	id,
+	display_name: id,
+	skills_dir: skills_dir_rel,
+	global_skills_dir: skills_dir_rel,
+	detect_paths: []
+})
+
+describe('is_symlink', () => {
+	let tmp
+	beforeEach(() => { tmp = make_tmp() })
+	afterEach(() => { cleanup(tmp) })
+
+	it('returns true for a symlink', async () => {
+		const target = path.join(tmp, 'target')
+		const link = path.join(tmp, 'link')
+		fs.mkdirSync(target)
+		fs.symlinkSync(target, link, 'junction')
+
+		const [errors, result] = await is_symlink(link)
+		assert.equal(errors, null)
+		assert.equal(result, true)
+	})
+
+	it('returns false for a regular directory', async () => {
+		const dir = path.join(tmp, 'regular')
+		fs.mkdirSync(dir)
+
+		const [errors, result] = await is_symlink(dir)
+		assert.equal(errors, null)
+		assert.equal(result, false)
+	})
+
+	it('returns false for a non-existent path', async () => {
+		const [errors, result] = await is_symlink(path.join(tmp, 'nope'))
+		assert.equal(errors, null)
+		assert.equal(result, false)
+	})
+})
+
+describe('link_to_agents', () => {
+	let tmp
+	beforeEach(() => { tmp = make_tmp() })
+	afterEach(() => { cleanup(tmp) })
+
+	it('creates symlinks in agent directories', async () => {
+		const source = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(source, { recursive: true })
+		fs.writeFileSync(path.join(source, 'SKILL.md'), 'test')
+
+		const agents = [make_agent('claude', '.claude/skills')]
+		const [errors, results] = await link_to_agents(source, agents, { global: false, project_root: tmp, skill_name: 'deploy-aws' })
+
+		assert.equal(errors, null)
+		assert.equal(results.length, 1)
+		assert.equal(results[0].agent_id, 'claude')
+		assert.equal(results[0].method, 'symlink')
+
+		const link_path = path.join(tmp, '.claude', 'skills', 'deploy-aws')
+		const stat = fs.lstatSync(link_path)
+		assert.ok(stat.isSymbolicLink())
+		assert.equal(fs.readlinkSync(link_path), source)
+	})
+
+	it('creates symlinks for multiple agents', async () => {
+		const source = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(source, { recursive: true })
+
+		const agents = [
+			make_agent('claude', '.claude/skills'),
+			make_agent('cursor', '.cursor/skills')
+		]
+		const [errors, results] = await link_to_agents(source, agents, { global: false, project_root: tmp, skill_name: 'deploy-aws' })
+
+		assert.equal(errors, null)
+		assert.equal(results.length, 2)
+
+		for (const agent of agents) {
+			const link_path = path.join(tmp, agent.skills_dir, 'deploy-aws')
+			assert.ok(fs.lstatSync(link_path).isSymbolicLink())
+		}
+	})
+
+	it('skips if symlink already points to the correct source', async () => {
+		const source = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(source, { recursive: true })
+
+		const agent_dir = path.join(tmp, '.claude', 'skills')
+		fs.mkdirSync(agent_dir, { recursive: true })
+		fs.symlinkSync(source, path.join(agent_dir, 'deploy-aws'), 'junction')
+
+		const agents = [make_agent('claude', '.claude/skills')]
+		const [errors, results] = await link_to_agents(source, agents, { global: false, project_root: tmp, skill_name: 'deploy-aws' })
+
+		assert.equal(errors, null)
+		assert.equal(results[0].skipped, true)
+	})
+
+	it('replaces stale symlink pointing elsewhere', async () => {
+		const source = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(source, { recursive: true })
+
+		const old_source = path.join(tmp, 'old-location')
+		fs.mkdirSync(old_source, { recursive: true })
+		const agent_dir = path.join(tmp, '.claude', 'skills')
+		fs.mkdirSync(agent_dir, { recursive: true })
+		fs.symlinkSync(old_source, path.join(agent_dir, 'deploy-aws'), 'junction')
+
+		const agents = [make_agent('claude', '.claude/skills')]
+		const [errors, results] = await link_to_agents(source, agents, { global: false, project_root: tmp, skill_name: 'deploy-aws' })
+
+		assert.equal(errors, null)
+		assert.equal(results[0].method, 'symlink')
+		assert.equal(results[0].skipped, undefined)
+
+		const link_path = path.join(tmp, '.claude', 'skills', 'deploy-aws')
+		assert.equal(fs.readlinkSync(link_path), source)
+	})
+})
+
+describe('unlink_from_agents', () => {
+	let tmp
+	beforeEach(() => { tmp = make_tmp() })
+	afterEach(() => { cleanup(tmp) })
+
+	it('removes symlinks from agent directories', async () => {
+		const source = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(source, { recursive: true })
+
+		const agent_dir = path.join(tmp, '.claude', 'skills')
+		fs.mkdirSync(agent_dir, { recursive: true })
+		fs.symlinkSync(source, path.join(agent_dir, 'deploy-aws'), 'junction')
+
+		const agents = [make_agent('claude', '.claude/skills')]
+		const [errors, results] = await unlink_from_agents('deploy-aws', agents, { global: false, project_root: tmp })
+
+		assert.equal(errors, null)
+		assert.equal(results[0].removed, true)
+		assert.ok(!fs.existsSync(path.join(agent_dir, 'deploy-aws')))
+	})
+
+	it('reports removed=false when symlink does not exist', async () => {
+		const agents = [make_agent('claude', '.claude/skills')]
+		const [errors, results] = await unlink_from_agents('deploy-aws', agents, { global: false, project_root: tmp })
+
+		assert.equal(errors, null)
+		assert.equal(results[0].removed, false)
+	})
+
+	it('removes from multiple agents', async () => {
+		const source = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(source, { recursive: true })
+
+		const agents = [
+			make_agent('claude', '.claude/skills'),
+			make_agent('cursor', '.cursor/skills')
+		]
+
+		for (const agent of agents) {
+			const agent_dir = path.join(tmp, agent.skills_dir)
+			fs.mkdirSync(agent_dir, { recursive: true })
+			fs.symlinkSync(source, path.join(agent_dir, 'deploy-aws'), 'junction')
+		}
+
+		const [errors, results] = await unlink_from_agents('deploy-aws', agents, { global: false, project_root: tmp })
+
+		assert.equal(errors, null)
+		assert.ok(results.every(r => r.removed === true))
+		for (const agent of agents) {
+			assert.ok(!fs.existsSync(path.join(tmp, agent.skills_dir, 'deploy-aws')))
+		}
+	})
+
+	it('does not remove the canonical source directory', async () => {
+		const source = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(source, { recursive: true })
+		fs.writeFileSync(path.join(source, 'SKILL.md'), 'test')
+
+		const agent_dir = path.join(tmp, '.claude', 'skills')
+		fs.mkdirSync(agent_dir, { recursive: true })
+		fs.symlinkSync(source, path.join(agent_dir, 'deploy-aws'), 'junction')
+
+		const agents = [make_agent('claude', '.claude/skills')]
+		await unlink_from_agents('deploy-aws', agents, { global: false, project_root: tmp })
+
+		// Canonical source must still exist
+		assert.ok(fs.existsSync(source))
+		assert.ok(fs.existsSync(path.join(source, 'SKILL.md')))
+	})
+})

package/src/agents/status.js

@@ -0,0 +1,42 @@
+const { error: { catch_errors } } = require('puffy-core')
+const { is_symlink } = require('./linker')
+const { agent_skill_install_dir } = require('../config/paths')
+
+/**
+ * Check whether a skill is enabled (has at least one symlink in an agent folder).
+ *
+ * @param {string} skill_name — short name (e.g. "deploy-aws")
+ * @param {Agent[]} agents — detected agent objects
+ * @param {boolean} is_global
+ * @param {string} project_root
+ * @returns {Promise} [errors, boolean]
+ */
+const is_skill_enabled = (skill_name, agents, is_global, project_root) => catch_errors('Skill enabled check failed', async () => {
+	for (const agent of agents) {
+		const target = agent_skill_install_dir(agent, is_global, project_root, skill_name)
+		const [, link] = await is_symlink(target)
+		if (link) return true
+	}
+	return false
+})
+
+/**
+ * Batch-check enabled status for multiple skills.
+ *
+ * @param {string[]} skill_names — array of short names
+ * @param {Agent[]} agents — detected agent objects
+ * @param {boolean} is_global
+ * @param {string} project_root
+ * @returns {Promise} [errors, Map<string, boolean>] — skill_name → enabled
+ */
+const get_skills_enabled_map = (skill_names, agents, is_global, project_root) => catch_errors('Skill enabled map failed', async () => {
+	const map = new Map()
+	const checks = skill_names.map(async (name) => {
+		const [, enabled] = await is_skill_enabled(name, agents, is_global, project_root)
+		map.set(name, enabled === true)
+	})
+	await Promise.all(checks)
+	return map
+})
+
+module.exports = { is_skill_enabled, get_skills_enabled_map }

package/src/agents/status.test.js

@@ -0,0 +1,127 @@
+'use strict'
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+const { is_skill_enabled, get_skills_enabled_map } = require('./status')
+
+const make_tmp = () => fs.mkdtempSync(path.join(os.tmpdir(), 'hs-status-test-'))
+const cleanup = (dir) => fs.rmSync(dir, { recursive: true, force: true })
+
+/**
+ * Helper: create a fake agent definition for testing.
+ */
+const make_agent = (id, skills_dir_rel) => ({
+	id,
+	display_name: id,
+	skills_dir: skills_dir_rel,
+	global_skills_dir: skills_dir_rel,
+	detect_paths: []
+})
+
+describe('is_skill_enabled', () => {
+	let tmp
+	beforeEach(() => { tmp = make_tmp() })
+	afterEach(() => { cleanup(tmp) })
+
+	it('returns true when a symlink exists in an agent folder', async () => {
+		const canonical = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(canonical, { recursive: true })
+		fs.writeFileSync(path.join(canonical, 'SKILL.md'), '---\nname: deploy-aws\n---\n')
+
+		const agent_dir = path.join(tmp, '.claude', 'skills')
+		fs.mkdirSync(agent_dir, { recursive: true })
+		fs.symlinkSync(canonical, path.join(agent_dir, 'deploy-aws'), 'junction')
+
+		const agent = make_agent('claude', '.claude/skills')
+		const [errors, enabled] = await is_skill_enabled('deploy-aws', [agent], false, tmp)
+		assert.equal(errors, null)
+		assert.equal(enabled, true)
+	})
+
+	it('returns false when no symlink exists in any agent folder', async () => {
+		const canonical = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(canonical, { recursive: true })
+
+		const agent = make_agent('claude', '.claude/skills')
+		const [errors, enabled] = await is_skill_enabled('deploy-aws', [agent], false, tmp)
+		assert.equal(errors, null)
+		assert.equal(enabled, false)
+	})
+
+	it('returns false when agent folder does not exist', async () => {
+		const agent = make_agent('claude', '.claude/skills')
+		const [errors, enabled] = await is_skill_enabled('deploy-aws', [agent], false, tmp)
+		assert.equal(errors, null)
+		assert.equal(enabled, false)
+	})
+
+	it('returns true if any one of multiple agents has the symlink', async () => {
+		const canonical = path.join(tmp, '.agents', 'skills', 'deploy-aws')
+		fs.mkdirSync(canonical, { recursive: true })
+
+		// Only cursor has the symlink, not claude
+		const cursor_dir = path.join(tmp, '.cursor', 'skills')
+		fs.mkdirSync(cursor_dir, { recursive: true })
+		fs.symlinkSync(canonical, path.join(cursor_dir, 'deploy-aws'), 'junction')
+
+		const agents = [
+			make_agent('claude', '.claude/skills'),
+			make_agent('cursor', '.cursor/skills')
+		]
+		const [errors, enabled] = await is_skill_enabled('deploy-aws', agents, false, tmp)
+		assert.equal(errors, null)
+		assert.equal(enabled, true)
+	})
+
+	it('returns false with an empty agents array', async () => {
+		const [errors, enabled] = await is_skill_enabled('deploy-aws', [], false, tmp)
+		assert.equal(errors, null)
+		assert.equal(enabled, false)
+	})
+})
+
+describe('get_skills_enabled_map', () => {
+	let tmp
+	beforeEach(() => { tmp = make_tmp() })
+	afterEach(() => { cleanup(tmp) })
+
+	it('returns a map with correct enabled/disabled status for multiple skills', async () => {
+		const agents_skills = path.join(tmp, '.agents', 'skills')
+		const skill_a = path.join(agents_skills, 'skill-a')
+		const skill_b = path.join(agents_skills, 'skill-b')
+		fs.mkdirSync(skill_a, { recursive: true })
+		fs.mkdirSync(skill_b, { recursive: true })
+
+		// Only skill-a is symlinked (enabled)
+		const claude_dir = path.join(tmp, '.claude', 'skills')
+		fs.mkdirSync(claude_dir, { recursive: true })
+		fs.symlinkSync(skill_a, path.join(claude_dir, 'skill-a'), 'junction')
+
+		const agents = [make_agent('claude', '.claude/skills')]
+		const [errors, map] = await get_skills_enabled_map(['skill-a', 'skill-b'], agents, false, tmp)
+
+		assert.equal(errors, null)
+		assert.equal(map.get('skill-a'), true)
+		assert.equal(map.get('skill-b'), false)
+	})
+
+	it('returns all false when no symlinks exist', async () => {
+		const agents = [make_agent('claude', '.claude/skills')]
+		const [errors, map] = await get_skills_enabled_map(['foo', 'bar'], agents, false, tmp)
+
+		assert.equal(errors, null)
+		assert.equal(map.get('foo'), false)
+		assert.equal(map.get('bar'), false)
+	})
+
+	it('handles empty skill list', async () => {
+		const agents = [make_agent('claude', '.claude/skills')]
+		const [errors, map] = await get_skills_enabled_map([], agents, false, tmp)
+
+		assert.equal(errors, null)
+		assert.equal(map.size, 0)
+	})
+})

package/src/auth/token_store.js

@@ -3,18 +3,43 @@ const path = require('path')
 const { error: { catch_errors } } = require('puffy-core')
 const { credentials_path, config_dir } = require('../config/paths')
 
+const _is_permanent_failure = (errors) => {
+	if (!errors) return false
+	const { AuthError } = require('../utils/errors')
+	return errors.some(e => e instanceof AuthError)
+}
+
 const _try_refresh = async (refresh_token) => {
-	try {
-		const { refresh } = require('../api/auth')
-		const [errors, data] = await refresh(refresh_token)
-		if (errors || !data) return null
-		const merged = { ...data, refresh_token }
-		const [save_err] = await save_token(merged)
-		if (save_err) return null
-		return { ...merged, stored_at: new Date().toISOString() }
-	} catch {
-		return null
+	const max_attempts = 2
+	let permanent = false
+	for (let attempt = 1; attempt <= max_attempts; attempt++) {
+		try {
+			const { refresh } = require('../api/auth')
+			const [errors, data] = await refresh(refresh_token)
+			if (errors || !data) {
+				const reason = errors
+					? errors.map(e => e.message || String(e)).join('; ')
+					: 'empty response from server'
+				const { print_warn } = require('../ui/output')
+				print_warn(`Token refresh failed (attempt ${attempt}/${max_attempts}): ${reason}`)
+				permanent = _is_permanent_failure(errors)
+				if (permanent || attempt >= max_attempts) return { ok: false, permanent }
+				continue
+			}
+			const merged = { ...data, refresh_token }
+			const [save_err] = await save_token(merged)
+			if (save_err) return { ok: false, permanent: false }
+			return { ok: true, data: { ...merged, stored_at: new Date().toISOString() } }
+		} catch (err) {
+			const { print_warn } = require('../ui/output')
+			print_warn(`Token refresh exception (attempt ${attempt}/${max_attempts}): ${err.message || String(err)}`)
+			const { AuthError } = require('../utils/errors')
+			permanent = err instanceof AuthError
+			if (permanent || attempt >= max_attempts) return { ok: false, permanent }
+			continue
+		}
 	}
+	return { ok: false, permanent: false }
 }
 
 const save_token = (token_data) => catch_errors('Failed to save token', async () => {
@@ -55,10 +80,16 @@ const load_token = () => catch_errors('Failed to load token', async () => {
 		const elapsed_sec = (now - stored) / 1000
 		if (elapsed_sec >= data.expires_in) {
 			if (data.refresh_token) {
-				const refreshed = await _try_refresh(data.refresh_token)
-				if (refreshed) return refreshed
+				const result = await _try_refresh(data.refresh_token)
+				if (result.ok) return result.data
+				// Permanent failure (Cognito rejected the token) → clear the file.
+				// Transient failure (network, cold start) → preserve the file so
+				// the next invocation can retry with the still-valid refresh token.
+				if (result.permanent) await clear_token()
+			} else {
+				// No refresh token — nothing to preserve, clean up the expired file.
+				await clear_token()
 			}
-			await clear_token()
 			return null
 		}
 	}