@anytio/pspm 0.13.0 → 0.14.1

package/dist/config-BQy_Rjip.js

@@ -0,0 +1,468 @@
+import { dirname, join } from "node:path";
+import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import * as ini from "ini";
+//#region ../../packages/shared/errors/src/extract.ts
+const DEFAULT_STATUS_DESCRIPTIONS = {
+	400: "Bad Request",
+	401: "Unauthorized",
+	403: "Forbidden",
+	404: "Not Found",
+	409: "Conflict",
+	422: "Validation Error",
+	429: "Too Many Requests",
+	500: "Internal Server Error",
+	502: "Bad Gateway",
+	503: "Service Unavailable"
+};
+function getStatusDescription(status, overrides) {
+	return overrides?.[status] ?? DEFAULT_STATUS_DESCRIPTIONS[status] ?? `HTTP ${status}`;
+}
+function extractApiErrorMessage$1(response, fallbackMessage, options = {}) {
+	const errorData = response.data;
+	const overrides = options.statusDescriptions;
+	if (options.debug) {
+		const log = options.debugLogger ?? console.log;
+		log(`[debug] API response status: ${response.status}`);
+		log("[debug] API response data:", errorData);
+	}
+	if (typeof errorData === "string") {
+		if (response.status === 404) return `${fallbackMessage}: ${getStatusDescription(404, overrides)}`;
+		return `${fallbackMessage}: ${errorData} (HTTP ${response.status})`;
+	}
+	if (!errorData || typeof errorData !== "object") return `${fallbackMessage}: ${getStatusDescription(response.status, overrides)}`;
+	let errorMessage = errorData.message || fallbackMessage;
+	if (errorData.code === "VALIDATION_ERROR" && errorData.details) {
+		const issues = errorData.details.issues;
+		if (issues && Array.isArray(issues)) errorMessage = `Validation failed:\n${issues.map((issue) => {
+			return `  - ${issue.path?.join(".") || "input"}: ${issue.message || "invalid value"}`;
+		}).join("\n")}`;
+	}
+	if (errorData.code && !errorMessage.includes(errorData.code)) errorMessage = `[${errorData.code}] ${errorMessage}`;
+	if (response.status >= 400) errorMessage += ` (HTTP ${response.status})`;
+	if (errorData.requestId) errorMessage += `\n(Request ID: ${errorData.requestId})`;
+	return errorMessage;
+}
+//#endregion
+//#region src/errors.ts
+/**
+* Base error class for PSPM configuration errors
+*/
+var ConfigError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ConfigError";
+	}
+};
+/**
+* Error thrown when the user is not logged in
+*/
+var NotLoggedInError = class extends ConfigError {
+	constructor() {
+		super("Not logged in. Run 'pspm login --api-key <key>' first, or set PSPM_API_KEY env var.");
+		this.name = "NotLoggedInError";
+	}
+};
+const CLI_STATUS_DESCRIPTIONS = {
+	400: "Bad Request - The request was malformed",
+	401: "Unauthorized - Please run 'pspm login' first",
+	403: "Forbidden - You don't have permission for this action",
+	404: "Not Found - The endpoint or resource doesn't exist",
+	409: "Conflict - The resource already exists or there's a version conflict",
+	422: "Validation Error - The request data is invalid",
+	429: "Too Many Requests - Please slow down and try again",
+	500: "Internal Server Error - Something went wrong on the server",
+	502: "Bad Gateway - The server is temporarily unavailable",
+	503: "Service Unavailable - The server is temporarily unavailable"
+};
+/**
+* Extract a human-readable error message from an API response.
+* Thin wrapper over `@anytio/errors/extract` with CLI-tuned status hints.
+*/
+function extractApiErrorMessage(response, fallbackMessage) {
+	return extractApiErrorMessage$1(response, fallbackMessage, {
+		statusDescriptions: CLI_STATUS_DESCRIPTIONS,
+		debug: Boolean(process.env.PSPM_DEBUG),
+		debugLogger: (msg, data) => data === void 0 ? console.log(msg) : console.log(msg, JSON.stringify(data, null, 2))
+	});
+}
+//#endregion
+//#region src/config-auth.ts
+/**
+* Get the auth token for a given registry URL.
+* Falls back to the default API key if no registry-specific token is configured.
+*
+* @param config - The resolved configuration
+* @param registryUrl - The registry URL
+* @returns The auth token to use, or undefined if none available
+*/
+function getTokenForRegistry(config, registryUrl) {
+	try {
+		const host = new URL(registryUrl).host;
+		if (config.registryTokens[host]) return config.registryTokens[host];
+		return config.apiKey;
+	} catch {
+		return config.apiKey;
+	}
+}
+/**
+* Set credentials (authToken and optionally username/registry)
+*/
+async function setCredentials(authToken, username, registry) {
+	const config = await readUserConfig();
+	config.authToken = authToken;
+	if (username) config.username = username;
+	if (registry && registry !== "https://registry.pspm.dev") config.registry = registry;
+	await writeUserConfig(config);
+}
+/**
+* Clear credentials (authToken and username)
+*/
+async function clearCredentials() {
+	const config = await readUserConfig();
+	config.authToken = void 0;
+	config.username = void 0;
+	await writeUserConfig(config);
+}
+/**
+* Check if user is logged in
+*/
+async function isLoggedIn() {
+	try {
+		return !!(await resolveConfig()).apiKey;
+	} catch {
+		return false;
+	}
+}
+/**
+* Get the API key (throws if not logged in)
+*/
+async function requireApiKey() {
+	const resolved = await resolveConfig();
+	if (!resolved.apiKey) {
+		if (process.env.PSPM_DEBUG) console.log("[config] requireApiKey: No API key found");
+		throw new NotLoggedInError();
+	}
+	if (process.env.PSPM_DEBUG) console.log(`[config] requireApiKey: Got API key (${resolved.apiKey.substring(0, 10)}...)`);
+	return resolved.apiKey;
+}
+/**
+* Get the registry URL
+*/
+async function getRegistryUrl() {
+	return (await resolveConfig()).registryUrl;
+}
+/**
+* Get the encryption key for a given scope.
+*
+* Checks environment variable first (PSPM_ENCRYPTION_KEY_{SCOPE}),
+* then falls back to ~/.pspmrc encryption-key:{scope}.
+*
+* @param scope - The scope (e.g., "@user/alice" or "@org/acme")
+* @returns The encryption key, or undefined if not configured
+*/
+async function getEncryptionKey(scope) {
+	const envSuffix = scope.replace(/^@/, "").replace(/\//g, "_").toUpperCase();
+	const envKey = process.env[`PSPM_ENCRYPTION_KEY_${envSuffix}`];
+	if (envKey) return envKey;
+	return (await readUserConfig()).encryptionKeys?.[scope];
+}
+/**
+* Set the encryption key for a given scope in ~/.pspmrc.
+*
+* @param scope - The scope (e.g., "@user/alice" or "@org/acme")
+* @param key - The encryption passphrase
+*/
+async function setEncryptionKey(scope, key) {
+	const config = await readUserConfig();
+	if (!config.encryptionKeys) config.encryptionKeys = {};
+	config.encryptionKeys[scope] = key;
+	await writeUserConfig(config);
+}
+/**
+* Remove the encryption key for a given scope from ~/.pspmrc.
+*
+* @param scope - The scope (e.g., "@user/alice" or "@org/acme")
+*/
+async function removeEncryptionKey(scope) {
+	const config = await readUserConfig();
+	if (config.encryptionKeys) {
+		delete config.encryptionKeys[scope];
+		if (Object.keys(config.encryptionKeys).length === 0) config.encryptionKeys = void 0;
+	}
+	await writeUserConfig(config);
+}
+/**
+* Derive the encryption scope from a package specifier.
+*
+* @user/alice/my-skill -> @user/alice
+* @org/acme/tool -> @org/acme
+*/
+function getEncryptionScope(namespace, owner) {
+	return `@${namespace}/${owner}`;
+}
+//#endregion
+//#region src/config.ts
+const DEFAULT_REGISTRY_URL = "https://registry.pspm.dev";
+/**
+* Get the user config file path (~/.pspmrc)
+*/
+function getConfigPath() {
+	return join(homedir(), ".pspmrc");
+}
+/**
+* Get the legacy config file path (~/.pspm/config.json) for migration
+*/
+function getLegacyConfigPath() {
+	return join(homedir(), ".pspm", "config.json");
+}
+let _globalMode = false;
+/**
+* Set global mode. When enabled, all path functions return
+* home-directory paths (~/.pspm/) instead of project-relative paths.
+*/
+function setGlobalMode(global) {
+	_globalMode = global;
+}
+/**
+* Check if global mode is enabled.
+*/
+function isGlobalMode() {
+	return _globalMode;
+}
+/**
+* Get the .pspm directory path
+* Global: ~/.pspm/
+* Project: ./.pspm/
+*/
+function getPspmDir() {
+	if (_globalMode) return join(homedir(), ".pspm");
+	return join(process.cwd(), ".pspm");
+}
+/**
+* Get the skills directory path
+* Global: ~/.pspm/skills/
+* Project: ./.pspm/skills/
+*/
+function getSkillsDir() {
+	return join(getPspmDir(), "skills");
+}
+/**
+* Get the cache directory path
+* Global: ~/.pspm/cache/
+* Project: ./.pspm/cache/
+*/
+function getCacheDir() {
+	return join(getPspmDir(), "cache");
+}
+/**
+* Get the lockfile path
+* Global: ~/.pspm/pspm-lock.json
+* Project: ./pspm-lock.json
+*/
+function getLockfilePath() {
+	if (_globalMode) return join(homedir(), ".pspm", "pspm-lock.json");
+	return join(process.cwd(), "pspm-lock.json");
+}
+/**
+* Get the legacy lockfile path (for migration)
+*/
+function getLegacyLockfilePath() {
+	return join(process.cwd(), "skill-lock.json");
+}
+/**
+* Get the legacy skills directory path (for migration)
+*/
+function getLegacySkillsDir() {
+	return join(process.cwd(), ".skills");
+}
+/**
+* Read the user config file (~/.pspmrc, INI format)
+*
+* Supports npm-style configuration:
+* ```ini
+* ; Default registry and auth
+* registry = https://pspm.dev
+* authToken = sk_default
+*
+* ; Scope mappings
+* @myorg:registry = https://corp.pspm.io
+*
+* ; Per-registry tokens
+* //pspm.dev:authToken = sk_public
+* //corp.pspm.io:authToken = sk_corp
+* ```
+*/
+async function readUserConfig() {
+	const configPath = getConfigPath();
+	if (process.env.PSPM_DEBUG) console.log(`[config] Reading config from: ${configPath}`);
+	try {
+		const content = await readFile(configPath, "utf-8");
+		const parsed = ini.parse(content);
+		if (process.env.PSPM_DEBUG) console.log("[config] Parsed config:", JSON.stringify(parsed, null, 2));
+		const scopedRegistries = {};
+		for (const key of Object.keys(parsed)) {
+			const scopeMatch = key.match(/^(@[^:]+):registry$/);
+			if (scopeMatch) {
+				const scope = scopeMatch[1];
+				scopedRegistries[scope] = parsed[key];
+			}
+		}
+		const registryTokens = {};
+		for (const key of Object.keys(parsed)) {
+			const tokenMatch = key.match(/^\/\/([^:]+):authToken$/);
+			if (tokenMatch) {
+				const host = tokenMatch[1];
+				registryTokens[host] = parsed[key];
+			}
+			if (key.startsWith("//") && typeof parsed[key] === "object") {
+				const host = key.slice(2);
+				const section = parsed[key];
+				if (section.authToken) registryTokens[host] = section.authToken;
+			}
+		}
+		const encryptionKeys = {};
+		for (const key of Object.keys(parsed)) {
+			const encKeyMatch = key.match(/^encryption-key:(.+)$/);
+			if (encKeyMatch) {
+				const scope = encKeyMatch[1];
+				encryptionKeys[scope] = parsed[key];
+			}
+		}
+		return {
+			registry: parsed.registry,
+			authToken: parsed.authToken,
+			username: parsed.username,
+			scopedRegistries: Object.keys(scopedRegistries).length > 0 ? scopedRegistries : void 0,
+			registryTokens: Object.keys(registryTokens).length > 0 ? registryTokens : void 0,
+			encryptionKeys: Object.keys(encryptionKeys).length > 0 ? encryptionKeys : void 0
+		};
+	} catch (error) {
+		if (process.env.PSPM_DEBUG) console.log(`[config] Error reading config: ${error instanceof Error ? error.message : String(error)}`);
+		return {};
+	}
+}
+/**
+* Write the user config file (~/.pspmrc, INI format)
+*/
+async function writeUserConfig(config) {
+	const configPath = getConfigPath();
+	const lines = ["; PSPM Configuration", ""];
+	if (config.registry) lines.push(`registry = ${config.registry}`);
+	if (config.authToken) lines.push(`authToken = ${config.authToken}`);
+	if (config.username) lines.push(`username = ${config.username}`);
+	if (config.encryptionKeys && Object.keys(config.encryptionKeys).length > 0) {
+		lines.push("; Encryption keys (scope -> passphrase)");
+		for (const [scope, key] of Object.entries(config.encryptionKeys)) lines.push(`encryption-key:${scope} = ${key}`);
+	}
+	lines.push("");
+	await mkdir(dirname(configPath), { recursive: true });
+	await writeFile(configPath, lines.join("\n"));
+	if (process.env.PSPM_DEBUG) console.log(`[config] Wrote config to: ${configPath}`);
+}
+/**
+* Find and read project config (.pspmrc) by searching up directory tree
+*/
+async function findProjectConfig() {
+	let currentDir = process.cwd();
+	const root = dirname(currentDir);
+	while (currentDir !== root) {
+		const configPath = join(currentDir, ".pspmrc");
+		try {
+			if ((await stat(configPath)).isFile()) {
+				const content = await readFile(configPath, "utf-8");
+				try {
+					const parsed = ini.parse(content);
+					if (process.env.PSPM_DEBUG) console.log(`[config] Found project config at ${configPath}:`, JSON.stringify(parsed, null, 2));
+					return { registry: parsed.registry };
+				} catch {
+					try {
+						return { registry: JSON.parse(content).registryUrl };
+					} catch {}
+				}
+			}
+		} catch {}
+		currentDir = dirname(currentDir);
+	}
+	return null;
+}
+/**
+* Migrate from legacy config format (~/.pspm/config.json) if it exists
+*/
+async function migrateFromLegacyConfig() {
+	const legacyPath = getLegacyConfigPath();
+	try {
+		const content = await readFile(legacyPath, "utf-8");
+		const parsed = JSON.parse(content);
+		let config = {};
+		if (parsed.version === 2 && parsed.profiles) {
+			const v2Config = parsed;
+			const defaultProfileName = v2Config.defaultProfile || "default";
+			const profile = v2Config.profiles[defaultProfileName];
+			if (profile) config = {
+				registry: profile.registryUrl !== "https://registry.pspm.dev" ? profile.registryUrl : void 0,
+				authToken: profile.apiKey,
+				username: profile.username
+			};
+			console.log(`Migrating from legacy config (profile: ${defaultProfileName})...`);
+		} else {
+			const v1Config = parsed;
+			config = {
+				registry: v1Config.registryUrl !== "https://registry.pspm.dev" ? v1Config.registryUrl : void 0,
+				authToken: v1Config.apiKey,
+				username: v1Config.username
+			};
+			console.log("Migrating from legacy config...");
+		}
+		await writeUserConfig(config);
+		console.log(`Created new config at: ${getConfigPath()}`);
+		await unlink(legacyPath);
+		console.log(`Removed legacy config: ${legacyPath}`);
+		return config;
+	} catch {
+		return null;
+	}
+}
+/**
+* Resolve the full configuration using cascade priority:
+* 1. Environment variables (PSPM_REGISTRY_URL, PSPM_API_KEY)
+* 2. Project config (.pspmrc in project directory)
+* 3. User config (~/.pspmrc)
+* 4. Defaults
+*/
+async function resolveConfig() {
+	const newConfigPath = getConfigPath();
+	try {
+		await stat(newConfigPath);
+	} catch {
+		await migrateFromLegacyConfig();
+	}
+	const userConfig = await readUserConfig();
+	const projectConfig = await findProjectConfig();
+	let registryUrl = DEFAULT_REGISTRY_URL;
+	let apiKey = userConfig.authToken;
+	const username = userConfig.username;
+	const scopedRegistries = userConfig.scopedRegistries ?? {};
+	const registryTokens = userConfig.registryTokens ?? {};
+	if (userConfig.registry) registryUrl = userConfig.registry;
+	if (projectConfig?.registry) registryUrl = projectConfig.registry;
+	if (process.env.PSPM_REGISTRY_URL) registryUrl = process.env.PSPM_REGISTRY_URL;
+	if (process.env.PSPM_API_KEY) apiKey = process.env.PSPM_API_KEY;
+	if (process.env.PSPM_DEBUG) {
+		console.log("[config] Resolved config:");
+		console.log(`[config]   registryUrl: ${registryUrl}`);
+		console.log(`[config]   apiKey: ${apiKey ? "***" : "(not set)"}`);
+		console.log(`[config]   username: ${username || "(not set)"}`);
+		console.log(`[config]   scopedRegistries: ${JSON.stringify(scopedRegistries)}`);
+		console.log(`[config]   registryTokens: ${Object.keys(registryTokens).length} configured`);
+	}
+	return {
+		registryUrl,
+		apiKey,
+		username,
+		scopedRegistries,
+		registryTokens
+	};
+}
+//#endregion
+export { setCredentials as C, requireApiKey as S, extractApiErrorMessage as T, getEncryptionScope as _, getLegacyLockfilePath as a, isLoggedIn as b, getPspmDir as c, readUserConfig as d, resolveConfig as f, getEncryptionKey as g, clearCredentials as h, getConfigPath as i, getSkillsDir as l, writeUserConfig as m, findProjectConfig as n, getLegacySkillsDir as o, setGlobalMode as p, getCacheDir as r, getLockfilePath as s, DEFAULT_REGISTRY_URL as t, isGlobalMode as u, getRegistryUrl as v, setEncryptionKey as w, removeEncryptionKey as x, getTokenForRegistry as y };

package/dist/config-BZJ6_GsC.js

@@ -0,0 +1,2 @@
+import { f as resolveConfig, g as getEncryptionKey, p as setGlobalMode, w as setEncryptionKey, x as removeEncryptionKey } from "./config-BQy_Rjip.js";
+export { getEncryptionKey, removeEncryptionKey, resolveConfig, setEncryptionKey, setGlobalMode };