happyskills 0.30.0 → 0.31.0

package/src/auth/token_store.test.js

@@ -12,7 +12,7 @@ const fs = require('fs')
 // ─────────────────────────────────────────────────────────────────────────────
 
 const { save_token, load_token, clear_token, require_token } = require('./token_store')
-const { AuthError } = require('../utils/errors')
+const { AuthError, NetworkError } = require('../utils/errors')
 
 // ─── helpers ──────────────────────────────────────────────────────────────────
 
@@ -200,3 +200,199 @@ describe('require_token', () => {
 		})
 	})
 })
+
+// ─── token refresh behavior ─────────────────────────────────────────────────
+//
+// _try_refresh is internal, but its behavior is observable through load_token:
+// when the id_token is expired and a refresh_token exists, load_token calls
+// _try_refresh which calls require('../api/auth').refresh(). We mock that
+// module in require.cache to control the refresh outcome.
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('load_token — refresh behavior', () => {
+	const auth_path = require.resolve('../api/auth')
+	let orig_auth_cache
+
+	const mock_refresh = (fn) => {
+		orig_auth_cache = require.cache[auth_path]
+		require.cache[auth_path] = {
+			id: auth_path,
+			filename: auth_path,
+			loaded: true,
+			exports: { refresh: fn }
+		}
+	}
+
+	const restore_refresh = () => {
+		if (orig_auth_cache) require.cache[auth_path] = orig_auth_cache
+		else delete require.cache[auth_path]
+	}
+
+	const write_expired_token = (dir, overrides = {}) => {
+		const token = {
+			id_token: 'expired-id-token',
+			access_token: 'expired-access-token',
+			refresh_token: 'valid-refresh-token',
+			expires_in: 1,
+			stored_at: new Date(Date.now() - 5000).toISOString(),
+			...overrides
+		}
+		fs.mkdirSync(path.join(dir, 'happyskills'), { recursive: true })
+		fs.writeFileSync(creds_file(dir), JSON.stringify(token), { mode: 0o600 })
+		return token
+	}
+
+	it('returns refreshed token when refresh succeeds', async () => {
+		await with_tmp(async (dir) => {
+			write_expired_token(dir)
+			mock_refresh(async () => [null, {
+				id_token: 'new-id-token',
+				access_token: 'new-access-token',
+				expires_in: 3600
+			}])
+			try {
+				const [err, loaded] = await load_token()
+				assert.strictEqual(err, null)
+				assert.ok(loaded, 'should return refreshed token')
+				assert.strictEqual(loaded.id_token, 'new-id-token')
+				assert.strictEqual(loaded.access_token, 'new-access-token')
+				assert.strictEqual(loaded.refresh_token, 'valid-refresh-token', 'original refresh_token preserved')
+				assert.ok(loaded.stored_at, 'stored_at should be set')
+			} finally {
+				restore_refresh()
+			}
+		})
+	})
+
+	it('saves refreshed tokens to disk after successful refresh', async () => {
+		await with_tmp(async (dir) => {
+			write_expired_token(dir)
+			mock_refresh(async () => [null, {
+				id_token: 'refreshed-on-disk',
+				access_token: 'new-access',
+				expires_in: 7200
+			}])
+			try {
+				await load_token()
+				const on_disk = JSON.parse(fs.readFileSync(creds_file(dir), 'utf-8'))
+				assert.strictEqual(on_disk.id_token, 'refreshed-on-disk')
+				assert.strictEqual(on_disk.refresh_token, 'valid-refresh-token', 'refresh_token preserved on disk')
+				assert.strictEqual(on_disk.expires_in, 7200)
+				assert.ok(on_disk.stored_at, 'stored_at should be updated on disk')
+			} finally {
+				restore_refresh()
+			}
+		})
+	})
+
+	it('preserves credentials file on transient refresh failure (NetworkError)', async () => {
+		await with_tmp(async (dir) => {
+			write_expired_token(dir)
+			mock_refresh(async () => [[new NetworkError('connection failed')], null])
+			try {
+				const [err, loaded] = await load_token()
+				assert.strictEqual(err, null)
+				assert.strictEqual(loaded, null, 'should return null on failed refresh')
+				assert.ok(fs.existsSync(creds_file(dir)), 'credentials file should be preserved for retry')
+				// Verify the refresh_token is still intact on disk
+				const on_disk = JSON.parse(fs.readFileSync(creds_file(dir), 'utf-8'))
+				assert.strictEqual(on_disk.refresh_token, 'valid-refresh-token')
+			} finally {
+				restore_refresh()
+			}
+		})
+	})
+
+	it('preserves credentials file on server error (ApiError)', async () => {
+		await with_tmp(async (dir) => {
+			write_expired_token(dir)
+			const { ApiError } = require('../utils/errors')
+			mock_refresh(async () => [[new ApiError('Internal server error', 500, 'INTERNAL_ERROR')], null])
+			try {
+				const [err, loaded] = await load_token()
+				assert.strictEqual(err, null)
+				assert.strictEqual(loaded, null)
+				assert.ok(fs.existsSync(creds_file(dir)), 'credentials file should be preserved on server error')
+			} finally {
+				restore_refresh()
+			}
+		})
+	})
+
+	it('deletes credentials file on permanent refresh failure (AuthError)', async () => {
+		await with_tmp(async (dir) => {
+			write_expired_token(dir)
+			mock_refresh(async () => [[new AuthError('token revoked')], null])
+			try {
+				const [err, loaded] = await load_token()
+				assert.strictEqual(err, null)
+				assert.strictEqual(loaded, null)
+				assert.ok(!fs.existsSync(creds_file(dir)), 'credentials file should be deleted on permanent failure')
+			} finally {
+				restore_refresh()
+			}
+		})
+	})
+
+	it('does not retry on permanent failure', async () => {
+		await with_tmp(async (dir) => {
+			write_expired_token(dir)
+			let call_count = 0
+			mock_refresh(async () => {
+				call_count++
+				return [[new AuthError('token expired')], null]
+			})
+			try {
+				await load_token()
+				assert.strictEqual(call_count, 1, 'should not retry on permanent failure')
+			} finally {
+				restore_refresh()
+			}
+		})
+	})
+
+	it('retries once on transient failure then succeeds', async () => {
+		await with_tmp(async (dir) => {
+			write_expired_token(dir)
+			let call_count = 0
+			mock_refresh(async () => {
+				call_count++
+				if (call_count === 1) return [[new NetworkError('cold start')], null]
+				return [null, {
+					id_token: 'retried-id-token',
+					access_token: 'retried-access-token',
+					expires_in: 3600
+				}]
+			})
+			try {
+				const [err, loaded] = await load_token()
+				assert.strictEqual(err, null)
+				assert.ok(loaded, 'should return refreshed token after retry')
+				assert.strictEqual(loaded.id_token, 'retried-id-token')
+				assert.strictEqual(call_count, 2, 'refresh should have been called twice')
+			} finally {
+				restore_refresh()
+			}
+		})
+	})
+
+	it('retries once on transient failure then gives up', async () => {
+		await with_tmp(async (dir) => {
+			write_expired_token(dir)
+			let call_count = 0
+			mock_refresh(async () => {
+				call_count++
+				return [[new NetworkError('still failing')], null]
+			})
+			try {
+				const [err, loaded] = await load_token()
+				assert.strictEqual(err, null)
+				assert.strictEqual(loaded, null)
+				assert.strictEqual(call_count, 2, 'should have retried once')
+				assert.ok(fs.existsSync(creds_file(dir)), 'credentials file preserved after exhausting retries')
+			} finally {
+				restore_refresh()
+			}
+		})
+	})
+})

