Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

37.3 KB
Raw Blame
// /skills/community: browse the community skills registry, preview a skill's
// full SKILL.md, import it onto one of your agents, and manage every custom
// skill on an agent (enable, edit, update from the registry, delete) against
// the agent's prompt budget.
//
// Data:
//   GET  /api/skills/community                      registry (public)
//   GET  /api/skills/community/:slug                one skill + SKILL.md (public)
//   GET  /api/auth/me                               session
//   GET  /api/agents                                the viewer's agents
//   *    /api/agents/:id/custom-skills[/:skillId]   the agent's skills + budget
//
// URL state (shareable, restored on load): ?q= &tag= &author= &skill=<slug>
// &view=mine &agent=<id>.

import { apiFetch, noteSession } from './api.js';
import { renderMarkdown } from './shared/markdown.js';

const $ = (id) => document.getElementById(id);
const MAX_CONTENT = 24000;

const state = {
	registry: null,
	details: new Map(),
	q: '',
	tag: '',
	author: '',
	view: 'browse',
	user: undefined,
	agents: null,
	agentId: '',
	installed: null,
	openSlug: null,
	editing: null,
};

// ── helpers ────────────────────────────────────────────────────────────────

function esc(s) {
	return String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
}

function announce(msg) {
	const live = $('sc-live');
	live.textContent = '';
	requestAnimationFrame(() => { live.textContent = msg; });
}

function fmtTokens(n) {
	return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
}

async function readJson(res) {
	const body = await res.json().catch(() => null);
	if (!res.ok) {
		const err = new Error(body?.error_description || body?.error?.message || `Request failed (${res.status})`);
		err.status = res.status;
		err.code = body?.error;
		err.body = body;
		throw err;
	}
	return body;
}

function loginHref() {
	return `/login?next=${encodeURIComponent(location.pathname + location.search)}`;
}

function syncUrl() {
	const p = new URLSearchParams();
	if (state.q) p.set('q', state.q);
	if (state.tag) p.set('tag', state.tag);
	if (state.author) p.set('author', state.author);
	if (state.openSlug) p.set('skill', state.openSlug);
	if (state.view === 'mine') p.set('view', 'mine');
	if (state.view === 'mine' && state.agentId) p.set('agent', state.agentId);
	const qs = p.toString();
	history.replaceState(null, '', `${location.pathname}${qs ? `?${qs}` : ''}`);
}

function stateBlock({ title, body, actions = '' , tone = '' }) {
	return `<div class="sc-state ${tone ? `sc-state-${tone}` : ''}" role="${tone === 'error' ? 'alert' : 'status'}">
		<h3 class="sc-state-title">${title}</h3>
		<p class="sc-state-body">${body}</p>
		${actions ? `<div class="sc-ctas">${actions}</div>` : ''}
	</div>`;
}

// ── session + agents (shared by import and manager) ───────────────────────

async function loadSession() {
	if (state.user !== undefined) return state.user;
	try {
		const body = await readJson(await apiFetch('/api/auth/me', { allowAnonymous: true }));
		state.user = body?.user || null;
	} catch {
		state.user = null;
	}
	noteSession(Boolean(state.user));
	return state.user;
}

async function loadAgents() {
	if (state.agents) return state.agents;
	const body = await readJson(await apiFetch('/api/agents'));
	state.agents = (body?.agents || []).map((a) => ({ id: a.id, name: a.name || 'Untitled agent' }));
	return state.agents;
}

// ── browse ─────────────────────────────────────────────────────────────────

function renderSkeleton() {
	$('sc-grid').innerHTML = Array.from({ length: 6 }, () => '<div class="sc-card sc-skeleton" aria-hidden="true"><span></span><span></span><span></span></div>').join('');
}

async function loadRegistry() {
	renderSkeleton();
	$('sc-browse-state').innerHTML = '';
	try {
		state.registry = await readJson(await apiFetch('/api/skills/community?limit=500', { allowAnonymous: true }));
	} catch (err) {
		$('sc-grid').innerHTML = '';
		$('sc-grid').setAttribute('aria-busy', 'false');
		$('sc-browse-state').innerHTML = stateBlock({
			tone: 'error',
			title: 'The registry did not load',
			body: `${esc(err.message)}. Your connection or our API hiccuped; nothing was changed.`,
			actions: '<button type="button" class="sc-btn sc-btn-primary" data-action="retry-registry">Try again</button>',
		});
		return;
	}
	renderStats();
	renderFilters();
	renderGrid();
}

function renderStats() {
	const r = state.registry;
	const scripts = r.skills.filter((s) => s.files.some((f) => f.startsWith('scripts/'))).length;
	$('sc-stats').innerHTML = [
		[r.total, r.total === 1 ? 'skill' : 'skills'],
		[r.tags.length, 'tags'],
		[r.authors.length, r.authors.length === 1 ? 'author' : 'authors'],
		[scripts, 'with runnable scripts'],
	].map(([n, label]) => `<div><dt>${esc(label)}</dt><dd>${n}</dd></div>`).join('');
}

