claudeup 3.7.2 → 3.9.0

package/src/services/settings-manager.js

@@ -0,0 +1,108 @@
+import { readSettings, writeSettings, readGlobalSettings, writeGlobalSettings, } from "./claude-settings.js";
+/** Read the current value of a setting from the given scope */
+export async function readSettingValue(setting, scope, projectPath) {
+    const settings = scope === "user"
+        ? await readGlobalSettings()
+        : await readSettings(projectPath);
+    if (setting.storage.type === "env") {
+        const env = settings.env;
+        return env?.[setting.storage.key];
+    }
+    else {
+        // Direct settings key (supports dot notation like "permissions.defaultMode")
+        const keys = setting.storage.key.split(".");
+        let value = settings;
+        for (const k of keys) {
+            value = value?.[k];
+        }
+        return value !== undefined && value !== null ? String(value) : undefined;
+    }
+}
+/** Write a setting value to the given scope */
+export async function writeSettingValue(setting, value, scope, projectPath) {
+    const settings = scope === "user"
+        ? await readGlobalSettings()
+        : await readSettings(projectPath);
+    if (setting.storage.type === "env") {
+        // Write to the "env" block in settings.json
+        settings.env = settings.env || {};
+        if (value === undefined || value === "" || value === setting.defaultValue) {
+            delete settings.env[setting.storage.key];
+            // Clean up empty env block
+            if (Object.keys(settings.env).length === 0) {
+                delete settings.env;
+            }
+        }
+        else {
+            settings.env[setting.storage.key] = value;
+        }
+    }
+    else {
+        // Direct settings key (supports dot notation)
+        const keys = setting.storage.key.split(".");
+        if (keys.length === 1) {
+            if (value === undefined || value === "") {
+                delete settings[keys[0]];
+            }
+            else {
+                // Try to preserve type: boolean, number, or string
+                settings[keys[0]] = parseSettingValue(value, setting.type);
+            }
+        }
+        else {
+            // Nested key like "permissions.defaultMode"
+            let obj = settings;
+            for (let i = 0; i < keys.length - 1; i++) {
+                obj[keys[i]] = obj[keys[i]] || {};
+                obj = obj[keys[i]];
+            }
+            const lastKey = keys[keys.length - 1];
+            if (value === undefined || value === "") {
+                delete obj[lastKey];
+            }
+            else {
+                obj[lastKey] = parseSettingValue(value, setting.type);
+            }
+        }
+    }
+    if (scope === "user") {
+        await writeGlobalSettings(settings);
+    }
+    else {
+        await writeSettings(settings, projectPath);
+    }
+}
+function parseSettingValue(value, type) {
+    if (type === "boolean") {
+        return value === "true" || value === "1";
+    }
+    // Try number
+    const num = Number(value);
+    if (!Number.isNaN(num) && value.trim() !== "") {
+        return value; // Keep as string for env vars
+    }
+    return value;
+}
+/** Read all setting values for the catalog */
+export async function readAllSettings(catalog, scope, projectPath) {
+    const values = new Map();
+    for (const setting of catalog) {
+        values.set(setting.id, await readSettingValue(setting, scope, projectPath));
+    }
+    return values;
+}
+/** Read all setting values from both scopes simultaneously */
+export async function readAllSettingsBothScopes(catalog, projectPath) {
+    const result = new Map();
+    const [userValues, projectValues] = await Promise.all([
+        readAllSettings(catalog, "user", projectPath),
+        readAllSettings(catalog, "project", projectPath),
+    ]);
+    for (const setting of catalog) {
+        result.set(setting.id, {
+            user: userValues.get(setting.id),
+            project: projectValues.get(setting.id),
+        });
+    }
+    return result;
+}

package/src/services/settings-manager.ts