package/src/commands/disable.js

@@ -0,0 +1,105 @@
+const { error: { catch_errors, wrap_errors: e } } = require('puffy-core')
+const { read_lock, get_all_locked_skills } = require('../lock/reader')
+const { find_project_root, lock_root, skills_dir, skill_install_dir } = require('../config/paths')
+const { resolve_agents, unlink_from_agents } = require('../agents')
+const { is_skill_enabled } = require('../agents/status')
+const { file_exists } = require('../utils/fs')
+const { print_help, print_json, print_success, print_warn, print_info } = require('../ui/output')
+const { exit_with_error, UsageError } = require('../utils/errors')
+const { EXIT_CODES } = require('../constants')
+
+const HELP_TEXT = `Usage: happyskills disable <skill> [skill2 ...] [options]
+
+Disable one or more skills by removing their agent symlinks.
+The skill files remain in .agents/skills/ and can be re-enabled at any time.
+
+Arguments:
+  skill             One or more skill names (owner/name or short name)
+
+Options:
+  -g, --global      Target globally installed skills
+  --agents <list>   Target specific agents (comma-separated)
+  --json            Output as JSON
+
+Examples:
+  happyskills disable acme/deploy-aws
+  happyskills disable deploy-aws monitoring
+  happyskills disable acme/deploy-aws acme/monitoring -g`
+
+/**
+ * Resolve a skill argument (owner/name or short name) to its full lock key and short name.
+ */
+const resolve_skill_name = (arg, locked_skills) => {
+	if (arg.includes('/')) {
+		const short = arg.split('/')[1]
+		return locked_skills[arg] ? { full: arg, short } : null
+	}
+	// Search by short name
+	for (const key of Object.keys(locked_skills)) {
+		if (key.split('/')[1] === arg) {
+			return { full: key, short: arg }
+		}
+	}
+	return null
+}
+
+const run = (args) => catch_errors('Disable failed', async () => {
+	if (args.flags._show_help) {
+		print_help(HELP_TEXT)
+		return process.exit(EXIT_CODES.SUCCESS)
+	}
+
+	const skills_args = args._
+	if (skills_args.length === 0) {
+		throw new UsageError('Please specify one or more skills to disable (e.g., happyskills disable acme/deploy-aws).')
+	}
+
+	const is_global = args.flags.global || false
+	const project_root = find_project_root()
+
+	const [agents_err, agents_result] = await resolve_agents(args.flags.agents)
+	if (agents_err) throw e('Agent resolution failed', agents_err)
+	const { agents } = agents_result
+
+	const [, lock_data] = await read_lock(lock_root(is_global, project_root))
+	const locked_skills = get_all_locked_skills(lock_data)
+
+	const results = []
+
+	for (const arg of skills_args) {
+		const resolved = resolve_skill_name(arg, locked_skills)
+
+		if (!resolved) {
+			print_warn(`${arg} is not a HappySkills-managed skill — skipping`)
+			results.push({ skill: arg, status: 'not_found' })
+			continue
+		}
+
+		const { full, short } = resolved
+
+		// Check if already disabled
+		const [, enabled] = await is_skill_enabled(short, agents, is_global, project_root)
+		if (!enabled) {
+			print_warn(`${full} is already disabled`)
+			results.push({ skill: full, status: 'already_disabled' })
+			continue
+		}
+
+		// Remove symlinks from all agent folders
+		const [link_err] = await unlink_from_agents(short, agents, { global: is_global, project_root })
+		if (link_err) {
+			print_warn(`Failed to disable ${full}`)
+			results.push({ skill: full, status: 'error', message: link_err[0]?.message })
+			continue
+		}
+
+		print_success(`Disabled ${full}`)
+		results.push({ skill: full, status: 'disabled' })
+	}
+
+	if (args.flags.json) {
+		print_json({ data: { results } })
+	}
+}).then(([errors]) => { if (errors) { exit_with_error(errors); return } })
+
+module.exports = { run }