function renderFilters() {
	const r = state.registry;
	const chips = [{ tag: '', count: r.total, label: 'All' }, ...r.tags.map((t) => ({ ...t, label: t.tag }))];
	$('sc-tags').innerHTML = chips
		.map((c) => `<button type="button" class="sc-chip${state.tag === c.tag ? ' is-active' : ''}" data-tag="${esc(c.tag)}" aria-pressed="${state.tag === c.tag}">${esc(c.label)} <span class="sc-chip-count">${c.count}</span></button>`)
		.join('');
	const sel = $('sc-author');
	sel.innerHTML = `<option value="">All authors</option>${r.authors.map((a) => `<option value="${esc(a)}">${esc(a)}</option>`).join('')}`;
	sel.value = r.authors.includes(state.author) ? state.author : '';
}

function matches(s) {
	if (state.tag && !s.tags.includes(state.tag)) return false;
	if (state.author && s.author !== state.author) return false;
	if (!state.q) return true;
	const hay = `${s.slug} ${s.name} ${s.description} ${s.tags.join(' ')} ${s.author}`.toLowerCase();
	return state.q.toLowerCase().split(/\s+/).filter(Boolean).every((w) => hay.includes(w));
}

function cardHtml(s) {
	const hasScripts = s.files.some((f) => f.startsWith('scripts/'));
	return `<article class="sc-card">
		<button type="button" class="sc-card-hit" data-open="${esc(s.slug)}" aria-label="Preview ${esc(s.name)}"></button>
		<header class="sc-card-head">
			<h3 class="sc-card-title">${esc(s.name)}</h3>
			<span class="sc-card-version">v${esc(s.version)}</span>
		</header>
		<p class="sc-card-desc">${esc(s.description)}</p>
		<ul class="sc-card-tags">${s.tags.map((t) => `<li>${esc(t)}</li>`).join('')}</ul>
		<footer class="sc-card-foot">
			<span>by ${esc(s.author)}</span>
			<span title="Approximate prompt size">~${fmtTokens(s.tokens)} tokens</span>
			${hasScripts ? '<span class="sc-badge">scripts</span>' : ''}
		</footer>
	</article>`;
}

function renderGrid() {
	const grid = $('sc-grid');
	const list = state.registry.skills.filter(matches);
	grid.setAttribute('aria-busy', 'false');
	grid.innerHTML = list.map(cardHtml).join('');
	$('sc-browse-state').innerHTML = list.length
		? ''
		: stateBlock({
				title: 'No skills match',
				body: `Nothing in the registry matches${state.q ? ` "${esc(state.q)}"` : ''}${state.tag ? ` tagged ${esc(state.tag)}` : ''}${state.author ? ` by ${esc(state.author)}` : ''}. Clear the filters, or write the skill yourself and contribute it.`,
				actions: '<button type="button" class="sc-btn sc-btn-primary" data-action="clear-filters">Clear filters</button><a class="sc-btn" href="https://github.com/nirholas/three.ws/blob/main/community-skills/CONTRIBUTING.md" rel="noopener">Contribute a skill</a>',
			});
	announce(`${list.length} of ${state.registry.total} skills shown`);
	renderExternal();
}

// ── external skills (operator-pinned third-party repositories) ───────────

function matchesExternal(s) {
	if (state.tag && !s.tags.includes(state.tag)) return false;
	if (state.author && s.author !== state.author) return false;
	if (!state.q) return true;
	const hay = `${s.slug} ${s.name} ${s.description} ${s.tags.join(' ')} ${s.author} ${s.source}`.toLowerCase();
	return state.q.toLowerCase().split(/\s+/).filter(Boolean).every((w) => hay.includes(w));
}

function externalCardHtml(s) {
	return `<article class="sc-card">
		<button type="button" class="sc-card-hit" data-open="${esc(s.slug)}" aria-label="Preview ${esc(s.name)} (external, not reviewed by three.ws)"></button>
		<header class="sc-card-head">
			<h3 class="sc-card-title">${esc(s.name)}</h3>
			<span class="sc-badge sc-badge-external">External</span>
		</header>
		<p class="sc-card-desc">${esc(s.description)}</p>
		<p class="sc-card-source">Not reviewed by three.ws. From <a href="${esc(s.tree_url)}" rel="noopener noreferrer" target="_blank">${esc(s.source)} @ ${esc(s.ref.slice(0, 7))}</a>, ${esc(s.license)}</p>
		<footer class="sc-card-foot">
			<span title="Approximate prompt size">~${fmtTokens(s.tokens)} tokens</span>
		</footer>
	</article>`;
}

function renderExternal() {
	const ext = state.registry?.external;
	const section = $('sc-external');
	if (!ext) {
		section.hidden = true;
		return;
	}
	section.hidden = false;
	const list = ext.skills.filter(matchesExternal);
	$('sc-external-grid').innerHTML = list.length
		? list.map(externalCardHtml).join('')
		: stateBlock({
				title: ext.total ? 'No external skills match' : 'No external skills loaded',
				body: ext.total ? 'Clear the filters to see every external skill.' : 'The listed external sources returned no valid skills right now. The reviewed registry above is unaffected.',
			});
	const failed = ext.sources.filter((src) => !src.loaded);
	$('sc-external-sources').innerHTML =
		`Sources: ${ext.sources.map((src) => `<a href="${esc(src.url)}" rel="noopener noreferrer" target="_blank">${esc(src.repo)} @ ${esc(src.ref.slice(0, 7))}</a> (${esc(src.license)})`).join(', ')}.` +
		(failed.length ? ` ${failed.length} source${failed.length === 1 ? '' : 's'} could not be reached and ${failed.length === 1 ? 'is' : 'are'} skipped for now.` : '');
}

