@lpm-registry/cli 0.2.0

package/lib/commands/config.js

@@ -0,0 +1,174 @@
+/**
+ * Config Command
+ *
+ * Manage CLI configuration values.
+ *
+ * Usage:
+ *   lpm config list              List all configuration values
+ *   lpm config get <key>         Get a specific config value
+ *   lpm config set <key> <value> Set a config value
+ *   lpm config delete <key>      Delete a config value (reset to default)
+ *
+ * Configurable Keys:
+ *   registry  - Registry URL (default: https://lpm.dev)
+ *   timeout   - Request timeout in milliseconds (default: 30000)
+ *   retries   - Maximum retry attempts (default: 3)
+ *
+ * @module cli/lib/commands/config
+ */
+
+import chalk from "chalk"
+import {
+	deleteConfigValue,
+	getAllConfig,
+	getConfigValue,
+	setConfigValue,
+} from "../config.js"
+
+/**
+ * List all configuration values.
+ */
+async function listConfig() {
+	console.log(chalk.bold("\nLPM Configuration:\n"))
+
+	const config = await getAllConfig()
+
+	// Format and display each config value
+	const entries = [
+		["Registry URL", config.registryUrl],
+		["Request Timeout", `${config.timeout}ms`],
+		["Max Retries", config.retries],
+		["Secure Storage", config.secureStorage],
+		[
+			"Authenticated",
+			config.authenticated ? chalk.green("Yes") : chalk.dim("No"),
+		],
+	]
+
+	const maxKeyLength = Math.max(...entries.map(([key]) => key.length))
+
+	for (const [key, value] of entries) {
+		const paddedKey = key.padEnd(maxKeyLength)
+		console.log(`  ${chalk.cyan(paddedKey)}  ${value}`)
+	}
+
+	console.log("")
+}
+
+/**
+ * Get a specific configuration value.
+ * @param {string} key - The config key to get
+ */
+function getConfig(key) {
+	const value = getConfigValue(key)
+
+	if (value === undefined) {
+		console.log(chalk.yellow(`Configuration key '${key}' is not set.`))
+		return
+	}
+
+	console.log(value)
+}
+
+/**
+ * Set a configuration value.
+ * @param {string} key - The config key to set
+ * @param {string} value - The value to set
+ */
+function setConfig(key, value) {
+	// Validate known keys
+	const numericKeys = ["timeout", "retries"]
+	if (numericKeys.includes(key)) {
+		const numValue = parseInt(value, 10)
+		if (Number.isNaN(numValue) || numValue < 0) {
+			console.error(chalk.red(`Error: '${key}' must be a positive number.`))
+			process.exit(1)
+		}
+	}
+
+	// Validate registry URL
+	if (key === "registry" || key === "registryUrl") {
+		try {
+			new URL(value)
+		} catch {
+			console.error(chalk.red(`Error: '${value}' is not a valid URL.`))
+			process.exit(1)
+		}
+	}
+
+	const success = setConfigValue(key, value)
+
+	if (success) {
+		console.log(chalk.green(`Set ${key} = ${value}`))
+	} else {
+		console.error(chalk.red(`Failed to set '${key}'.`))
+		process.exit(1)
+	}
+}
+
+/**
+ * Delete a configuration value (reset to default).
+ * @param {string} key - The config key to delete
+ */
+function deleteConfig(key) {
+	const success = deleteConfigValue(key)
+
+	if (success) {
+		console.log(chalk.green(`Reset '${key}' to default value.`))
+	} else {
+		console.error(chalk.red(`Failed to delete '${key}'.`))
+		process.exit(1)
+	}
+}
+
+/**
+ * Execute the config command.
+ *
+ * @param {string} action - The action to perform (list, get, set, delete)
+ * @param {string} [key] - The config key
+ * @param {string} [value] - The value to set
+ */
+export async function config(action, key, value) {
+	switch (action) {
+		case "list":
+		case undefined:
+			await listConfig()
+			break
+
+		case "get":
+			if (!key) {
+				console.error(chalk.red("Error: Key required."))
+				console.log(chalk.dim("Usage: lpm config get <key>"))
+				process.exit(1)
+			}
+			getConfig(key)
+			break
+
+		case "set":
+			if (!key || value === undefined) {
+				console.error(chalk.red("Error: Key and value required."))
+				console.log(chalk.dim("Usage: lpm config set <key> <value>"))
+				process.exit(1)
+			}
+			setConfig(key, value)
+			break
+
+		case "delete":
+		case "rm":
+		case "remove":
+			if (!key) {
+				console.error(chalk.red("Error: Key required."))
+				console.log(chalk.dim("Usage: lpm config delete <key>"))
+				process.exit(1)
+			}
+			deleteConfig(key)
+			break
+
+		default:
+			console.error(chalk.red(`Unknown action: ${action}`))
+			console.log(chalk.dim("Available actions: list, get, set, delete"))
+			process.exit(1)
+	}
+}
+
+export default config

