@quadient/skillshare 0.1.0

package/README.md

@@ -0,0 +1,61 @@
+# Skillshare TUI
+
+Development CLI for the Skillshare registry.
+
+Examples:
+
+```bash
+bun run index.ts
+bun run index.ts login
+bun run index.ts login local
+bun run index.ts list
+bun run index.ts upload ./examples/prompt-lint --version 0.1.0
+bun run index.ts install 12 0.1.0 --target ./installed
+bun run index.ts install --skill-version-id 42 --target ./installed
+```
+
+Interactive behavior:
+
+- If the current directory already contains SKILL.md, the TUI offers to upload it before showing the main action picker.
+- After install or upload, the CLI writes skillshare.metadata.json into the skill directory with the skill id, name, description, and installed or published version.
+- When skillshare.metadata.json already exists, uploads publish a new version of that skill instead of creating a duplicate entry.
+- New skill creation derives name and description from SKILL.md frontmatter when available, so the user usually only needs to enter the initial version.
+- Upload and publish commands show progress while scanning and reading local files, then keep a timed upload status visible until the registry call finishes.
+
+Login opens a browser against the selected Skillshare host, exchanges the backend login code for CLI tokens, and stores the access token plus refresh token in the user config directory.
+
+Without an existing session, the CLI now defaults to the production registry. Use `login local` only when you want the local backend.
+
+Session storage paths:
+
+- macOS/Linux: `~/.config/skillshare/session.json`
+- Windows: `%APPDATA%\\skillshare\\session.json`
+
+## Package Distribution
+
+The CLI is prepared for publishing as `@quadient/skillshare`.
+
+Recommended invocation:
+
+```bash
+npx @quadient/skillshare
+bunx @quadient/skillshare
+```
+
+Packaging checks:
+
+```bash
+bunx tsc --noEmit
+npm run build
+npm pack --dry-run
+```
+
+Publishing from the repo root:
+
+```bash
+bun run publish:tui:dry-run
+bun run publish:tui
+bun run publish:tui -- --otp 123456
+```
+
+The publish script builds `tui/`, validates the packed files with `npm pack --dry-run`, and only then runs `npm publish`.

package/bin/skillshare

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js'

package/dist/index.js