async function scanExternal(skill, agentId) {
	const note = $('sc-import-note');
	const btn = $('sc-import-go');
	btn.disabled = true;
	btn.textContent = 'Scanning…';
	note.className = 'sc-import-note';
	try {
		const { data } = await readJson(await apiFetch('/api/skill-imports/scan', {
			method: 'POST',
			headers: { 'content-type': 'application/json' },
			body: JSON.stringify({ agent_id: agentId, registry: skill.import.registry, skill: skill.import.skill }),
		}));
		const req = data.request;
		if (req.verdict === 'refused') {
			note.classList.add('is-error');
			note.textContent = 'The scan refused this skill, so it cannot be installed.';
			btn.textContent = 'Scan and review';
			btn.disabled = false;
			return;
		}
		note.classList.add(req.gated ? 'is-warn' : 'is-ok');
		note.innerHTML = `Scanned at commit ${esc(skill.ref.slice(0, 7))}: ${esc(req.verdict)}.${req.gated ? ' It asks to spend, sign or send messages and would stay under the spend gate.' : ''}
			<span class="sc-ctas"><button type="button" class="sc-btn sc-btn-primary" data-approve="${esc(req.id)}" data-gated="${req.gated ? '1' : ''}">Approve and install</button><button type="button" class="sc-btn" data-refuse="${esc(req.id)}">Cancel</button></span>`;
		btn.textContent = 'Scan again';
		btn.disabled = false;
	} catch (err) {
		note.classList.add('is-error');
		note.textContent = err.message;
		btn.textContent = 'Scan and review';
		btn.disabled = false;
	}
}

async function decideExternal(requestId, decision, gated) {
	const note = $('sc-import-note');
	note.className = 'sc-import-note';
	try {
		const { data } = await readJson(await apiFetch(`/api/skill-imports/requests/${encodeURIComponent(requestId)}`, {
			method: 'POST',
			headers: { 'content-type': 'application/json' },
			body: JSON.stringify({ decision, acknowledge_gated: Boolean(gated) }),
		}));
		if (decision === 'refuse') {
			note.textContent = 'Cancelled. Nothing was installed.';
			return;
		}
		note.classList.add(data.skill?.injected ? 'is-ok' : 'is-warn');
		note.textContent = data.skill?.injected ? 'Installed. Your agent follows it from its next reply.' : 'Installed, but it is disabled or over the agent\'s token budget.';
	} catch (err) {
		note.classList.add(err.code === 'already_installed' ? 'is-warn' : 'is-error');
		note.textContent = err.code === 'already_installed' ? 'This agent already has this skill.' : err.message;
	}
}

// ── preview + import ──────────────────────────────────────────────────────

async function skillDetail(slug) {
	if (state.details.has(slug)) return state.details.get(slug);
	const { skill } = await readJson(await apiFetch(`/api/skills/community/${encodeURIComponent(slug)}`, { allowAnonymous: true }));
	state.details.set(slug, skill);
	return skill;
}

async function openPreview(slug) {
	const dlg = $('sc-preview');
	state.openSlug = slug;
	syncUrl();
	$('sc-preview-kicker').textContent = 'Loading…';
	$('sc-preview-title').textContent = slug;
	$('sc-preview-desc').textContent = '';
	$('sc-preview-meta').innerHTML = '';
	$('sc-import').innerHTML = '';
	$('sc-preview-body').innerHTML = '<div class="sc-md-skeleton" aria-hidden="true"><span></span><span></span><span></span><span></span></div>';
	if (!dlg.open) dlg.showModal();
	let skill;
	try {
		skill = await skillDetail(slug);
	} catch (err) {
		$('sc-preview-kicker').textContent = '';
		$('sc-preview-body').innerHTML = stateBlock({
			tone: 'error',
			title: err.status === 404 ? 'That skill is not in the registry' : 'The skill did not load',
			body: err.status === 404 ? 'It may have been renamed or removed. Browse the registry for the current list.' : esc(err.message),
			actions: err.status === 404 ? '' : `<button type="button" class="sc-btn sc-btn-primary" data-open="${esc(slug)}">Try again</button>`,
		});
		return;
	}
	if (state.openSlug !== slug) return;
	const external = skill.origin === 'external';
	$('sc-preview-kicker').textContent = external ? `${skill.slug} · external, not reviewed by three.ws` : `${skill.slug} · v${skill.version}`;
	$('sc-preview-title').textContent = skill.name;
	$('sc-preview-desc').textContent = skill.description;
	const files = [...(skill.scripts || []), ...(skill.references || [])];
	$('sc-preview-meta').innerHTML = `
		<span class="sc-meta">by <strong>${esc(skill.author)}</strong></span>
		<span class="sc-meta">${esc(skill.license)}</span>
		${external ? `<span class="sc-meta"><span class="sc-badge sc-badge-external">External</span> <a href="${esc(skill.tree_url)}" rel="noopener noreferrer" target="_blank">${esc(skill.source)} @ ${esc(skill.ref.slice(0, 7))}</a></span>` : ''}
		<span class="sc-meta" title="Counted against the agent's prompt budget">~${fmtTokens(skill.tokens)} tokens</span>
		${files.length ? `<span class="sc-meta">${files.map((f) => `<code>${esc(f)}</code>`).join(' ')}</span>` : ''}
		<span class="sc-meta-actions">
			<button type="button" class="sc-btn sc-btn-sm" data-action="copy-skill">Copy SKILL.md</button>
			<a class="sc-btn sc-btn-sm" href="/api/skills/community/${esc(skill.slug)}?format=md" download="${esc(skill.slug)}-SKILL.md">Download</a>
			<a class="sc-btn sc-btn-sm" href="${esc(skill.source_url)}" rel="noopener" target="_blank">Source</a>
		</span>`;
	$('sc-preview-body').innerHTML = renderMarkdown(skill.body, { demoteHeadings: 1 });
	renderImport(skill);
}