package/lib/commands/doctor.js

@@ -0,0 +1,142 @@
+import fs from "node:fs"
+import path from "node:path"
+import chalk from "chalk"
+import { getRegistryUrl, getToken } from "../config.js"
+import { createSpinner, log, printHeader } from "../ui.js"
+
+export async function doctor() {
+	printHeader()
+	log.info("Running health checks...\n")
+
+	const checks = []
+
+	// 1. Check Auth
+	const spinnerAuth = createSpinner("Checking authentication...").start()
+	const token = await getToken()
+	if (token) {
+		spinnerAuth.succeed("Authentication token found.")
+		checks.push({ name: "Auth Token", status: "ok" })
+	} else {
+		spinnerAuth.fail("No authentication token found. Run `lpm login`.")
+		checks.push({ name: "Auth Token", status: "fail" })
+	}
+
+	// 2. Check Registry Reachability
+	const spinnerApi = createSpinner("Checking registry connection...").start()
+	try {
+		// Assuming we have a health endpoint or similar. Using the registry URL from config or default.
+		const registryUrl = getRegistryUrl()
+		const res = await fetch(`${registryUrl}/api/registry/health`)
+		if (res.ok) {
+			spinnerApi.succeed(`Registry reachable at ${registryUrl}`)
+			checks.push({ name: "Registry API", status: "ok" })
+		} else {
+			spinnerApi.fail(`Registry returned status ${res.status}`)
+			checks.push({ name: "Registry API", status: "fail" })
+		}
+	} catch (err) {
+		spinnerApi.fail(`Could not connect to registry: ${err.message}`)
+		checks.push({ name: "Registry API", status: "fail" })
+	}
+
+	// 3. Check Quota (via whoami)
+	if (token) {
+		const spinnerQuota = createSpinner("Checking account quota...").start()
+		try {
+			// We can reuse the whoami logic or fetch directly
+			// Since we are in doctor, let's fetch directly using the token
+			const registryUrl = getRegistryUrl()
+			const res = await fetch(`${registryUrl}/api/registry/-/whoami`, {
+				headers: {
+					Authorization: `Bearer ${token}`,
+				},
+			})
+
+			if (res.ok) {
+				const data = await res.json()
+				if (data.plan_tier) {
+					const limits = data.limits || {}
+					let isOverLimit = false
+					const statusMsg = `Plan: ${data.plan_tier.toUpperCase()}`
+
+					if (limits.storageBytes) {
+						if (data.usage.storage_bytes > limits.storageBytes)
+							isOverLimit = true
+					}
+					if (
+						limits.privatePackages &&
+						limits.privatePackages !== Number.POSITIVE_INFINITY &&
+						limits.privatePackages !== null
+					) {
+						if (data.usage.private_packages > limits.privatePackages)
+							isOverLimit = true
+					}
+
+					if (isOverLimit) {
+						spinnerQuota.fail(`${statusMsg} | OVER LIMIT`)
+						checks.push({ name: "Account Quota", status: "fail" })
+					} else {
+						spinnerQuota.succeed(
+							`${statusMsg} | Storage: ${(data.usage.storage_bytes / 1024 / 1024).toFixed(0)}MB`,
+						)
+						checks.push({ name: "Account Quota", status: "ok" })
+					}
+				} else {
+					spinnerQuota.info("Could not retrieve detailed quota info.")
+					checks.push({ name: "Account Quota", status: "info" })
+				}
+			} else {
+				spinnerQuota.warn("Could not fetch account details.")
+				checks.push({ name: "Account Quota", status: "warn" })
+			}
+		} catch (err) {
+			spinnerQuota.warn(`Quota check failed: ${err.message}`)
+			checks.push({ name: "Account Quota", status: "warn" })
+		}
+	}
+
+	// 4. Check .npmrc
+	const spinnerNpmrc = createSpinner("Checking .npmrc configuration...").start()
+	const npmrcPath = path.join(process.cwd(), ".npmrc")
+	if (fs.existsSync(npmrcPath)) {
+		const content = fs.readFileSync(npmrcPath, "utf-8")
+		if (content.includes("registry=")) {
+			spinnerNpmrc.succeed(".npmrc found and configured.")
+			checks.push({ name: ".npmrc", status: "ok" })
+		} else {
+			spinnerNpmrc.warn(".npmrc found but might be missing registry config.")
+			checks.push({ name: ".npmrc", status: "warn" })
+		}
+	} else {
+		spinnerNpmrc.info("No local .npmrc found (global config might be used).")
+		checks.push({ name: ".npmrc", status: "info" })
+	}
+
+	console.log("\nSummary:")
+	checks.forEach(c => {
+		const symbol =
+			c.status === "ok"
+				? "✔"
+				: c.status === "fail"
+					? "✖"
+					: c.status === "warn"
+						? "⚠"
+						: "ℹ"
+		const color =
+			c.status === "ok"
+				? chalk.green
+				: c.status === "fail"
+					? chalk.red
+					: c.status === "warn"
+						? chalk.yellow
+						: chalk.blue
+		console.log(color(`${symbol} ${c.name}`))
+	})
+
+	if (checks.some(c => c.status === "fail")) {
+		console.log(chalk.red("\nSome checks failed. Please fix the issues above."))
+		process.exit(1)
+	} else {
+		console.log(chalk.green("\nAll systems operational."))
+	}
+}