package/src/commands/enable.js

@@ -0,0 +1,114 @@
+const { error: { catch_errors, wrap_errors: e } } = require('puffy-core')
+const { read_lock, get_all_locked_skills } = require('../lock/reader')
+const { find_project_root, lock_root, skills_dir, skill_install_dir } = require('../config/paths')
+const { resolve_agents, link_to_agents } = require('../agents')
+const { is_skill_enabled } = require('../agents/status')
+const { file_exists } = require('../utils/fs')
+const { print_help, print_json, print_success, print_warn, print_info } = require('../ui/output')
+const { exit_with_error, UsageError } = require('../utils/errors')
+const { EXIT_CODES } = require('../constants')
+
+const HELP_TEXT = `Usage: happyskills enable <skill> [skill2 ...] [options]
+
+Enable one or more previously disabled skills by restoring their agent symlinks.
+
+Arguments:
+  skill             One or more skill names (owner/name or short name)
+
+Options:
+  -g, --global      Target globally installed skills
+  --agents <list>   Target specific agents (comma-separated)
+  --json            Output as JSON
+
+Examples:
+  happyskills enable acme/deploy-aws
+  happyskills enable deploy-aws monitoring
+  happyskills enable acme/deploy-aws acme/monitoring -g`
+
+/**
+ * Resolve a skill argument (owner/name or short name) to its full lock key and short name.
+ */
+const resolve_skill_name = (arg, locked_skills) => {
+	if (arg.includes('/')) {
+		const short = arg.split('/')[1]
+		return locked_skills[arg] ? { full: arg, short } : null
+	}
+	// Search by short name
+	for (const key of Object.keys(locked_skills)) {
+		if (key.split('/')[1] === arg) {
+			return { full: key, short: arg }
+		}
+	}
+	return null
+}
+
+const run = (args) => catch_errors('Enable failed', async () => {
+	if (args.flags._show_help) {
+		print_help(HELP_TEXT)
+		return process.exit(EXIT_CODES.SUCCESS)
+	}
+
+	const skills_args = args._
+	if (skills_args.length === 0) {
+		throw new UsageError('Please specify one or more skills to enable (e.g., happyskills enable acme/deploy-aws).')
+	}
+
+	const is_global = args.flags.global || false
+	const project_root = find_project_root()
+	const base_dir = skills_dir(is_global, project_root)
+
+	const [agents_err, agents_result] = await resolve_agents(args.flags.agents)
+	if (agents_err) throw e('Agent resolution failed', agents_err)
+	const { agents } = agents_result
+
+	const [, lock_data] = await read_lock(lock_root(is_global, project_root))
+	const locked_skills = get_all_locked_skills(lock_data)
+
+	const results = []
+
+	for (const arg of skills_args) {
+		const resolved = resolve_skill_name(arg, locked_skills)
+
+		if (!resolved) {
+			print_warn(`${arg} is not a HappySkills-managed skill — skipping`)
+			results.push({ skill: arg, status: 'not_found' })
+			continue
+		}
+
+		const { full, short } = resolved
+
+		// Verify the skill directory exists on disk
+		const dir = skill_install_dir(base_dir, short)
+		const [, exists] = await file_exists(dir)
+		if (!exists) {
+			print_warn(`${full} files not found on disk — run happyskills install to restore`)
+			results.push({ skill: full, status: 'missing' })
+			continue
+		}
+
+		// Check if already enabled
+		const [, enabled] = await is_skill_enabled(short, agents, is_global, project_root)
+		if (enabled) {
+			print_warn(`${full} is already enabled`)
+			results.push({ skill: full, status: 'already_enabled' })
+			continue
+		}
+
+		// Create symlinks to all agent folders
+		const [link_err] = await link_to_agents(dir, agents, { global: is_global, project_root, skill_name: short })
+		if (link_err) {
+			print_warn(`Failed to enable ${full}`)
+			results.push({ skill: full, status: 'error', message: link_err[0]?.message })
+			continue
+		}
+
+		print_success(`Enabled ${full}`)
+		results.push({ skill: full, status: 'enabled' })
+	}
+
+	if (args.flags.json) {
+		print_json({ data: { results } })
+	}
+}).then(([errors]) => { if (errors) { exit_with_error(errors); return } })
+
+module.exports = { run }