function closePreview() {
	const dlg = $('sc-preview');
	if (dlg.open) dlg.close();
}

async function renderImport(skill) {
	const box = $('sc-import');
	box.innerHTML = '<div class="sc-import-row"><span class="sc-spinner" aria-hidden="true"></span> Checking your agents…</div>';
	const user = await loadSession();
	if (state.openSlug !== skill.slug) return;
	if (!user) {
		box.innerHTML = `<div class="sc-import-row"><span>Sign in to import this skill onto one of your agents.</span><a class="sc-btn sc-btn-primary" href="${loginHref()}">Sign in to import</a></div>`;
		return;
	}
	let agents;
	try {
		agents = await loadAgents();
	} catch (err) {
		box.innerHTML = `<div class="sc-import-row sc-import-error"><span>Your agents did not load: ${esc(err.message)}</span><button type="button" class="sc-btn" data-action="retry-import">Try again</button></div>`;
		return;
	}
	if (!agents.length) {
		box.innerHTML = `<div class="sc-import-row"><span>You do not have an agent yet. Create one, then come back to give it this skill.</span><a class="sc-btn sc-btn-primary" href="/create-agent">Create an agent</a></div>`;
		return;
	}
	const preselect = agents.some((a) => a.id === state.agentId) ? state.agentId : agents[0].id;
	const external = skill.origin === 'external';
	box.innerHTML = `<form class="sc-import-row" data-import="${esc(skill.slug)}">
		<label class="sr-only" for="sc-import-agent">Agent to import onto</label>
		<select class="sc-select" id="sc-import-agent">${agents.map((a) => `<option value="${esc(a.id)}"${a.id === preselect ? ' selected' : ''}>${esc(a.name)}</option>`).join('')}</select>
		<button type="submit" class="sc-btn sc-btn-primary" id="sc-import-go">${external ? 'Scan and review' : 'Import to agent'}</button>
	</form>
	<p class="sc-import-note" id="sc-import-note" role="status"></p>`;
}

async function doImport(slug, agentId) {
	const btn = $('sc-import-go');
	const note = $('sc-import-note');
	btn.disabled = true;
	btn.textContent = 'Importing…';
	note.className = 'sc-import-note';
	const agentName = state.agents.find((a) => a.id === agentId)?.name || 'your agent';
	const manage = `<a href="/skills/community?view=mine&agent=${esc(agentId)}" data-manage="${esc(agentId)}">Manage ${esc(agentName)}'s skills</a>`;
	try {
		const { data } = await readJson(await apiFetch(`/api/agents/${agentId}/custom-skills`, {
			method: 'POST',
			headers: { 'content-type': 'application/json' },
			body: JSON.stringify({ source: 'community', slug }),
		}));
		const { skill, budget } = data;
		if (skill.injected) {
			note.classList.add('is-ok');
			note.innerHTML = `Imported. ${esc(agentName)} follows it from its next reply (${budget.used_tokens.toLocaleString()} of ${budget.cap_tokens.toLocaleString()} tokens used). ${manage}`;
		} else {
			note.classList.add('is-warn');
			note.innerHTML = `Imported, but it does not fit ${esc(agentName)}'s ${budget.cap_tokens.toLocaleString()}-token budget, so it is not active yet. Turn another skill off to make room. ${manage}`;
		}
		announce(`${skill.name} imported onto ${agentName}`);
		if (state.agentId === agentId) state.installed = null;
	} catch (err) {
		note.classList.add(err.code === 'already_installed' ? 'is-warn' : 'is-error');
		note.innerHTML = err.code === 'already_installed'
			? `${esc(agentName)} already has this skill. ${manage}`
			: `${esc(err.message)}${err.code === 'limit_reached' ? ` ${manage}` : ''}`;
	} finally {
		btn.disabled = false;
		btn.textContent = 'Import to agent';
	}
}