package/lib/commands/info.js

@@ -0,0 +1,215 @@
+/**
+ * Info Command
+ *
+ * Display detailed information about a package.
+ *
+ * Usage:
+ *   lpm info <package> [options]
+ *
+ * Options:
+ *   --json      Output in JSON format
+ *   --versions  Show all versions
+ *
+ * @module cli/lib/commands/info
+ */
+
+import chalk from "chalk"
+import ora from "ora"
+import { get } from "../api.js"
+
+/**
+ * Parse a package specifier.
+ * @param {string} specifier - Package name (e.g., '@scope/name', 'name', 'name@1.0.0')
+ * @returns {{ name: string, scope?: string, version?: string }}
+ */
+function parsePackageSpecifier(specifier) {
+	let name = specifier
+	let scope
+	let version
+
+	// Handle version specifier
+	const versionMatch = name.match(/^(.+)@(\d+\.\d+\.\d+.*)$/)
+	if (versionMatch) {
+		name = versionMatch[1]
+		version = versionMatch[2]
+	}
+
+	// Handle scope
+	if (name.startsWith("@")) {
+		const scopeMatch = name.match(/^@([^/]+)\/(.+)$/)
+		if (scopeMatch) {
+			scope = scopeMatch[1]
+			name = scopeMatch[2]
+		}
+	}
+
+	return { name, scope, version }
+}
+
+/**
+ * Format a date for display.
+ * @param {string} dateStr
+ * @returns {string}
+ */
+function formatDate(dateStr) {
+	const date = new Date(dateStr)
+	return date.toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric",
+	})
+}
+
+/**
+ * Execute the info command.
+ *
+ * @param {string} packageSpec - Package specifier
+ * @param {Object} options - Command options
+ * @param {boolean} [options.json] - Output as JSON
+ * @param {boolean} [options.versions] - Show all versions
+ */
+export async function info(packageSpec, options = {}) {
+	if (!packageSpec || packageSpec.trim() === "") {
+		console.error(chalk.red("Error: Package name required."))
+		console.log(chalk.dim("Usage: lpm info <package>"))
+		process.exit(1)
+	}
+
+	const { name, scope, version } = parsePackageSpecifier(packageSpec)
+	const packagePath = scope ? `@${scope}/${name}` : name
+
+	const spinner = ora(`Fetching info for ${packagePath}...`).start()
+
+	try {
+		// Registry uses NPM-compatible paths: /@scope/pkg or /@scope/pkg/version
+		const url = version
+			? `/${encodeURIComponent(packagePath)}/${version}`
+			: `/${encodeURIComponent(packagePath)}`
+
+		const response = await get(url, {
+			onRetry: (attempt, max) => {
+				spinner.text = `Fetching (retry ${attempt}/${max})...`
+			},
+		})
+
+		if (!response.ok) {
+			if (response.status === 404) {
+				throw new Error(`Package "${packagePath}" not found.`)
+			}
+			const data = await response.json().catch(() => ({}))
+			throw new Error(data.error || `Failed to fetch package info.`)
+		}
+
+		const pkg = await response.json()
+
+		spinner.stop()
+
+		if (options.json) {
+			console.log(JSON.stringify(pkg, null, 2))
+			return
+		}
+
+		// Get latest version data from versions object
+		const latestVersionTag = pkg["dist-tags"]?.latest
+		const latestVersionData = latestVersionTag
+			? pkg.versions?.[latestVersionTag]
+			: null
+
+		// Display package info
+		const fullName = pkg.name
+
+		console.log("")
+		console.log(
+			chalk.bold.cyan(fullName) +
+				chalk.dim(`@${pkg.latestVersion || latestVersionTag || "no versions"}`),
+		)
+		console.log("")
+
+		if (pkg.description) {
+			console.log(chalk.white(pkg.description))
+			console.log("")
+		}
+
+		// Metadata table
+		const metadata = [
+			["Latest Version", pkg.latestVersion || latestVersionTag || "N/A"],
+			["License", latestVersionData?.license || pkg.license || "N/A"],
+			["Author", latestVersionData?.author || pkg.author || "N/A"],
+			["Published", pkg.publishedAt ? formatDate(pkg.publishedAt) : "N/A"],
+			["Downloads", (pkg.downloads ?? 0).toLocaleString()],
+		]
+
+		if (latestVersionData?.repository || pkg.repository) {
+			metadata.push([
+				"Repository",
+				latestVersionData?.repository || pkg.repository,
+			])
+		}
+
+		if (latestVersionData?.homepage || pkg.homepage) {
+			metadata.push(["Homepage", latestVersionData?.homepage || pkg.homepage])
+		}
+
+		const maxKeyLength = Math.max(...metadata.map(([key]) => key.length))
+
+		for (const [key, value] of metadata) {
+			const paddedKey = key.padEnd(maxKeyLength)
+			console.log(`  ${chalk.dim(paddedKey)}  ${value}`)
+		}
+
+		console.log("")
+
+		// Dependencies from latest version
+		const deps = latestVersionData?.dependencies || pkg.dependencies
+		if (deps && Object.keys(deps).length > 0) {
+			console.log(chalk.bold("Dependencies:"))
+			for (const [dep, ver] of Object.entries(deps)) {
+				console.log(`  ${chalk.cyan(dep)}  ${chalk.dim(ver)}`)
+			}
+			console.log("")
+		}
+
+		// Show versions if requested (versions is an object, not array)
+		if (
+			options.allVersions &&
+			pkg.versions &&
+			Object.keys(pkg.versions).length > 0
+		) {
+			console.log(chalk.bold("Versions:"))
+			const versionList = Object.keys(pkg.versions).reverse().slice(0, 20)
+			for (const v of versionList) {
+				const date = pkg.time?.[v] ? formatDate(pkg.time[v]) : ""
+				console.log(`  ${chalk.green(v)}  ${chalk.dim(date)}`)
+			}
+			if (Object.keys(pkg.versions).length > 20) {
+				console.log(
+					chalk.dim(
+						`  ... and ${Object.keys(pkg.versions).length - 20} more versions`,
+					),
+				)
+			}
+			console.log("")
+		}
+
+		// Keywords
+		const keywords = latestVersionData?.keywords || pkg.keywords
+		if (keywords && keywords.length > 0) {
+			console.log(
+				chalk.bold("Keywords:") +
+					" " +
+					keywords.map(k => chalk.dim(k)).join(", "),
+			)
+			console.log("")
+		}
+
+		// Install hint
+		console.log(chalk.dim(`Install: lpm install ${fullName}`))
+		console.log("")
+	} catch (error) {
+		spinner.fail(chalk.red("Failed to fetch package info."))
+		console.error(chalk.red(`  ${error.message}`))
+		process.exit(1)
+	}
+}
+
+export default info