package/src/commands/list.js

@@ -4,7 +4,10 @@ const { skills_dir, skill_install_dir, find_project_root, lock_root } = require(
 const { file_exists, read_json } = require('../utils/fs')
 const { scan_skills_dir, scan_agent_orphan_skills } = require('../utils/skill_scanner')
 const { AGENTS } = require('../agents/registry')
+const { resolve_agents } = require('../agents/detector')
+const { get_skills_enabled_map } = require('../agents/status')
 const { print_help, print_table, print_json, print_info } = require('../ui/output')
+const { green, yellow } = require('../ui/colors')
 const { exit_with_error } = require('../utils/errors')
 const { EXIT_CODES, SKILL_JSON, SKILL_TYPES } = require('../constants')
 
@@ -37,8 +40,16 @@ const run = (args) => catch_errors('List failed', async () => {
 	const skills = get_all_locked_skills(lock_data)
 	const managed_entries = Object.entries(skills)
 
+	// Resolve agents and build enabled/disabled map for managed skills
+	const [, agents_result] = await resolve_agents(args.flags.agents)
+	const agents = agents_result?.agents || []
+	const managed_short_names = managed_entries.map(([k]) => k.split('/')[1])
+	const [, enabled_map] = agents.length > 0
+		? await get_skills_enabled_map(managed_short_names, agents, is_global, project_root)
+		: [null, new Map()]
+
 	const [, disk_skills] = await scan_skills_dir(base_dir)
-	const managed_names = new Set(managed_entries.map(([k]) => k.split('/')[1]))
+	const managed_names = new Set(managed_short_names)
 	const external_skills = (disk_skills || []).filter(s => !managed_names.has(s.name))
 
 	// Scan agent-specific dirs for skills placed directly in agent folders (not symlinked from .agents/skills/)
@@ -67,12 +78,14 @@ const run = (args) => catch_errors('List failed', async () => {
 	if (args.flags.json) {
 		const skills_map = {}
 		for (const [name, data] of managed_entries) {
-			const dir = skill_install_dir(base_dir, name.split('/')[1])
+			const short = name.split('/')[1]
+			const dir = skill_install_dir(base_dir, short)
 			const [, exists] = await file_exists(dir)
 			const status = exists ? 'installed' : 'missing'
 			const source = data.requested_by?.includes('__root__') ? 'direct' : 'dep'
 			const type = await resolve_type(name, data)
-			skills_map[name] = { version: data.version, type, source, status }
+			const enabled = enabled_map?.get(short) ?? true
+			skills_map[name] = { version: data.version, type, source, status, enabled }
 		}
 		const external = external_skills.map(s => ({ name: s.name, description: s.description || '' }))
 		const agent_orphan_list = orphan_skills.map(s => ({
@@ -86,25 +99,28 @@ const run = (args) => catch_errors('List failed', async () => {
 
 	const rows = []
 	for (const [name, data] of managed_entries) {
-		const dir = skill_install_dir(base_dir, name.split('/')[1])
+		const short = name.split('/')[1]
+		const dir = skill_install_dir(base_dir, short)
 		const [, exists] = await file_exists(dir)
 		const status = exists ? 'installed' : 'missing'
 		const source = data.requested_by?.includes('__root__') ? 'direct' : 'dep'
 		const type = await resolve_type(name, data)
 		const display_name = type === SKILL_TYPES.KIT ? `${name} [kit]` : name
-		rows.push([display_name, data.version, source, status])
+		const enabled = enabled_map?.get(short) ?? true
+		const enabled_label = enabled ? green('enabled') : yellow('disabled')
+		rows.push([display_name, data.version, source, status, enabled_label])
 	}
 
 	for (const s of external_skills) {
-		rows.push([s.name, '-', 'external', 'installed'])
+		rows.push([s.name, '-', 'external', 'installed', '-'])
 	}
 
 	for (const s of orphan_skills) {
 		const agent_label = s.agents.map(a => a.name).join(', ')
-		rows.push([s.name, '-', `agent-orphan (${agent_label})`, 'installed'])
+		rows.push([s.name, '-', `agent-orphan (${agent_label})`, 'installed', '-'])
 	}
 
-	print_table(['Skill', 'Version', 'Source', 'Status'], rows)
+	print_table(['Skill', 'Version', 'Source', 'Status', 'Enabled'], rows)
 }).then(([errors]) => { if (errors) { exit_with_error(errors); return } })
 
 module.exports = { run }

package/src/constants.js

@@ -38,7 +38,9 @@ const COMMAND_ALIASES = {
 	v: 'validate',
 	del: 'delete',
 	vis: 'visibility',
-	grp: 'groups'
+	grp: 'groups',
+	on: 'enable',
+	off: 'disable'
 }
 
 const COMMANDS = [
@@ -68,7 +70,9 @@ const COMMANDS = [
 	'config',
 	'people',
 	'groups',
-	'access'
+	'access',
+	'enable',
+	'disable'
 ]
 
 module.exports = {

package/src/engine/installer.js

@@ -12,6 +12,7 @@ const { skills_dir, tmp_dir, skill_install_dir, lock_root } = require('../config
 const { ensure_dir, remove_dir, file_exists, read_json } = require('../utils/fs')
 const { SKILL_JSON } = require('../constants')
 const { resolve_agents, link_to_agents } = require('../agents')
+const { is_skill_enabled } = require('../agents/status')
 const { create_spinner } = require('../ui/spinner')
 const { print_success, print_warn, print_info } = require('../ui/output')
 
@@ -95,6 +96,20 @@ const install = (skill, options = {}) => catch_errors('Install failed', async ()
 		return { skill, version: packages[0]?.version, no_op: true, installed: [], skipped, warnings: [], forced: [] }
 	}
 
+	// Capture disabled state before modifying disk — disabled skills stay disabled on update
+	const disabled_skills = new Set()
+	if (lock_data && agents.length > 0) {
+		await Promise.all(packages_to_install.map(async (pkg) => {
+			const name = pkg.skill.split('/')[1]
+			const dir = skill_install_dir(base_dir, name)
+			const [, exists] = await file_exists(dir)
+			if (exists) {
+				const [, enabled] = await is_skill_enabled(name, agents, is_global, project_root)
+				if (!enabled) disabled_skills.add(name)
+			}
+		}))
+	}
+
 	spinner.update(`Downloading ${packages_to_install.length} package(s)...`)
 
 	const [cleanup_err] = await remove_dir(temp_dir)
@@ -150,14 +165,23 @@ const install = (skill, options = {}) => catch_errors('Install failed', async ()
 		}
 
 		// Link to detected agents (non-fatal — warnings only)
+		// Skip linking for skills that were disabled before this install/update
 		if (agents.length > 0) {
-			spinner.update(`Linking to ${agents.length} agent(s)...`)
-			for (const { pkg } of downloaded) {
-				const name = pkg.skill.split('/')[1]
-				const source = skill_install_dir(base_dir, name)
-				const [link_errs] = await link_to_agents(source, agents, { global: is_global, project_root, skill_name: name })
-				if (link_errs) {
-					print_warn(`Warning: failed to link ${pkg.skill} to some agents`)
+			const to_link = downloaded.filter(({ pkg }) => !disabled_skills.has(pkg.skill.split('/')[1]))
+			if (to_link.length > 0) {
+				spinner.update(`Linking to ${agents.length} agent(s)...`)
+				for (const { pkg } of to_link) {
+					const name = pkg.skill.split('/')[1]
+					const source = skill_install_dir(base_dir, name)
+					const [link_errs] = await link_to_agents(source, agents, { global: is_global, project_root, skill_name: name })
+					if (link_errs) {
+						print_warn(`Warning: failed to link ${pkg.skill} to some agents`)
+					}
+				}
+			}
+			if (disabled_skills.size > 0) {
+				for (const name of disabled_skills) {
+					print_info(`${name} remains disabled — use happyskills enable to re-enable`)
 				}
 			}
 		}
@@ -196,7 +220,8 @@ const install = (skill, options = {}) => catch_errors('Install failed', async ()
 
 		spinner.succeed(`Installed ${packages_to_install.length} package(s)`)
 
-		if (agents.length > 0) {
+		const linked_count = downloaded.length - disabled_skills.size
+		if (agents.length > 0 && linked_count > 0) {
 			print_info(`Linked to: ${agents.map(a => a.display_name).join(', ')}`)
 		}
 

package/src/index.js

@@ -105,6 +105,8 @@ Commands:
   people <sub>             Manage workspace members (list, add, remove, role, search)
   groups <sub>             Manage workspace groups (list, create, delete, show, add, remove, default)
   access <sub>             Manage group skill access (list, grant, revoke, set)
+  enable <skill> [...]     Enable disabled skills (alias: on)
+  disable <skill> [...]    Disable skills without uninstalling (alias: off)
   login                    Authenticate with the registry
   logout                   Clear stored credentials
   whoami                   Show current user