async function copySkill() {
	const skill = state.details.get(state.openSlug);
	if (!skill) return;
	const btn = document.querySelector('[data-action="copy-skill"]');
	try {
		await navigator.clipboard.writeText(skill.content);
		btn.textContent = 'Copied';
	} catch {
		btn.textContent = 'Copy blocked';
	}
	setTimeout(() => { btn.textContent = 'Copy SKILL.md'; }, 1600);
}

// ── manager (your agents' skills) ─────────────────────────────────────────

async function showMine() {
	const gate = $('sc-mine-gate');
	const body = $('sc-mine-body');
	body.hidden = true;
	gate.innerHTML = '<div class="sc-installed-skeleton" aria-hidden="true"><span></span><span></span><span></span></div>';
	const user = await loadSession();
	if (!user) {
		gate.innerHTML = stateBlock({
			title: 'Sign in to manage your agents\' skills',
			body: 'Custom skills belong to an agent you own. Sign in to see what each of your agents has installed and how much of its prompt budget is in use.',
			actions: `<a class="sc-btn sc-btn-primary" href="${loginHref()}">Sign in</a>`,
		});
		return;
	}
	let agents;
	try {
		agents = await loadAgents();
	} catch (err) {
		gate.innerHTML = stateBlock({ tone: 'error', title: 'Your agents did not load', body: esc(err.message), actions: '<button type="button" class="sc-btn sc-btn-primary" data-action="retry-mine">Try again</button>' });
		return;
	}
	if (!agents.length) {
		gate.innerHTML = stateBlock({
			title: 'No agents yet',
			body: 'Skills are installed on an agent. Create your first agent, then import skills from the registry or write your own.',
			actions: '<a class="sc-btn sc-btn-primary" href="/create-agent">Create an agent</a><button type="button" class="sc-btn" data-view="browse">Browse skills</button>',
		});
		return;
	}
	gate.innerHTML = '';
	body.hidden = false;
	if (!agents.some((a) => a.id === state.agentId)) state.agentId = agents[0].id;
	$('sc-agent').innerHTML = agents.map((a) => `<option value="${esc(a.id)}">${esc(a.name)}</option>`).join('');
	$('sc-agent').value = state.agentId;
	syncUrl();
	await loadInstalled();
}

async function loadInstalled() {
	const list = $('sc-installed');
	list.innerHTML = '<li class="sc-installed-skeleton" aria-hidden="true"><span></span><span></span><span></span></li>';
	$('sc-budget').innerHTML = '';
	const agentId = state.agentId;
	try {
		const { data } = await readJson(await apiFetch(`/api/agents/${agentId}/custom-skills`));
		if (agentId !== state.agentId) return;
		state.installed = data;
		renderInstalled();
	} catch (err) {
		list.innerHTML = `<li>${stateBlock({ tone: 'error', title: 'This agent\'s skills did not load', body: esc(err.message), actions: '<button type="button" class="sc-btn sc-btn-primary" data-action="retry-installed">Try again</button>' })}</li>`;
	}
}

function renderBudget(budget, count) {
	const pct = Math.min(100, Math.round((budget.used_tokens / budget.cap_tokens) * 100));
	const over = budget.skipped_over_budget.length;
	const tone = over ? 'is-over' : pct >= 85 ? 'is-high' : '';
	$('sc-budget').innerHTML = `
		<div class="sc-budget-head">
			<span><strong>${budget.used_tokens.toLocaleString()}</strong> of ${budget.cap_tokens.toLocaleString()} prompt tokens in use</span>
			<span>${budget.injected_count} of ${count} skill${count === 1 ? '' : 's'} active</span>
		</div>
		<div class="sc-meter ${tone}" role="meter" aria-valuemin="0" aria-valuemax="${budget.cap_tokens}" aria-valuenow="${budget.used_tokens}" aria-label="Prompt budget used">
			<span style="transform: scaleX(${pct / 100})"></span>
		</div>
		<p class="sc-budget-note">${over
			? `${over} enabled skill${over === 1 ? ' does' : 's do'} not fit and ${over === 1 ? 'is' : 'are'} skipped. Skills load oldest first; turn one off to make room.`
			: 'Enabled skills load into the agent\'s prompt oldest first. A skill that would overflow the budget is skipped whole, never cut off.'}</p>`;
}