@@ -0,0 +1,140 @@
+import {
+	readSettings,
+	writeSettings,
+	readGlobalSettings,
+	writeGlobalSettings,
+} from "./claude-settings.js";
+import type { SettingDefinition } from "../data/settings-catalog.js";
+
+export type SettingScope = "user" | "project";
+
+/** Read the current value of a setting from the given scope */
+export async function readSettingValue(
+	setting: SettingDefinition,
+	scope: SettingScope,
+	projectPath?: string,
+): Promise<string | undefined> {
+	const settings =
+		scope === "user"
+			? await readGlobalSettings()
+			: await readSettings(projectPath);
+
+	if (setting.storage.type === "env") {
+		const env = (settings as any).env as Record<string, string> | undefined;
+		return env?.[setting.storage.key];
+	} else {
+		// Direct settings key (supports dot notation like "permissions.defaultMode")
+		const keys = setting.storage.key.split(".");
+		let value: any = settings;
+		for (const k of keys) {
+			value = value?.[k];
+		}
+		return value !== undefined && value !== null ? String(value) : undefined;
+	}
+}
+
+/** Write a setting value to the given scope */
+export async function writeSettingValue(
+	setting: SettingDefinition,
+	value: string | undefined,
+	scope: SettingScope,
+	projectPath?: string,
+): Promise<void> {
+	const settings =
+		scope === "user"
+			? await readGlobalSettings()
+			: await readSettings(projectPath);
+
+	if (setting.storage.type === "env") {
+		// Write to the "env" block in settings.json
+		(settings as any).env = (settings as any).env || {};
+		if (value === undefined || value === "" || value === setting.defaultValue) {
+			delete (settings as any).env[setting.storage.key];
+			// Clean up empty env block
+			if (Object.keys((settings as any).env).length === 0) {
+				delete (settings as any).env;
+			}
+		} else {
+			(settings as any).env[setting.storage.key] = value;
+		}
+	} else {
+		// Direct settings key (supports dot notation)
+		const keys = setting.storage.key.split(".");
+		if (keys.length === 1) {
+			if (value === undefined || value === "") {
+				delete (settings as any)[keys[0]];
+			} else {
+				// Try to preserve type: boolean, number, or string
+				(settings as any)[keys[0]] = parseSettingValue(value, setting.type);
+			}
+		} else {
+			// Nested key like "permissions.defaultMode"
+			let obj: any = settings;
+			for (let i = 0; i < keys.length - 1; i++) {
+				obj[keys[i]] = obj[keys[i]] || {};
+				obj = obj[keys[i]];
+			}
+			const lastKey = keys[keys.length - 1];
+			if (value === undefined || value === "") {
+				delete obj[lastKey];
+			} else {
+				obj[lastKey] = parseSettingValue(value, setting.type);
+			}
+		}
+	}
+
+	if (scope === "user") {
+		await writeGlobalSettings(settings);
+	} else {
+		await writeSettings(settings, projectPath);
+	}
+}
+
+function parseSettingValue(value: string, type: string): any {
+	if (type === "boolean") {
+		return value === "true" || value === "1";
+	}
+	// Try number
+	const num = Number(value);
+	if (!Number.isNaN(num) && value.trim() !== "") {
+		return value; // Keep as string for env vars
+	}
+	return value;
+}
+
+/** Read all setting values for the catalog */
+export async function readAllSettings(
+	catalog: SettingDefinition[],
+	scope: SettingScope,
+	projectPath?: string,
+): Promise<Map<string, string | undefined>> {
+	const values = new Map<string, string | undefined>();
+	for (const setting of catalog) {
+		values.set(setting.id, await readSettingValue(setting, scope, projectPath));
+	}
+	return values;
+}
+
+export interface ScopedSettingValues {
+	user: string | undefined;
+	project: string | undefined;
+}
+
+/** Read all setting values from both scopes simultaneously */
+export async function readAllSettingsBothScopes(
+	catalog: SettingDefinition[],
+	projectPath?: string,
+): Promise<Map<string, ScopedSettingValues>> {
+	const result = new Map<string, ScopedSettingValues>();
+	const [userValues, projectValues] = await Promise.all([
+		readAllSettings(catalog, "user", projectPath),
+		readAllSettings(catalog, "project", projectPath),
+	]);
+	for (const setting of catalog) {
+		result.set(setting.id, {
+			user: userValues.get(setting.id),
+			project: projectValues.get(setting.id),
+		});
+	}
+	return result;
+}