@@ -0,0 +1,1252 @@
+import { createServer } from 'node:http';
+import { createHash, randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { cancel, confirm, intro, isCancel, multiselect, outro, progress, select, spinner, text } from '@clack/prompts';
+const PROD_URL = 'https://skillshare.inspireclouduat.net';
+const LOCAL_URL = 'http://localhost:5050';
+const APP_DIR = getAppDir();
+const SESSION_PATH = join(APP_DIR, 'session.json');
+const SKILL_FILE_NAME = 'SKILL.md';
+const SKILL_METADATA_FILE_NAME = 'skillshare.metadata.json';
+const UNIVERSAL_PROJECT_SKILLS_PATH = '.agents/skills';
+const UNIVERSAL_PROJECT_AGENT_VALUE = '__universal-project__';
+const AGENTS = [
+    { value: 'amp', label: 'Amp', projectPath: '.agents/skills', globalPath: '.config/agents/skills' },
+    { value: 'kimi-cli', label: 'Kimi Code CLI', projectPath: '.agents/skills', globalPath: '.config/agents/skills' },
+    { value: 'replit', label: 'Replit', projectPath: '.agents/skills', globalPath: '.config/agents/skills' },
+    { value: 'universal', label: 'Universal', projectPath: '.agents/skills', globalPath: '.config/agents/skills' },
+    { value: 'antigravity', label: 'Antigravity', projectPath: '.agents/skills', globalPath: '.gemini/antigravity/skills' },
+    { value: 'augment', label: 'Augment', projectPath: '.augment/skills', globalPath: '.augment/skills' },
+    { value: 'bob', label: 'IBM Bob', projectPath: '.bob/skills', globalPath: '.bob/skills' },
+    { value: 'claude-code', label: 'Claude Code', projectPath: '.claude/skills', globalPath: '.claude/skills' },
+    { value: 'openclaw', label: 'OpenClaw', projectPath: 'skills', globalPath: '.openclaw/skills' },
+    { value: 'cline', label: 'Cline', projectPath: '.agents/skills', globalPath: '.agents/skills' },
+    { value: 'warp', label: 'Warp', projectPath: '.agents/skills', globalPath: '.agents/skills' },
+    { value: 'codebuddy', label: 'CodeBuddy', projectPath: '.codebuddy/skills', globalPath: '.codebuddy/skills' },
+    { value: 'codex', label: 'Codex', projectPath: '.agents/skills', globalPath: '.codex/skills' },
+    { value: 'command-code', label: 'Command Code', projectPath: '.commandcode/skills', globalPath: '.commandcode/skills' },
+    { value: 'continue', label: 'Continue', projectPath: '.continue/skills', globalPath: '.continue/skills' },
+    { value: 'cortex', label: 'Cortex Code', projectPath: '.cortex/skills', globalPath: '.snowflake/cortex/skills' },
+    { value: 'crush', label: 'Crush', projectPath: '.crush/skills', globalPath: '.config/crush/skills' },
+    { value: 'cursor', label: 'Cursor', projectPath: '.agents/skills', globalPath: '.cursor/skills' },
+    { value: 'deepagents', label: 'Deep Agents', projectPath: '.agents/skills', globalPath: '.deepagents/agent/skills' },
+    { value: 'droid', label: 'Droid', projectPath: '.factory/skills', globalPath: '.factory/skills' },
+    { value: 'firebender', label: 'Firebender', projectPath: '.agents/skills', globalPath: '.firebender/skills' },
+    { value: 'gemini-cli', label: 'Gemini CLI', projectPath: '.agents/skills', globalPath: '.gemini/skills' },
+    { value: 'github-copilot', label: 'GitHub Copilot', projectPath: '.agents/skills', globalPath: '.copilot/skills' },
+    { value: 'goose', label: 'Goose', projectPath: '.goose/skills', globalPath: '.config/goose/skills' },
+    { value: 'junie', label: 'Junie', projectPath: '.junie/skills', globalPath: '.junie/skills' },
+    { value: 'iflow-cli', label: 'iFlow CLI', projectPath: '.iflow/skills', globalPath: '.iflow/skills' },
+    { value: 'kilo', label: 'Kilo Code', projectPath: '.kilocode/skills', globalPath: '.kilocode/skills' },
+    { value: 'kiro-cli', label: 'Kiro CLI', projectPath: '.kiro/skills', globalPath: '.kiro/skills' },
+    { value: 'kode', label: 'Kode', projectPath: '.kode/skills', globalPath: '.kode/skills' },
+    { value: 'mcpjam', label: 'MCPJam', projectPath: '.mcpjam/skills', globalPath: '.mcpjam/skills' },
+    { value: 'mistral-vibe', label: 'Mistral Vibe', projectPath: '.vibe/skills', globalPath: '.vibe/skills' },
+    { value: 'mux', label: 'Mux', projectPath: '.mux/skills', globalPath: '.mux/skills' },
+    { value: 'opencode', label: 'OpenCode', projectPath: '.agents/skills', globalPath: '.config/opencode/skills' },
+    { value: 'openhands', label: 'OpenHands', projectPath: '.openhands/skills', globalPath: '.openhands/skills' },
+    { value: 'pi', label: 'Pi', projectPath: '.pi/skills', globalPath: '.pi/agent/skills' },
+    { value: 'qoder', label: 'Qoder', projectPath: '.qoder/skills', globalPath: '.qoder/skills' },
+    { value: 'qwen-code', label: 'Qwen Code', projectPath: '.qwen/skills', globalPath: '.qwen/skills' },
+    { value: 'roo', label: 'Roo Code', projectPath: '.roo/skills', globalPath: '.roo/skills' },
+    { value: 'trae', label: 'Trae', projectPath: '.trae/skills', globalPath: '.trae/skills' },
+    { value: 'trae-cn', label: 'Trae CN', projectPath: '.trae/skills', globalPath: '.trae-cn/skills' },
+    { value: 'windsurf', label: 'Windsurf', projectPath: '.windsurf/skills', globalPath: '.codeium/windsurf/skills' },
+    { value: 'zencoder', label: 'Zencoder', projectPath: '.zencoder/skills', globalPath: '.zencoder/skills' },
+    { value: 'neovate', label: 'Neovate', projectPath: '.neovate/skills', globalPath: '.neovate/skills' },
+    { value: 'pochi', label: 'Pochi', projectPath: '.pochi/skills', globalPath: '.pochi/skills' },
+    { value: 'adal', label: 'AdaL', projectPath: '.adal/skills', globalPath: '.adal/skills' },
+];
+const usage = `
+skillshare <command> [options]
+
+Commands:
+  login [local]
+  logout
+  whoami
+  list
+  show <skillId> [version]
+  upload <directory> --version <version> [--skill-id <id>] [--name <name> --description <desc>]
+  install <skillId> [version] --target <directory>
+  install --skill-version-id <id> --target <directory>
+
+Options:
+  --token <token>    Bearer token for API requests
+`;
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (!command) {
+        await runInteractive();
+        return;
+    }
+    if (command === '--help' || command === '-h') {
+        console.log(usage.trim());
+        process.exit(0);
+    }
+    const options = await parseOptions(args.slice(1));
+    switch (command) {
+        case 'login': {
+            await login(options.positionals[0] === 'local' ? LOCAL_URL : PROD_URL);
+            return;
+        }
+        case 'logout': {
+            await logoutSession();
+            return;
+        }
+        case 'whoami':
+        case 'list':
+        case 'show':
+        case 'upload':
+        case 'install': {
+            const client = await createClient(await resolveActiveBaseUrl(), options.token);
+            switch (command) {
+                case 'whoami': {
+                    const user = await client.get('/api/auth/me');
+                    console.log(JSON.stringify(user, null, 2));
+                    return;
+                }
+                case 'list': {
+                    const skills = await client.get('/api/skills');
+                    for (const skill of skills) {
+                        console.log(`${skill.id}\t${skill.latestVersion}\t${skill.name}`);
+                    }
+                    return;
+                }
+                case 'show': {
+                    const skillId = options.positionals[0];
+                    const version = options.positionals[1];
+                    if (!skillId) {
+                        throw new Error('show requires <skillId>');
+                    }
+                    const resource = version
+                        ? `/api/skills/${skillId}/versions/${version}`
+                        : `/api/skills/${skillId}`;
+                    const data = await client.get(resource);
+                    console.log(JSON.stringify(data, null, 2));
+                    return;
+                }
+                case 'upload': {
+                    const directory = options.positionals[0];
+                    const version = options.flags.version;
+                    if (!directory || !version) {
+                        throw new Error('upload requires <directory> --version <version>');
+                    }
+                    const localSkill = await loadLocalSkillContext(directory);
+                    const skillId = options.flags['skill-id']
+                        ? parsePositiveInteger(options.flags['skill-id'], '--skill-id')
+                        : localSkill.metadata?.skillId;
+                    if (!skillId) {
+                        const created = await createSkillFromDirectory(client, localSkill, {
+                            name: options.flags.name,
+                            description: options.flags.description,
+                            version,
+                        });
+                        console.log(JSON.stringify(created.response, null, 2));
+                    }
+                    else {
+                        const published = await publishSkillFromDirectory(client, localSkill, {
+                            skillId,
+                            version,
+                            failIfMissing: false,
+                        });
+                        console.log(JSON.stringify(published.response, null, 2));
+                    }
+                    return;
+                }
+                case 'install': {
+                    const skillVersionId = options.flags['skill-version-id'];
+                    const skillId = options.positionals[0];
+                    const version = options.positionals[1];
+                    const target = options.flags.target;
+                    if (skillVersionId) {
+                        if (!target) {
+                            throw new Error('install with --skill-version-id requires --target <directory>');
+                        }
+                        const parsedSkillVersionId = Number.parseInt(skillVersionId, 10);
+                        if (!Number.isFinite(parsedSkillVersionId) || parsedSkillVersionId <= 0) {
+                            throw new Error('--skill-version-id must be a positive number');
+                        }
+                        const detail = await client.get(`/api/skill-versions/${parsedSkillVersionId}`);
+                        const skill = await client.get(`/api/skills/${detail.skillId}`);
+                        await client.post(`/api/skills/${detail.skillId}/versions/${detail.version}/downloads`);
+                        await writeSkillVersionToDirectory(client, {
+                            skillId: detail.skillId,
+                            skillName: skill.name,
+                            skillDescription: skill.description,
+                            version: detail.version,
+                            files: detail.files,
+                            targetRoot: target,
+                        });
+                        console.log(`Installed skillVersion ${parsedSkillVersionId} (${detail.skillId}@${detail.version}) to ${target}`);
+                        return;
+                    }
+                    if (!skillId || !target) {
+                        throw new Error('install requires <skillId> [version] --target <directory> or --skill-version-id <id> --target <directory>');
+                    }
+                    const skill = await client.get(`/api/skills/${skillId}`);
+                    const effectiveVersion = version ?? skill.latestVersion;
+                    if (!effectiveVersion) {
+                        throw new Error(`Skill '${skillId}' does not have a published version.`);
+                    }
+                    const detail = await client.get(`/api/skills/${skillId}/versions/${effectiveVersion}`);
+                    await client.post(`/api/skills/${skillId}/versions/${effectiveVersion}/downloads`);
+                    await writeSkillVersionToDirectory(client, {
+                        skillId: skill.id,
+                        skillName: skill.name,
+                        skillDescription: skill.description,
+                        version: effectiveVersion,
+                        files: detail.files,
+                        targetRoot: target,
+                    });
+                    console.log(`Installed ${skillId}@${effectiveVersion} to ${target}`);
+                    return;
+                }
+            }
+            return;
+        }
+        default:
+            throw new Error(`Unknown command '${command}'`);
+    }
+}
+async function runInteractive() {
+    intro('Skillshare');
+    const baseUrl = await resolveActiveBaseUrl();
+    await ensureInteractiveLogin(baseUrl);
+    const client = await createClient(baseUrl);
+    if (existsSync(join(process.cwd(), SKILL_FILE_NAME))) {
+        const localMetadata = await readLocalSkillMetadata(process.cwd());
+        const shouldUploadCurrent = await promptConfirm(localMetadata
+            ? `Current directory contains ${SKILL_FILE_NAME}. Upload a new version of ${localMetadata.skillName || `skill ${localMetadata.skillId}`} now?`
+            : `Current directory contains ${SKILL_FILE_NAME}. Upload it now?`, true);
+        if (shouldUploadCurrent) {
+            await runInteractiveUpload(client, process.cwd());
+            outro('Done.');
+            return;
+        }
+    }
+    const action = await select({
+        message: 'What do you want to do?',
+        options: [
+            { value: 'install', label: 'Install a skill', hint: 'Browse registry and install to agents' },
+            { value: 'upload', label: 'Upload a skill', hint: 'Create a new skill or publish a version' },
+        ],
+    });
+    if (isCancel(action)) {
+        cancel('Cancelled.');
+        process.exit(0);
+    }
+    if (action === 'install') {
+        await runInteractiveInstall(client);
+    }
+    else {
+        await runInteractiveUpload(client);
+    }
+    outro('Done.');
+}
+async function ensureInteractiveLogin(baseUrl) {
+    const session = await loadSession(baseUrl);
+    if (!session) {
+        await login(baseUrl);
+        return;
+    }
+    if (new Date(session.refreshTokenExpiresAt).getTime() <= Date.now()) {
+        await login(baseUrl);
+        return;
+    }
+    try {
+        const client = await createClient(baseUrl);
+        await client.get('/api/auth/me');
+    }
+    catch {
+        await login(baseUrl);
+    }
+}
+async function runInteractiveInstall(client) {
+    const skills = await client.get('/api/skills');
+    if (skills.length === 0) {
+        throw new Error('No skills available in the registry.');
+    }
+    const skill = await promptForSkill(skills);
+    const detail = await client.get(`/api/skills/${skill.id}`);
+    const selectedVersion = await promptForVersion(detail);
+    const scope = await promptForInstallScope();
+    const selectedAgents = await promptForAgents(scope);
+    if (selectedAgents.length === 0) {
+        throw new Error('Select at least one agent.');
+    }
+    const versionDetail = await client.get(`/api/skills/${skill.id}/versions/${selectedVersion}`);
+    await client.post(`/api/skills/${skill.id}/versions/${selectedVersion}/downloads`);
+    const installName = createInstalledSkillDirectoryName(skill);
+    const installTargets = resolveInstallTargets(selectedAgents, scope, installName);
+    for (const installTarget of installTargets) {
+        await writeSkillVersionToDirectory(client, {
+            skillId: skill.id,
+            skillName: skill.name,
+            skillDescription: skill.description,
+            version: selectedVersion,
+            files: versionDetail.files,
+            targetRoot: installTarget.targetRoot,
+        });
+    }
+    console.log(`Installed ${skill.name}@${selectedVersion} to ${installTargets.length} location(s) for ${selectedAgents.length} agent(s) in ${scope} scope.`);
+}
+async function runInteractiveUpload(client, initialDirectory) {
+    const directory = initialDirectory
+        ?? await promptText('Skill directory', '.', `Enter the directory containing ${SKILL_FILE_NAME}`);
+    const localSkill = await loadLocalSkillContext(directory);
+    if (!localSkill.metadata?.skillId) {
+        const version = await promptText('Initial version', '0.1.0');
+        const created = await createSkillFromDirectory(client, localSkill, { version });
+        console.log(`Created skill ${created.detail.id}: ${created.detail.name}@${version}`);
+        return;
+    }
+    const skill = await client.get(`/api/skills/${localSkill.metadata.skillId}`);
+    const localVersion = normalizeText(localSkill.metadata.skillVersion);
+    const latestVersion = normalizeText(skill.latestVersion);
+    if (latestVersion && localVersion && latestVersion !== localVersion) {
+        const shouldDownloadLatest = await promptConfirm(`Local version is ${localVersion}, but the server latest is ${latestVersion}. Download it first? Local file changes will be overwritten.`, false);
+        if (shouldDownloadLatest) {
+            const latestDetail = await client.get(`/api/skills/${skill.id}/versions/${latestVersion}`);
+            await client.post(`/api/skills/${skill.id}/versions/${latestVersion}/downloads`);
+            await writeSkillVersionToDirectory(client, {
+                skillId: skill.id,
+                skillName: skill.name,
+                skillDescription: skill.description,
+                version: latestVersion,
+                files: latestDetail.files,
+                targetRoot: localSkill.directory,
+            });
+            console.log(`Downloaded ${skill.name}@${latestVersion} to ${localSkill.directory}`);
+            return;
+        }
+    }
+    const version = await promptText('New version');
+    const published = await publishSkillFromDirectory(client, localSkill, {
+        skillId: skill.id,
+        version,
+        failIfMissing: true,
+    });
+    console.log(`Published ${published.detail.name}@${published.response.version}`);
+}
+async function promptForSkill(skills) {
+    let query = '';
+    while (true) {
+        const queryValue = await text({
+            message: 'Search skills',
+            placeholder: query || 'Type part of the skill name or description',
+            defaultValue: query,
+            validate(value) {
+                if (!(value ?? '').trim()) {
+                    return 'Enter at least one search term.';
+                }
+            },
+        });
+        if (isCancel(queryValue)) {
+            cancel('Cancelled.');
+            process.exit(0);
+        }
+        query = queryValue.trim();
+        const filtered = filterSkills(skills, query).slice(0, 20);
+        if (filtered.length === 0) {
+            console.log(`No skills match "${query}". Try a different search.`);
+            continue;
+        }
+        const selected = await select({
+            message: 'Select a skill',
+            options: [
+                ...filtered.map((skill) => ({
+                    value: String(skill.id),
+                    label: `${skill.name}${skill.latestVersion ? ` (${skill.latestVersion})` : ''}`,
+                    hint: skill.description,
+                })),
+                { value: '__search_again__', label: 'Search again', hint: 'Change the filter query' },
+            ],
+        });
+        if (isCancel(selected)) {
+            cancel('Cancelled.');
+            process.exit(0);
+        }
+        if (selected === '__search_again__') {
+            continue;
+        }
+        const skill = skills.find((item) => String(item.id) === selected);
+        if (!skill) {
+            throw new Error('Selected skill was not found.');
+        }
+        return skill;
+    }
+}
+async function promptForVersion(detail) {
+    const selected = await select({
+        message: 'Select a version to install',
+        options: detail.versions.map((version) => ({
+            value: version.version,
+            label: `${version.version}${version.isLatest ? ' (latest)' : ''}`,
+            hint: `${new Date(version.created).toLocaleString()} · ${version.files.length} files`,
+        })),
+    });
+    if (isCancel(selected)) {
+        cancel('Cancelled.');
+        process.exit(0);
+    }
+    return selected;
+}
+async function promptForInstallScope() {
+    const selected = await select({
+        message: 'Install scope',
+        options: [
+            { value: 'project', label: 'Project (default)', hint: 'Install into the current working directory' },
+            { value: 'global', label: 'Global', hint: 'Install into your user profile' },
+        ],
+    });
+    if (isCancel(selected)) {
+        cancel('Cancelled.');
+        process.exit(0);
+    }
+    return selected;
+}
+async function promptForAgents(scope) {
+    const ordered = AGENTS
+        .map((agent) => ({ agent, detected: isAgentDetected(agent, scope) }))
+        .sort((left, right) => Number(right.detected) - Number(left.detected) || left.agent.label.localeCompare(right.agent.label));
+    const universalAgents = scope === 'project'
+        ? ordered.filter(({ agent }) => isUniversalProjectAgent(agent))
+        : [];
+    const specificAgents = scope === 'project'
+        ? ordered.filter(({ agent }) => !isUniversalProjectAgent(agent))
+        : ordered;
+    const initialValues = scope === 'project' && universalAgents.length > 0
+        ? [UNIVERSAL_PROJECT_AGENT_VALUE]
+        : [];
+    const selected = await multiselect({
+        message: 'Select agents',
+        options: [
+            ...(scope === 'project' && universalAgents.length > 0
+                ? [{
+                        value: UNIVERSAL_PROJECT_AGENT_VALUE,
+                        label: `Universal (${UNIVERSAL_PROJECT_SKILLS_PATH})`,
+                        hint: `${universalAgents[0]?.detected ? 'detected · ' : ''}Shared project path for ${universalAgents.length} agents`,
+                    }]
+                : []),
+            ...specificAgents.map(({ agent, detected }) => ({
+                value: agent.value,
+                label: agent.label,
+                hint: `${detected ? 'detected · ' : ''}${scope === 'global' ? `~/${agent.globalPath}` : `./${agent.projectPath}`}`,
+            })),
+        ],
+        initialValues,
+        required: false,
+    });
+    if (isCancel(selected)) {
+        cancel('Cancelled.');
+        process.exit(0);
+    }
+    const selectedValues = new Set(selected);
+    const includesUniversalProjectAgents = scope === 'project' && selectedValues.has(UNIVERSAL_PROJECT_AGENT_VALUE);
+    return ordered
+        .map(({ agent }) => agent)
+        .filter((agent) => selectedValues.has(agent.value) || (includesUniversalProjectAgents && isUniversalProjectAgent(agent)));
+}
+async function promptText(message, initialValue = '', placeholder) {
+    const value = await text({
+        message,
+        defaultValue: initialValue,
+        placeholder,
+        validate(input) {
+            if (!(input ?? '').trim()) {
+                return `${message} is required.`;
+            }
+        },
+    });
+    if (isCancel(value)) {
+        cancel('Cancelled.');
+        process.exit(0);
+    }
+    return value.trim();
+}
+async function promptConfirm(message, initialValue = false) {
+    const value = await confirm({
+        message,
+        initialValue,
+    });
+    if (isCancel(value)) {
+        cancel('Cancelled.');
+        process.exit(0);
+    }
+    return value;
+}
+async function loadLocalSkillContext(directory) {
+    const resolvedDirectory = resolve(directory);
+    const scanStatus = spinner({ indicator: 'timer' });
+    scanStatus.start(`Scanning ${resolvedDirectory}`);
+    let filePlans;
+    try {
+        filePlans = await collectFilePlans(resolvedDirectory);
+    }
+    catch (error) {
+        scanStatus.clear();
+        throw error;
+    }
+    scanStatus.stop(`Found ${filePlans.length} file${filePlans.length === 1 ? '' : 's'} in ${resolvedDirectory}`);
+    const totalBytes = filePlans.reduce((sum, file) => sum + file.size, 0);
+    const readProgress = progress({ max: Math.max(filePlans.length, 1), size: 32 });
+    if (filePlans.length > 0) {
+        readProgress.start(`Reading files 0/${filePlans.length}`);
+    }
+    let files;
+    try {
+        files = await collectFiles(filePlans, (completed, total, relativePath) => {
+            readProgress.advance(1, `Reading files ${completed}/${total} · ${relativePath}`);
+        });
+    }
+    catch (error) {
+        readProgress.clear();
+        throw error;
+    }
+    if (filePlans.length > 0) {
+        readProgress.stop(`Prepared ${files.length} file${files.length === 1 ? '' : 's'} (${formatByteSize(totalBytes)})`);
+    }
+    validateSkillDirectory(files);
+    return {
+        directory: resolvedDirectory,
+        files,
+        totalBytes,
+        metadata: await readLocalSkillMetadata(resolvedDirectory),
+        defaults: deriveSkillDefaults(files, resolvedDirectory),
+    };
+}
+async function createSkillFromDirectory(client, localSkill, input) {
+    const name = normalizeText(input.name) ?? localSkill.defaults.name;
+    const description = normalizeText(input.description) ?? localSkill.defaults.description;
+    const uploadStatus = spinner({ indicator: 'timer' });
+    uploadStatus.start(`Uploading ${localSkill.files.length} file${localSkill.files.length === 1 ? '' : 's'} (${formatByteSize(localSkill.totalBytes)})`);
+    try {
+        const response = await client.createSkill({
+            name,
+            description,
+            version: input.version,
+            files: localSkill.files,
+        });
+        uploadStatus.message(`Fetching saved metadata for skill ${response.id}`);
+        const detail = await client.get(`/api/skills/${response.id}`);
+        await writeLocalSkillMetadata(localSkill.directory, createLocalSkillMetadata(detail, detail.latestVersion ?? input.version));
+        uploadStatus.stop(`Uploaded ${localSkill.files.length} file${localSkill.files.length === 1 ? '' : 's'} (${formatByteSize(localSkill.totalBytes)})`);
+        return { response, detail };
+    }
+    catch (error) {
+        uploadStatus.clear();
+        throw error;
+    }
+}
+async function publishSkillFromDirectory(client, localSkill, input) {
+    if (input.failIfMissing && !localSkill.metadata?.skillId) {
+        throw new Error(`Missing ${SKILL_METADATA_FILE_NAME}. Create the skill first or restore the metadata file.`);
+    }
+    const uploadStatus = spinner({ indicator: 'timer' });
+    uploadStatus.start(`Uploading ${localSkill.files.length} file${localSkill.files.length === 1 ? '' : 's'} (${formatByteSize(localSkill.totalBytes)})`);
+    try {
+        const response = await client.publishVersion({
+            skillId: input.skillId,
+            version: input.version,
+            files: localSkill.files,
+        });
+        uploadStatus.message(`Fetching saved metadata for skill ${input.skillId}`);
+        const detail = await client.get(`/api/skills/${input.skillId}`);
+        await writeLocalSkillMetadata(localSkill.directory, createLocalSkillMetadata(detail, response.version));
+        uploadStatus.stop(`Uploaded ${localSkill.files.length} file${localSkill.files.length === 1 ? '' : 's'} (${formatByteSize(localSkill.totalBytes)})`);
+        return { response, detail };
+    }
+    catch (error) {
+        uploadStatus.clear();
+        throw error;
+    }
+}
+async function writeSkillVersionToDirectory(client, input) {
+    for (const file of input.files) {
+        const response = await client.rawGet(`/api/skills/${input.skillId}/versions/${input.version}/files/${file.nameWithPath}`);
+        const destination = join(input.targetRoot, file.nameWithPath);
+        await mkdir(dirname(destination), { recursive: true });
+        await writeFile(destination, Buffer.from(await response.arrayBuffer()));
+    }
+    await writeLocalSkillMetadata(input.targetRoot, {
+        skillId: input.skillId,
+        skillName: input.skillName,
+        skillDescription: input.skillDescription,
+        skillVersion: input.version,
+    });
+}
+function deriveSkillDefaults(files, directory) {
+    const skillFile = files.find((file) => file.relativePath === SKILL_FILE_NAME);
+    if (!skillFile) {
+        throw new Error(`The skill directory must contain ${SKILL_FILE_NAME}.`);
+    }
+    const parsedSkillFile = parseSkillFile(skillFile.content.toString('utf8'));
+    const name = normalizeText(parsedSkillFile.attributes.name ?? parsedSkillFile.attributes.title)
+        ?? extractMarkdownTitle(parsedSkillFile.body)
+        ?? humanizeSkillName(basename(directory));
+    const description = normalizeText(parsedSkillFile.attributes.description)
+        ?? extractMarkdownDescription(parsedSkillFile.body)
+        ?? `Skill published from ${basename(directory)}.`;
+    return { name, description };
+}
+function parseSkillFile(content) {
+    const normalized = content.replaceAll('\r\n', '\n');
+    if (!normalized.startsWith('---\n')) {
+        return {
+            attributes: {},
+            body: normalized,
+        };
+    }
+    const lines = normalized.split('\n');
+    let closingLineIndex = -1;
+    for (let index = 1; index < lines.length; index += 1) {
+        if (lines[index]?.trim() === '---') {
+            closingLineIndex = index;
+            break;
+        }
+    }
+    if (closingLineIndex === -1) {
+        return {
+            attributes: {},
+            body: normalized,
+        };
+    }
+    return {
+        attributes: parseFrontmatter(lines.slice(1, closingLineIndex)),
+        body: lines.slice(closingLineIndex + 1).join('\n'),
+    };
+}
+function parseFrontmatter(lines) {
+    const attributes = {};
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index]?.trimEnd() ?? '';
+        const match = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(line);
+        if (!match) {
+            continue;
+        }
+        const rawKey = match[1];
+        const rawValue = match[2];
+        if (!rawKey || rawValue === undefined) {
+            continue;
+        }
+        const key = rawKey.toLowerCase();
+        const value = rawValue.trim();
+        if (value === '|' || value === '>') {
+            const blockLines = [];
+            let nextIndex = index + 1;
+            while (nextIndex < lines.length) {
+                const blockLine = lines[nextIndex] ?? '';
+                if (blockLine.length > 0 && !/^\s/.test(blockLine)) {
+                    break;
+                }
+                blockLines.push(blockLine.replace(/^\s+/, ''));
+                nextIndex += 1;
+            }
+            attributes[key] = value === '>'
+                ? blockLines.join(' ').replace(/\s+/g, ' ').trim()
+                : blockLines.join('\n').trim();
+            index = nextIndex - 1;
+            continue;
+        }
+        attributes[key] = unquoteFrontmatterValue(value);
+    }
+    return attributes;
+}
+function unquoteFrontmatterValue(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"'))
+        || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function extractMarkdownTitle(markdown) {
+    for (const line of markdown.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const heading = /^#\s+(.+)$/.exec(trimmed);
+        if (heading?.[1]) {
+            return heading[1].trim();
+        }
+    }
+    return null;
+}
+function extractMarkdownDescription(markdown) {
+    const paragraphs = markdown
+        .replace(/```[\s\S]*?```/g, ' ')
+        .split(/\n\s*\n/g);
+    for (const paragraph of paragraphs) {
+        const lines = paragraph
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith('#'));
+        const text = lines.join(' ').replace(/\s+/g, ' ').trim();
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
+function humanizeSkillName(value) {
+    const normalized = value
+        .replace(/[^A-Za-z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+    return normalized || 'Untitled Skill';
+}
+function createLocalSkillMetadata(detail, version) {
+    return {
+        skillId: detail.id,
+        skillName: detail.name,
+        skillDescription: detail.description,
+        skillVersion: version,
+    };
+}
+function parsePositiveInteger(value, optionName) {
+    const parsedValue = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsedValue) || parsedValue <= 0) {
+        throw new Error(`${optionName} must be a positive number`);
+    }
+    return parsedValue;
+}
+function normalizeText(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function filterSkills(skills, query) {
+    const normalized = query.trim().toLowerCase();
+    return skills.filter((skill) => skill.name.toLowerCase().includes(normalized) ||
+        skill.description.toLowerCase().includes(normalized));
+}
+function isAgentDetected(agent, scope) {
+    const basePath = getAgentBaseDir(agent, scope);
+    return existsSync(basePath);
+}
+function isUniversalProjectAgent(agent) {
+    return agent.projectPath === UNIVERSAL_PROJECT_SKILLS_PATH;
+}
+function getAgentBaseDir(agent, scope) {
+    return scope === 'global'
+        ? join(homedir(), agent.globalPath)
+        : join(process.cwd(), agent.projectPath);
+}
+function resolveInstallTargets(agents, scope, installName) {
+    const targets = new Map();
+    for (const agent of agents) {
+        const targetRoot = join(getAgentBaseDir(agent, scope), installName);
+        if (!targets.has(targetRoot)) {
+            targets.set(targetRoot, { targetRoot });
+        }
+    }
+    return [...targets.values()];
+}
+function createInstalledSkillDirectoryName(skill) {
+    const normalized = skill.name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized.length > 0 ? normalized : `skill-${skill.id}`;
+}
+async function login(baseUrl) {
+    baseUrl = normalizeBaseUrl(baseUrl);
+    const state = cryptoRandomHex(16);
+    const codeVerifier = createPkceVerifier();
+    const codeChallenge = createPkceChallenge(codeVerifier);
+    const callback = await waitForLoginCallback();
+    const loginUrl = `${baseUrl}/api/cli/login?redirectUri=${encodeURIComponent(callback.redirectUri)}` +
+        `&codeChallenge=${encodeURIComponent(codeChallenge)}` +
+        `&state=${encodeURIComponent(state)}`;
+    await openBrowser(loginUrl);
+    console.log(`Opening browser for ${baseUrl}`);
+    const authCode = await callback.wait(state);
+    const response = await fetchJson(`${baseUrl}/api/cli/token`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+        },
+        body: JSON.stringify({
+            code: authCode,
+            redirectUri: callback.redirectUri,
+            codeVerifier,
+        }),
+    });
+    await storeSession({
+        baseUrl,
+        accessToken: response.accessToken,
+        accessTokenExpiresAt: response.accessTokenExpiresAt,
+        refreshToken: response.refreshToken,
+        refreshTokenExpiresAt: response.refreshTokenExpiresAt,
+        user: response.user,
+    });
+    console.log(`Logged in as ${response.user.displayName} (${baseUrl})`);
+}
+async function parseOptions(args) {
+    const flags = {};
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (!current) {
+            continue;
+        }
+        if (current.startsWith('--')) {
+            const key = current.slice(2);
+            const value = args[index + 1];
+            if (!value || value.startsWith('--')) {
+                throw new Error(`Missing value for ${current}`);
+            }
+            flags[key] = value;
+            index += 1;
+        }
+        else {
+            positionals.push(current);
+        }
+    }
+    return {
+        token: flags.token,
+        flags,
+        positionals,
+    };
+}
+async function resolveActiveBaseUrl() {
+    const session = await loadAnySession();
+    if (session?.baseUrl) {
+        return normalizeBaseUrl(session.baseUrl);
+    }
+    return PROD_URL;
+}
+async function createClient(baseUrl, explicitToken) {
+    const resolvedBaseUrl = normalizeBaseUrl(baseUrl);
+    async function loadStoredSessionOrThrow() {
+        const session = await loadSession(resolvedBaseUrl);
+        if (!session) {
+            throw new Error(`No stored session for ${resolvedBaseUrl}. Run "skillshare login${resolvedBaseUrl === LOCAL_URL ? ' local' : ''}".`);
+        }
+        return session;
+    }
+    async function refreshStoredSession(session) {
+        const currentSession = session ?? await loadStoredSessionOrThrow();
+        if (new Date(currentSession.refreshTokenExpiresAt).getTime() <= Date.now()) {
+            throw new Error(`Stored session for ${resolvedBaseUrl} is no longer valid. Run "skillshare login${resolvedBaseUrl === LOCAL_URL ? ' local' : ''}" again.`);
+        }
+        const response = await fetch(`${resolvedBaseUrl}/api/cli/refresh`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: JSON.stringify({
+                refreshToken: currentSession.refreshToken,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Stored session for ${resolvedBaseUrl} is no longer valid. Run "skillshare login${resolvedBaseUrl === LOCAL_URL ? ' local' : ''}" again.`);
+        }
+        const refreshed = await response.json();
+        const nextSession = {
+            ...currentSession,
+            accessToken: refreshed.accessToken,
+            accessTokenExpiresAt: refreshed.accessTokenExpiresAt,
+            refreshToken: refreshed.refreshToken,
+            refreshTokenExpiresAt: refreshed.refreshTokenExpiresAt,
+            user: refreshed.user,
+        };
+        await storeSession(nextSession);
+        return nextSession;
+    }
+    async function getAccessToken(options) {
+        if (explicitToken) {
+            return explicitToken;
+        }
+        const session = await loadStoredSessionOrThrow();
+        if (!options?.forceRefresh && new Date(session.accessTokenExpiresAt).getTime() > Date.now() + 60_000) {
+            return session.accessToken;
+        }
+        const refreshedSession = await refreshStoredSession(session);
+        return refreshedSession.accessToken;
+    }
+    async function sendAuthorized(path, init, retryUnauthorized = true) {
+        const response = await fetch(`${resolvedBaseUrl}${path}`, {
+            ...init,
+            headers: await buildHeaders(() => getAccessToken(), init?.headers),
+        });
+        if (response.status !== 401 || explicitToken || !retryUnauthorized) {
+            return response;
+        }
+        const refreshedToken = await getAccessToken({ forceRefresh: true });
+        return fetch(`${resolvedBaseUrl}${path}`, {
+            ...init,
+            headers: await buildHeaders(() => Promise.resolve(refreshedToken), init?.headers),
+        });
+    }
+    return {
+        async get(path) {
+            const response = await sendAuthorized(path);
+            return parseJson(response);
+        },
+        async post(path) {
+            const response = await sendAuthorized(path, {
+                method: 'POST',
+            });
+            return parseJson(response);
+        },
+        async rawGet(path) {
+            const response = await sendAuthorized(path);
+            if (!response.ok) {
+                throw new Error(await formatErrorResponse(response));
+            }
+            return response;
+        },
+        async createSkill(input) {
+            const formData = new FormData();
+            formData.append('metadata', JSON.stringify({
+                name: input.name,
+                description: input.description,
+                version: input.version,
+            }));
+            for (const file of input.files) {
+                formData.append('files', new Blob([toBlobPart(file.content)], { type: file.contentType }), file.relativePath);
+            }
+            const response = await sendAuthorized('/api/skills', {
+                method: 'POST',
+                body: formData,
+            });
+            return parseJson(response);
+        },
+        async publishVersion(input) {
+            const formData = new FormData();
+            formData.append('metadata', JSON.stringify({
+                version: input.version,
+            }));
+            for (const file of input.files) {
+                formData.append('files', new Blob([toBlobPart(file.content)], { type: file.contentType }), file.relativePath);
+            }
+            const response = await sendAuthorized(`/api/skills/${input.skillId}/versions`, {
+                method: 'POST',
+                body: formData,
+            });
+            return parseJson(response);
+        },
+    };
+}
+async function buildHeaders(getAccessToken, initialHeaders) {
+    const headers = new Headers(initialHeaders);
+    if (!headers.has('Accept')) {
+        headers.set('Accept', 'application/json');
+    }
+    headers.set('Authorization', `Bearer ${await getAccessToken()}`);
+    return headers;
+}
+async function parseJson(response) {
+    if (!response.ok) {
+        throw new Error(await formatErrorResponse(response));
+    }
+    return response.json();
+}
+async function formatErrorResponse(response) {
+    const fallbackMessage = `Request failed with ${response.status}${response.statusText ? ` ${response.statusText}` : ''}.`;
+    let body = '';
+    try {
+        body = (await response.text()).trim();
+    }
+    catch {
+        return fallbackMessage;
+    }
+    if (!body) {
+        return fallbackMessage;
+    }
+    try {
+        const parsed = JSON.parse(body);
+        const message = typeof parsed.error === 'string'
+            ? parsed.error
+            : typeof parsed.message === 'string'
+                ? parsed.message
+                : null;
+        if (message) {
+            return `${fallbackMessage} ${message}`;
+        }
+    }
+    catch {
+        // Fall back to the raw response body when the server returned non-JSON text.
+    }
+    return body.length > 300
+        ? `${fallbackMessage} ${body.slice(0, 297)}...`
+        : `${fallbackMessage} ${body}`;
+}
+async function fetchJson(input, init) {
+    const response = await fetch(input, init);
+    return parseJson(response);
+}
+async function loadSession(baseUrl) {
+    try {
+        const session = JSON.parse(await readFile(SESSION_PATH, 'utf8'));
+        return session.baseUrl === baseUrl ? session : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function loadAnySession() {
+    try {
+        return JSON.parse(await readFile(SESSION_PATH, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function storeSession(session) {
+    await mkdir(APP_DIR, { recursive: true });
+    await writeFile(SESSION_PATH, JSON.stringify(session), {
+        mode: process.platform === 'win32' ? undefined : 0o600,
+    });
+}
+async function logoutSession() {
+    try {
+        await rm(SESSION_PATH);
+        console.log('Logged out.');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            console.log('No active session.');
+            return;
+        }
+        throw error;
+    }
+}
+async function openBrowser(url) {
+    if (process.platform === 'darwin') {
+        const result = await runProcess('open', [url], { allowFailure: true });
+        if (result.exitCode !== 0) {
+            throw new Error(result.stderr.trim() || 'Failed to open browser.');
+        }
+        return;
+    }
+    if (process.platform === 'win32') {
+        const result = await runProcess('cmd', ['/c', 'start', '', url], { allowFailure: true });
+        if (result.exitCode !== 0) {
+            throw new Error(result.stderr.trim() || 'Failed to open browser.');
+        }
+        return;
+    }
+    const result = await runProcess('xdg-open', [url], { allowFailure: true });
+    if (result.exitCode !== 0) {
+        throw new Error(result.stderr.trim() || 'Failed to open browser.');
+    }
+}
+async function waitForLoginCallback() {
+    let resolveStatePromise = () => { };
+    let rejectStatePromise = () => { };
+    const statePromise = new Promise((resolve, reject) => {
+        resolveStatePromise = resolve;
+        rejectStatePromise = reject;
+    });
+    const server = createServer((request, response) => {
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        const code = url.searchParams.get('code');
+        const state = url.searchParams.get('state');
+        const error = url.searchParams.get('error');
+        if (error) {
+            response.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
+            response.end(`Login failed: ${error}`);
+            rejectStatePromise(new Error(`Login failed: ${error}`));
+            return;
+        }
+        if (!code || !state) {
+            response.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
+            response.end('Missing code or state.');
+            return;
+        }
+        response.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+        response.end('Skillshare login completed. You can close this tab.');
+        resolveStatePromise(JSON.stringify({ code, state }));
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => resolve());
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Failed to bind local callback server.');
+    }
+    return {
+        redirectUri: `http://127.0.0.1:${address.port}/callback`,
+        async wait(expectedState) {
+            try {
+                const payload = JSON.parse(await statePromise);
+                if (payload.state !== expectedState) {
+                    throw new Error('Login state mismatch.');
+                }
+                return payload.code;
+            }
+            finally {
+                server.close();
+            }
+        },
+    };
+}
+async function readLocalSkillMetadata(directory) {
+    const metadataPath = join(resolve(directory), SKILL_METADATA_FILE_NAME);
+    try {
+        const parsed = JSON.parse(await readFile(metadataPath, 'utf8'));
+        const skillId = Number(parsed.skillId);
+        if (!Number.isInteger(skillId) || skillId <= 0) {
+            throw new Error(`Invalid skillId in ${SKILL_METADATA_FILE_NAME}.`);
+        }
+        return {
+            skillId,
+            skillName: typeof parsed.skillName === 'string' ? parsed.skillName : '',
+            skillDescription: typeof parsed.skillDescription === 'string' ? parsed.skillDescription : '',
+            skillVersion: typeof parsed.skillVersion === 'string' ? parsed.skillVersion : '',
+        };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return null;
+        }
+        throw new Error(`Failed to read ${metadataPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function writeLocalSkillMetadata(directory, metadata) {
+    await mkdir(directory, { recursive: true });
+    await writeFile(join(directory, SKILL_METADATA_FILE_NAME), `${JSON.stringify(metadata, null, 2)}\n`);
+}
+async function collectFilePlans(root, current = root) {
+    const entries = await readdir(current, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const entryPath = join(current, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await collectFilePlans(root, entryPath)));
+            continue;
+        }
+        const entryStat = await stat(entryPath);
+        if (!entryStat.isFile()) {
+            continue;
+        }
+        const relativePath = relative(root, entryPath).replaceAll('\\', '/');
+        if (relativePath === SKILL_METADATA_FILE_NAME) {
+            continue;
+        }
+        files.push({
+            absolutePath: entryPath,
+            relativePath,
+            size: entryStat.size,
+        });
+    }
+    return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function collectFiles(filePlans, onFileRead) {
+    const files = [];
+    for (let index = 0; index < filePlans.length; index += 1) {
+        const filePlan = filePlans[index];
+        if (!filePlan) {
+            continue;
+        }
+        files.push({
+            relativePath: filePlan.relativePath,
+            content: await readFile(filePlan.absolutePath),
+            contentType: guessContentType(filePlan.relativePath),
+        });
+        onFileRead?.(index + 1, filePlans.length, filePlan.relativePath);
+    }
+    return files;
+}
+function validateSkillDirectory(files) {
+    if (files.length === 0) {
+        throw new Error('The skill directory is empty.');
+    }
+    if (!files.some((file) => file.relativePath === SKILL_FILE_NAME)) {
+        throw new Error(`The skill directory must contain ${SKILL_FILE_NAME}.`);
+    }
+}
+function guessContentType(path) {
+    if (path.endsWith('.md'))
+        return 'text/markdown; charset=utf-8';
+    if (path.endsWith('.json'))
+        return 'application/json; charset=utf-8';
+    if (path.endsWith('.yaml') || path.endsWith('.yml'))
+        return 'application/yaml; charset=utf-8';
+    if (path.endsWith('.txt'))
+        return 'text/plain; charset=utf-8';
+    return 'application/octet-stream';
+}
+function formatByteSize(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0) {
+        return '0 B';
+    }
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex += 1;
+    }
+    const decimals = value >= 10 || unitIndex === 0 ? 0 : 1;
+    return `${value.toFixed(decimals)} ${units[unitIndex]}`;
+}
+function normalizeBaseUrl(url) {
+    return url.replace(/\/+$/, '');
+}
+function cryptoRandomHex(bytes) {
+    return randomBytes(bytes).toString('hex');
+}
+function createPkceVerifier() {
+    return toBase64Url(randomBytes(32));
+}
+function createPkceChallenge(verifier) {
+    return toBase64Url(createHash('sha256').update(verifier, 'ascii').digest());
+}
+function toBase64Url(bytes) {
+    return Buffer.from(bytes)
+        .toString('base64')
+        .replaceAll('+', '-')
+        .replaceAll('/', '_')
+        .replaceAll('=', '');
+}
+function toBlobPart(buffer) {
+    return Uint8Array.from(buffer);
+}
+function getAppDir() {
+    if (process.platform === 'win32') {
+        return join(process.env.APPDATA ?? join(homedir(), 'AppData', 'Roaming'), 'skillshare');
+    }
+    return join(homedir(), '.config', 'skillshare');
+}
+async function runProcess(command, args, options) {
+    const child = spawn(command, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => {
+        stdout += chunk.toString();
+    });
+    child.stderr.on('data', (chunk) => {
+        stderr += chunk.toString();
+    });
+    const exitCode = await new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('close', (code) => resolve(code ?? 1));
+    });
+    if (exitCode !== 0 && !options?.allowFailure) {
+        throw new Error(stderr.trim() || `${command} failed with exit code ${exitCode}.`);
+    }
+    return { exitCode, stdout, stderr };
+}
+main().catch((error) => {
+    process.exitCode = 1;
+    const message = error instanceof Error
+        ? error.message.trim() || 'Unexpected error.'
+        : String(error).trim() || 'Unexpected error.';
+    process.stderr.write(`${message}\n`);
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@quadient/skillshare",
+  "version": "0.1.0",
+  "description": "Skillshare CLI for installing and publishing Quadient skills",
+  "type": "module",
+  "bin": {
+    "skillshare": "./bin/skillshare"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx index.ts",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "start": "node ./dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.2.0"
+  }
+}