function installedHtml(s, i) {
	const status = s.injected
		? '<span class="sc-status is-on">Active</span>'
		: s.skip_reason === 'over_budget'
			? '<span class="sc-status is-over" title="Enabled, but it does not fit the prompt budget">Over budget</span>'
			: '<span class="sc-status">Off</span>';
	const update = s.registry?.update_available
		? `<button type="button" class="sc-btn sc-btn-sm" data-resync="${esc(s.id)}" title="Replace with the latest registry version ${esc(s.registry.latest_version)}">Update to v${esc(s.registry.latest_version)}</button>`
		: '';
	const origin = s.source === 'community'
		? `<a href="/skills/community?skill=${esc(s.source_slug)}" data-open="${esc(s.source_slug)}">from the registry</a>${s.registry?.removed ? ' (no longer listed)' : ''}`
		: s.source === 'external' && s.external
			? externalOrigin(s)
			: s.fork
				? `forked from ${esc(s.fork.slug || 'a skill')}${s.fork.license?.spdx ? ` · ${esc(s.fork.license.spdx)}` : ''}`
				: 'written by you';
	const gated = s.gated
		? '<span class="sc-status is-gated" title="This skill asked for spending, signing or outbound messaging. Any transfer it proposes is held until you ask for it yourself.">Spend gate</span>'
		: '';
	return `<li class="sc-item${s.enabled ? '' : ' is-disabled'}" data-id="${esc(s.id)}">
		<span class="sc-item-order" aria-hidden="true">${i + 1}</span>
		<div class="sc-item-main">
			<div class="sc-item-head">
				<h3 class="sc-item-title">${esc(s.name)}</h3>
				${status}
				${gated}
			</div>
			<p class="sc-item-meta">v${esc(s.version)} · ~${fmtTokens(s.tokens)} tokens · ${origin}</p>
			${s.description ? `<p class="sc-item-desc">${esc(s.description)}</p>` : ''}
		</div>
		<div class="sc-item-actions">
			<label class="sc-switch">
				<input type="checkbox" role="switch" data-toggle="${esc(s.id)}" ${s.enabled ? 'checked' : ''} aria-label="${s.enabled ? 'Disable' : 'Enable'} ${esc(s.name)}" />
				<span aria-hidden="true"></span>
			</label>
			${update}
			<button type="button" class="sc-btn sc-btn-sm" data-edit="${esc(s.id)}">Edit</button>
			<button type="button" class="sc-btn sc-btn-sm sc-btn-danger" data-delete="${esc(s.id)}">Delete</button>
		</div>
	</li>`;
}

/** Provenance line for a skill imported from an external registry. */
function externalOrigin(s) {
	const e = s.external;
	const pin = e.commit ? `@ ${esc(e.commit.slice(0, 7))}` : e.sha256 ? `sha256 ${esc(e.sha256.slice(0, 7))}` : '';
	const where = e.source_url ? `<a href="${esc(e.source_url)}" rel="noopener" target="_blank">${esc(e.registry?.label || 'external registry')}</a>` : esc(e.registry?.label || 'external registry');
	const manage = `<a href="/skills/import?view=installed&amp;agent=${esc(state.agentId)}">check for updates</a>`;
	return `from ${where} ${pin}${e.license?.spdx ? ` · ${esc(e.license.spdx)}` : ''}${e.locally_modified ? ' · edited locally' : ''} · ${manage}`;
}

function renderInstalled() {
	const { skills, budget } = state.installed;
	renderBudget(budget, skills.length);
	const list = $('sc-installed');
	if (!skills.length) {
		list.innerHTML = `<li>${stateBlock({
			title: 'No custom skills on this agent',
			body: 'Import one from the registry, or write your own instructions. They apply to this agent\'s very next reply.',
			actions: '<button type="button" class="sc-btn sc-btn-primary" data-view="browse">Browse the registry</button><button type="button" class="sc-btn" data-action="new-skill">Write a custom skill</button>',
		})}</li>`;
		return;
	}
	list.innerHTML = skills.map(installedHtml).join('');
}

async function mutate(path, init, { success }) {
	const res = await apiFetch(path, { headers: { 'content-type': 'application/json' }, ...init });
	const { data } = await readJson(res);
	state.installed = { skills: data.skills ?? state.installed.skills, budget: data.budget ?? state.installed.budget };
	if (!data.skills) await loadInstalled();
	else renderInstalled();
	if (success) announce(success);
	return data;
}

async function toggleSkill(id, enabled, input) {
	input.disabled = true;
	try {
		await mutate(`/api/agents/${state.agentId}/custom-skills/${id}`, { method: 'PATCH', body: JSON.stringify({ enabled }) }, { success: enabled ? 'Skill enabled' : 'Skill disabled' });
	} catch (err) {
		input.checked = !enabled;
		input.disabled = false;
		announce(`Could not update the skill: ${err.message}`);
		flashItemError(id, err.message);
	}
}

async function resyncSkill(id, btn) {
	btn.disabled = true;
	btn.textContent = 'Updating…';
	try {
		await mutate(`/api/agents/${state.agentId}/custom-skills/${id}`, { method: 'PATCH', body: JSON.stringify({ resync: true }) }, { success: 'Skill updated to the latest registry version' });
	} catch (err) {
		btn.disabled = false;
		btn.textContent = 'Retry update';
		flashItemError(id, err.message);
	}
}

// Delete is irreversible, so it takes two presses: the first arms the button
// for a few seconds and says so, the second deletes.
function armDelete(id, btn) {
	if (btn.dataset.armed === '1') return deleteSkill(id, btn);
	btn.dataset.armed = '1';
	btn.textContent = 'Press again to delete';
	btn.classList.add('is-armed');
	setTimeout(() => {
		if (!btn.isConnected || btn.dataset.armed !== '1') return;
		btn.dataset.armed = '';
		btn.textContent = 'Delete';
		btn.classList.remove('is-armed');
	}, 4000);
}