package/lib/commands/init.js

@@ -0,0 +1,146 @@
+import fs from "node:fs"
+import path from "node:path"
+import * as p from "@clack/prompts"
+import chalk from "chalk"
+import { getRegistryUrl } from "../config.js"
+import { printHeader } from "../ui.js"
+import { setup } from "./setup.js"
+
+/**
+ * Parse package name in the @lpm.dev/owner.package format
+ */
+function parsePackageName(name) {
+	if (!name.startsWith("@lpm.dev/")) {
+		return { error: "Package name must start with @lpm.dev/" }
+	}
+
+	const nameWithOwner = name.replace("@lpm.dev/", "")
+	const dotIndex = nameWithOwner.indexOf(".")
+
+	if (dotIndex === -1) {
+		return { error: "Format: @lpm.dev/owner.package-name" }
+	}
+
+	const owner = nameWithOwner.substring(0, dotIndex)
+	const pkgName = nameWithOwner.substring(dotIndex + 1)
+
+	// Validate owner format
+	if (!/^[a-z][a-z0-9-]*$/.test(owner)) {
+		return {
+			error:
+				"Owner must start with a letter and contain only lowercase letters, numbers, and hyphens",
+		}
+	}
+
+	// Validate package name format
+	if (!/^[a-z][a-z0-9-]*$/.test(pkgName)) {
+		return {
+			error:
+				"Package name must start with a letter and contain only lowercase letters, numbers, and hyphens",
+		}
+	}
+
+	return { owner, name: pkgName }
+}
+
+export async function init() {
+	printHeader()
+
+	p.intro(chalk.bgCyan(chalk.black(" lpm init ")))
+
+	const project = await p.group(
+		{
+			name: () =>
+				p.text({
+					message: "What is the name of your package?",
+					placeholder: "@lpm.dev/username.package-name",
+					validate: value => {
+						if (!value) return "Name is required"
+						const parsed = parsePackageName(value)
+						if (parsed.error) return parsed.error
+					},
+				}),
+			version: () =>
+				p.text({
+					message: "Version",
+					initialValue: "0.1.0",
+				}),
+			description: () =>
+				p.text({
+					message: "Description",
+					placeholder: "A brief description of your package",
+				}),
+			entry: () =>
+				p.text({
+					message: "Entry point",
+					initialValue: "index.js",
+				}),
+			license: () =>
+				p.select({
+					message: "License type",
+					options: [
+						{ value: "ISC", label: "ISC" },
+						{ value: "MIT", label: "MIT" },
+						{ value: "UNLICENSED", label: "UNLICENSED (Private/Proprietary)" },
+					],
+				}),
+			confirm: () =>
+				p.confirm({
+					message: "Create package.json?",
+					initialValue: true,
+				}),
+		},
+		{
+			onCancel: () => {
+				p.cancel("Operation cancelled.")
+				process.exit(0)
+			},
+		},
+	)
+
+	if (project.confirm) {
+		const registryUrl = getRegistryUrl()
+		const packageJson = {
+			name: project.name,
+			version: project.version,
+			description: project.description,
+			main: project.entry,
+			scripts: {
+				test: 'echo "Error: no test specified" && exit 1',
+			},
+			author: "",
+			license: project.license,
+			publishConfig: {
+				registry: `${registryUrl}/api/registry/`,
+			},
+		}
+
+		const filePath = path.join(process.cwd(), "package.json")
+		fs.writeFileSync(filePath, JSON.stringify(packageJson, null, 2))
+
+		p.note(JSON.stringify(packageJson, null, 2), "package.json")
+
+		// Offer to setup .npmrc
+		const npmrcPath = path.join(process.cwd(), ".npmrc")
+		if (
+			!fs.existsSync(npmrcPath) ||
+			!fs.readFileSync(npmrcPath, "utf8").includes("@lpm.dev:registry")
+		) {
+			const setupNpmrc = await p.confirm({
+				message: "Create .npmrc for local development?",
+				initialValue: true,
+			})
+
+			if (!p.isCancel(setupNpmrc) && setupNpmrc) {
+				await setup({ registry: registryUrl })
+				return
+			}
+		}
+
+		p.outro(
+			`Package initialized! Run ${chalk.cyan("lpm publish")} to push to the registry.`,
+		)
+	} else {
+		p.outro("Cancelled.")
+	}
+}