package/src/services/skills-manager.js

@@ -0,0 +1,239 @@
+import fs from "fs-extra";
+import path from "node:path";
+import os from "node:os";
+const treeCache = new Map();
+// ─── Path helpers ──────────────────────────────────────────────────────────────
+export function getUserSkillsDir() {
+    return path.join(os.homedir(), ".claude", "skills");
+}
+export function getProjectSkillsDir(projectPath) {
+    return path.join(projectPath ?? process.cwd(), ".claude", "skills");
+}
+// ─── GitHub Tree API ──────────────────────────────────────────────────────────
+async function fetchGitTree(repo) {
+    const cached = treeCache.get(repo);
+    const url = `https://api.github.com/repos/${repo}/git/trees/HEAD?recursive=1`;
+    const headers = {
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    };
+    if (cached?.etag) {
+        headers["If-None-Match"] = cached.etag;
+    }
+    const token = process.env.GITHUB_TOKEN || process.env.GITHUB_PERSONAL_ACCESS_TOKEN;
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    const response = await fetch(url, {
+        headers,
+        signal: AbortSignal.timeout(10000),
+    });
+    if (response.status === 304 && cached) {
+        return cached.tree;
+    }
+    if (response.status === 403 || response.status === 429) {
+        const resetHeader = response.headers.get("X-RateLimit-Reset");
+        const resetTime = resetHeader
+            ? new Date(Number(resetHeader) * 1000).toLocaleTimeString()
+            : "unknown";
+        throw new Error(`GitHub API rate limit exceeded. Resets at ${resetTime}. Set GITHUB_TOKEN to increase limits.`);
+    }
+    if (!response.ok) {
+        throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    }
+    const etag = response.headers.get("ETag") || "";
+    const tree = (await response.json());
+    treeCache.set(repo, { etag, tree, fetchedAt: Date.now() });
+    return tree;
+}
+// ─── Frontmatter parser ───────────────────────────────────────────────────────
+function parseYamlFrontmatter(content) {
+    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch)
+        return {};
+    const yaml = frontmatterMatch[1];
+    const result = {};
+    for (const line of yaml.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const rawValue = line.slice(colonIdx + 1).trim();
+        if (!key)
+            continue;
+        // Handle arrays (simple inline: [a, b, c])
+        if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+            const items = rawValue
+                .slice(1, -1)
+                .split(",")
+                .map((s) => s.trim().replace(/^["']|["']$/g, ""))
+                .filter(Boolean);
+            result[key] = items;
+        }
+        else {
+            // Strip quotes
+            result[key] = rawValue.replace(/^["']|["']$/g, "");
+        }
+    }
+    return result;
+}
+export async function fetchSkillFrontmatter(skill) {
+    const url = `https://raw.githubusercontent.com/${skill.source.repo}/HEAD/${skill.repoPath}`;
+    const response = await fetch(url, {
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!response.ok) {
+        return {
+            name: skill.name,
+            description: "(no description)",
+            category: "general",
+        };
+    }
+    const content = await response.text();
+    const parsed = parseYamlFrontmatter(content);
+    return {
+        name: parsed.name || skill.name,
+        description: parsed.description || "(no description)",
+        category: parsed.category,
+        author: parsed.author,
+        version: parsed.version,
+        tags: parsed.tags,
+    };
+}
+// ─── Check installation ───────────────────────────────────────────────────────
+export async function getInstalledSkillNames(scope, projectPath) {
+    const dir = scope === "user"
+        ? getUserSkillsDir()
+        : getProjectSkillsDir(projectPath);
+    const installed = new Set();
+    try {
+        if (!(await fs.pathExists(dir)))
+            return installed;
+        const entries = await fs.readdir(dir);
+        for (const entry of entries) {
+            const skillMd = path.join(dir, entry, "SKILL.md");
+            if (await fs.pathExists(skillMd)) {
+                installed.add(entry);
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return installed;
+}
+// ─── Fetch available skills ───────────────────────────────────────────────────
+export async function fetchAvailableSkills(repos, projectPath) {
+    const userInstalled = await getInstalledSkillNames("user");
+    const projectInstalled = await getInstalledSkillNames("project", projectPath);
+    const skills = [];
+    for (const source of repos) {
+        let tree;
+        try {
+            tree = await fetchGitTree(source.repo);
+        }
+        catch {
+            // Skip this repo on error
+            continue;
+        }
+        // Filter for SKILL.md files under skillsPath
+        const prefix = source.skillsPath ? `${source.skillsPath}/` : "";
+        for (const item of tree.tree) {
+            if (item.type !== "blob")
+                continue;
+            if (!item.path.endsWith("/SKILL.md"))
+                continue;
+            if (prefix && !item.path.startsWith(prefix))
+                continue;
+            // Extract skill name: second-to-last segment of path
+            const parts = item.path.split("/");
+            if (parts.length < 2)
+                continue;
+            const skillName = parts[parts.length - 2];
+            // Validate name (prevent traversal)
+            if (!/^[a-z0-9][a-z0-9-_]*$/i.test(skillName))
+                continue;
+            const isUserInstalled = userInstalled.has(skillName);
+            const isProjInstalled = projectInstalled.has(skillName);
+            const installed = isUserInstalled || isProjInstalled;
+            const installedScope = isProjInstalled
+                ? "project"
+                : isUserInstalled
+                    ? "user"
+                    : null;
+            skills.push({
+                id: `${source.repo}/${item.path}`,
+                name: skillName,
+                source,
+                repoPath: item.path,
+                gitBlobSha: item.sha,
+                frontmatter: null,
+                installed,
+                installedScope,
+                hasUpdate: false,
+            });
+        }
+    }
+    // Sort by name within each repo
+    skills.sort((a, b) => a.name.localeCompare(b.name));
+    return skills;
+}
+// ─── Install / Uninstall ──────────────────────────────────────────────────────
+export async function installSkill(skill, scope, projectPath) {
+    const url = `https://raw.githubusercontent.com/${skill.source.repo}/HEAD/${skill.repoPath}`;
+    const response = await fetch(url, {
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch skill: ${response.status} ${response.statusText}`);
+    }
+    const content = await response.text();
+    const installDir = scope === "user"
+        ? path.join(getUserSkillsDir(), skill.name)
+        : path.join(getProjectSkillsDir(projectPath), skill.name);
+    await fs.ensureDir(installDir);
+    await fs.writeFile(path.join(installDir, "SKILL.md"), content, "utf8");
+}
+export async function uninstallSkill(skillName, scope, projectPath) {
+    const installDir = scope === "user"
+        ? path.join(getUserSkillsDir(), skillName)
+        : path.join(getProjectSkillsDir(projectPath), skillName);
+    const skillMdPath = path.join(installDir, "SKILL.md");
+    if (await fs.pathExists(skillMdPath)) {
+        await fs.remove(skillMdPath);
+    }
+    // Try to remove directory if empty
+    try {
+        await fs.rmdir(installDir);
+    }
+    catch {
+        // Ignore if not empty or doesn't exist
+    }
+}
+// ─── Check installed skills from file system ──────────────────────────────────
+export async function getInstalledSkillsFromFs(projectPath) {
+    const result = [];
+    const userDir = getUserSkillsDir();
+    const projDir = getProjectSkillsDir(projectPath);
+    const scopedDirs = [
+        [userDir, "user"],
+        [projDir, "project"],
+    ];
+    for (const [dir, scope] of scopedDirs) {
+        try {
+            if (!(await fs.pathExists(dir)))
+                continue;
+            const entries = await fs.readdir(dir);
+            for (const entry of entries) {
+                const skillMd = path.join(dir, entry, "SKILL.md");
+                if (await fs.pathExists(skillMd)) {
+                    result.push({ name: entry, scope });
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return result;
+}