async function deleteSkill(id, btn) {
	btn.disabled = true;
	btn.textContent = 'Deleting…';
	try {
		await mutate(`/api/agents/${state.agentId}/custom-skills/${id}`, { method: 'DELETE' }, { success: 'Skill deleted' });
	} catch (err) {
		btn.disabled = false;
		btn.textContent = 'Delete';
		btn.dataset.armed = '';
		flashItemError(id, err.message);
	}
}

function flashItemError(id, message) {
	const item = document.querySelector(`.sc-item[data-id="${CSS.escape(id)}"]`);
	if (!item) return;
	item.querySelector('.sc-item-error')?.remove();
	item.querySelector('.sc-item-main').insertAdjacentHTML('beforeend', `<p class="sc-item-error" role="alert">${esc(message)}</p>`);
}

function bindCounter(textarea, counter) {
	const update = () => {
		const n = textarea.value.length;
		counter.textContent = `${n.toLocaleString()} / ${MAX_CONTENT.toLocaleString()} characters · ~${fmtTokens(Math.ceil(n / 4))} tokens`;
		counter.classList.toggle('is-high', n > MAX_CONTENT * 0.9);
	};
	textarea.addEventListener('input', update);
	update();
}

function toggleNewForm(open) {
	const form = $('sc-new');
	form.hidden = !open;
	$('sc-new-toggle').setAttribute('aria-expanded', String(open));
	$('sc-new-note').textContent = '';
	if (open) $('sc-new-name').focus();
}

async function submitNew(e) {
	e.preventDefault();
	const name = $('sc-new-name').value.trim();
	const content = $('sc-new-content').value.trim();
	const note = $('sc-new-note');
	note.className = 'sc-form-note';
	if (name.length < 2) { note.classList.add('is-error'); note.textContent = 'Give the skill a name of at least 2 characters.'; $('sc-new-name').focus(); return; }
	if (!content) { note.classList.add('is-error'); note.textContent = 'Write the instructions the agent should follow.'; $('sc-new-content').focus(); return; }
	const btn = $('sc-new-save');
	btn.disabled = true;
	btn.textContent = 'Saving…';
	try {
		const data = await mutate(`/api/agents/${state.agentId}/custom-skills`, {
			method: 'POST',
			body: JSON.stringify({ name, description: $('sc-new-desc').value.trim(), content }),
		}, { success: 'Custom skill saved' });
		$('sc-new').reset();
		bindCounter($('sc-new-content'), $('sc-new-count'));
		toggleNewForm(false);
		if (data.skill && !data.skill.injected && data.skill.skip_reason === 'over_budget') announce('Saved, but it does not fit the prompt budget yet');
	} catch (err) {
		note.classList.add('is-error');
		note.textContent = err.message;
	} finally {
		btn.disabled = false;
		btn.textContent = 'Save skill';
	}
}

function openEditor(id) {
	const skill = state.installed?.skills.find((s) => s.id === id);
	if (!skill) return;
	state.editing = id;
	$('sc-edit-name').value = skill.name;
	$('sc-edit-desc').value = skill.description || '';
	$('sc-edit-content').value = skill.content;
	$('sc-edit-note').textContent = '';
	$('sc-edit-title').textContent = `Edit ${skill.name}`;
	bindCounter($('sc-edit-content'), $('sc-edit-count'));
	$('sc-edit').showModal();
}

async function submitEdit(e) {
	e.preventDefault();
	const note = $('sc-edit-note');
	note.className = 'sc-form-note';
	const name = $('sc-edit-name').value.trim();
	const content = $('sc-edit-content').value.trim();
	if (name.length < 2 || !content) {
		note.classList.add('is-error');
		note.textContent = 'A skill needs a name of at least 2 characters and some instructions.';
		return;
	}
	const btn = $('sc-edit-save');
	btn.disabled = true;
	btn.textContent = 'Saving…';
	try {
		await mutate(`/api/agents/${state.agentId}/custom-skills/${state.editing}`, {
			method: 'PATCH',
			body: JSON.stringify({ name, description: $('sc-edit-desc').value.trim(), content }),
		}, { success: 'Skill saved' });
		$('sc-edit').close();
	} catch (err) {
		note.classList.add('is-error');
		note.textContent = err.message;
	} finally {
		btn.disabled = false;
		btn.textContent = 'Save changes';
	}
}

// ── view switching ────────────────────────────────────────────────────────

function setView(view) {
	state.view = view;
	for (const tab of document.querySelectorAll('.sc-tab')) {
		const active = tab.dataset.view === view;
		tab.classList.toggle('is-active', active);
		tab.setAttribute('aria-selected', String(active));
		tab.tabIndex = active ? 0 : -1;
	}
	$('sc-browse').hidden = view !== 'browse';
	$('sc-mine').hidden = view !== 'mine';
	syncUrl();
	if (view === 'mine') showMine();
}

// ── events ────────────────────────────────────────────────────────────────

function bind() {
	let searchTimer;
	$('sc-q').addEventListener('input', (e) => {
		clearTimeout(searchTimer);
		searchTimer = setTimeout(() => {
			state.q = e.target.value.trim();
			syncUrl();
			if (state.registry) renderGrid();
		}, 120);
	});
	$('sc-author').addEventListener('change', (e) => {
		state.author = e.target.value;
		syncUrl();
		renderGrid();
	});
	$('sc-agent').addEventListener('change', (e) => {
		state.agentId = e.target.value;
		syncUrl();
		loadInstalled();
	});
	$('sc-new-toggle').addEventListener('click', () => toggleNewForm($('sc-new').hidden));
	$('sc-new-cancel').addEventListener('click', () => toggleNewForm(false));
	$('sc-new').addEventListener('submit', submitNew);
	$('sc-edit-form').addEventListener('submit', submitEdit);
	$('sc-edit-close').addEventListener('click', () => $('sc-edit').close());
	$('sc-edit-cancel').addEventListener('click', () => $('sc-edit').close());
	$('sc-preview-close').addEventListener('click', closePreview);
	$('sc-preview').addEventListener('close', () => {
		state.openSlug = null;
		syncUrl();
	});
	for (const dlg of [$('sc-preview'), $('sc-edit')]) {
		// A click on the backdrop lands on the <dialog> itself.
		dlg.addEventListener('click', (e) => { if (e.target === dlg) dlg.close(); });
	}
	bindCounter($('sc-new-content'), $('sc-new-count'));

	// Keyboard: tabs move with arrow keys; "/" focuses search.
	$('sc-tab-browse').parentElement.addEventListener('keydown', (e) => {
		if (e.key !== 'ArrowRight' && e.key !== 'ArrowLeft') return;
		const next = state.view === 'browse' ? 'mine' : 'browse';
		setView(next);
		document.querySelector(`.sc-tab[data-view="${next}"]`).focus();
	});
	document.addEventListener('keydown', (e) => {
		if (e.key !== '/' || e.metaKey || e.ctrlKey || e.altKey) return;
		const t = e.target;
		if (t instanceof HTMLElement && (t.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName))) return;
		if (document.querySelector('dialog[open]')) return;
		e.preventDefault();
		if (state.view !== 'browse') setView('browse');
		$('sc-q').focus();
	});

	document.addEventListener('click', (e) => {
		const el = e.target.closest('[data-open],[data-tag],[data-view],[data-action],[data-edit],[data-delete],[data-resync],[data-manage],[data-approve],[data-refuse]');
		if (!el) return;
		if (el.dataset.approve) return void decideExternal(el.dataset.approve, 'approve', el.dataset.gated === '1');
		if (el.dataset.refuse) return void decideExternal(el.dataset.refuse, 'refuse', false);
		if (el.dataset.manage) {
			e.preventDefault();
			closePreview();
			state.agentId = el.dataset.manage;
			state.installed = null;
			setView('mine');
			return;
		}
		if (el.dataset.open) {
			e.preventDefault();
			openPreview(el.dataset.open);
		} else if (el.dataset.tag !== undefined) {
			state.tag = state.tag === el.dataset.tag ? '' : el.dataset.tag;
			syncUrl();
			renderFilters();
			renderGrid();
		} else if (el.dataset.view) {
			setView(el.dataset.view);
		} else if (el.dataset.edit) {
			openEditor(el.dataset.edit);
		} else if (el.dataset.delete) {
			armDelete(el.dataset.delete, el);
		} else if (el.dataset.resync) {
			resyncSkill(el.dataset.resync, el);
		} else {
			const action = el.dataset.action;
			if (action === 'retry-registry') loadRegistry();
			else if (action === 'clear-filters') {
				state.q = state.tag = state.author = '';
				$('sc-q').value = '';
				syncUrl();
				renderFilters();
				renderGrid();
			} else if (action === 'copy-skill') copySkill();
			else if (action === 'retry-import') renderImport(state.details.get(state.openSlug));
			else if (action === 'retry-mine') { state.agents = null; showMine(); }
			else if (action === 'retry-installed') loadInstalled();
			else if (action === 'new-skill') toggleNewForm(true);
		}
	});

	document.addEventListener('change', (e) => {
		const input = e.target.closest('[data-toggle]');
		if (input) toggleSkill(input.dataset.toggle, input.checked, input);
	});

	document.addEventListener('submit', (e) => {
		const form = e.target.closest('[data-import]');
		if (!form) return;
		e.preventDefault();
		const skill = state.details.get(form.dataset.import);
		if (skill?.origin === 'external') scanExternal(skill, $('sc-import-agent').value);
		else doImport(form.dataset.import, $('sc-import-agent').value);
	});
}

// ── boot ──────────────────────────────────────────────────────────────────

function readUrl() {
	const p = new URLSearchParams(location.search);
	state.q = (p.get('q') || '').trim();
	state.tag = (p.get('tag') || '').trim().toLowerCase();
	state.author = (p.get('author') || '').trim();
	state.agentId = p.get('agent') || '';
	$('sc-q').value = state.q;
	return { skill: p.get('skill'), view: p.get('view') === 'mine' || p.get('agent') ? 'mine' : 'browse' };
}

bind();
const initial = readUrl();
loadRegistry();
setView(initial.view);
if (initial.skill) openPreview(initial.skill);