@lpm-registry/cli 0.2.0

package/lib/commands/marketplace-compare.js

@@ -0,0 +1,164 @@
+import chalk from "chalk"
+import ora from "ora"
+import { get } from "../api.js"
+
+/**
+ * Format cents to a dollar string.
+ * @param {number} cents
+ * @returns {string}
+ */
+function formatCents(cents) {
+	if (!cents && cents !== 0) return "—"
+	return `$${(cents / 100).toFixed(2)}`
+}
+
+/**
+ * Parse package name to extract category or clean name.
+ * @param {string} input
+ * @returns {{ isPackage: boolean, owner?: string, name?: string, category?: string }}
+ */
+function parseInput(input) {
+	let cleaned = input
+	if (cleaned.startsWith("@lpm.dev/")) {
+		cleaned = cleaned.replace("@lpm.dev/", "")
+	}
+	const dotIndex = cleaned.indexOf(".")
+	if (dotIndex > 0 && dotIndex < cleaned.length - 1) {
+		return {
+			isPackage: true,
+			owner: cleaned.substring(0, dotIndex),
+			name: cleaned.substring(dotIndex + 1),
+		}
+	}
+	// Treat as category/keyword
+	return { isPackage: false, category: input }
+}
+
+/**
+ * Find and display comparable marketplace packages.
+ *
+ * @param {string} input - Package name or category
+ * @param {Object} [options]
+ * @param {boolean} [options.json] - Output as JSON
+ * @param {string} [options.category] - Filter by category
+ * @param {number} [options.limit] - Max results
+ */
+export async function marketplaceCompare(input, options = {}) {
+	if (!input || input.trim() === "") {
+		if (options.json) {
+			console.log(
+				JSON.stringify({ error: "Package name or category required." }),
+			)
+		} else {
+			console.error(chalk.red("Error: Package name or category required."))
+			console.log(
+				chalk.dim("Usage: lpm marketplace compare owner.package-name"),
+			)
+			console.log(
+				chalk.dim("       lpm marketplace compare --category ui-components"),
+			)
+		}
+		process.exit(1)
+	}
+
+	const parsed = parseInput(input.trim())
+	const category =
+		options.category || (parsed.isPackage ? null : parsed.category)
+	const query = parsed.isPackage ? parsed.name : null
+
+	const params = new URLSearchParams()
+	if (category) params.set("category", category)
+	if (query) params.set("q", query)
+	if (options.limit) params.set("limit", String(options.limit))
+
+	const spinner = options.json
+		? null
+		: ora("Fetching comparable packages...").start()
+
+	try {
+		const response = await get(
+			`/marketplace/comparables?${params.toString()}`,
+			{
+				onRetry: spinner
+					? (attempt, max) => {
+							spinner.text = `Fetching (retry ${attempt}/${max})...`
+						}
+					: undefined,
+			},
+		)
+
+		const data = await response.json().catch(() => ({}))
+
+		if (!response.ok) {
+			throw new Error(data.error || `Request failed: ${response.status}`)
+		}
+
+		if (options.json) {
+			console.log(JSON.stringify(data, null, 2))
+			return
+		}
+
+		if (spinner) spinner.stop()
+
+		const comparables = data.comparables || []
+
+		console.log("")
+		if (category) {
+			console.log(chalk.bold(`  Marketplace: ${category}`))
+		} else if (parsed.isPackage) {
+			console.log(
+				chalk.bold(`  Similar to: @lpm.dev/${parsed.owner}.${parsed.name}`),
+			)
+		}
+
+		if (data.stats?.priceRange) {
+			const pr = data.stats.priceRange
+			console.log(
+				chalk.dim(
+					`  Price range: ${formatCents(pr.minCents)} — ${formatCents(pr.maxCents)} (median: ${formatCents(pr.medianCents)})`,
+				),
+			)
+		}
+		console.log(chalk.dim(`  ${data.stats?.total || 0} packages found`))
+		console.log("")
+
+		if (comparables.length === 0) {
+			console.log(chalk.dim("  No comparable packages found."))
+			console.log("")
+			return
+		}
+
+		// Table
+		const nameWidth = Math.max(30, ...comparables.map(c => c.name.length + 2))
+		console.log(
+			`  ${chalk.dim("Package".padEnd(nameWidth))}${chalk.dim("Price".padStart(10))}${chalk.dim("Quality".padStart(10))}${chalk.dim("Downloads".padStart(12))}${chalk.dim("Mode".padStart(14))}`,
+		)
+		console.log(chalk.dim(`  ${"─".repeat(nameWidth + 46)}`))
+
+		for (const pkg of comparables) {
+			const name = pkg.name.padEnd(nameWidth)
+			const price = pkg.pricing
+				? formatCents(pkg.pricing.minPriceCents).padStart(10)
+				: chalk.dim("Pool".padStart(10))
+			const quality =
+				pkg.qualityScore !== null
+					? `${pkg.qualityScore}/100`.padStart(10)
+					: chalk.dim("—".padStart(10))
+			const downloads = (pkg.downloadCount || 0).toLocaleString().padStart(12)
+			const mode = pkg.distributionMode.padStart(14)
+			console.log(`  ${name}${price}${quality}${downloads}${chalk.dim(mode)}`)
+		}
+
+		console.log("")
+	} catch (error) {
+		if (spinner) spinner.fail(chalk.red("Failed to fetch comparable packages."))
+		if (options.json) {
+			console.log(JSON.stringify({ error: error.message }))
+		} else {
+			console.error(chalk.red(`  ${error.message}`))
+		}
+		process.exit(1)
+	}
+}
+
+export default marketplaceCompare

package/lib/commands/marketplace-earnings.js

@@ -0,0 +1,89 @@
+import chalk from "chalk"
+import ora from "ora"
+import { get } from "../api.js"
+
+/**
+ * Format cents to a dollar string.
+ * @param {number} cents
+ * @returns {string}
+ */
+function formatCents(cents) {
+	if (!cents && cents !== 0) return "$0.00"
+	return `$${(cents / 100).toFixed(2)}`
+}
+
+/**
+ * Fetch and display Marketplace earnings for the authenticated user.
+ *
+ * @param {Object} [options]
+ * @param {boolean} [options.json] - Output as JSON
+ */
+export async function marketplaceEarnings(options = {}) {
+	const spinner = options.json
+		? null
+		: ora("Fetching marketplace earnings...").start()
+
+	try {
+		const response = await get("/marketplace/earnings", {
+			skipRetry: false,
+			onRetry: spinner
+				? (attempt, max) => {
+						spinner.text = `Fetching (retry ${attempt}/${max})...`
+					}
+				: undefined,
+		})
+
+		const data = await response.json().catch(() => ({}))
+
+		if (!response.ok) {
+			throw new Error(data.error || `Request failed: ${response.status}`)
+		}
+
+		if (options.json) {
+			console.log(JSON.stringify(data, null, 2))
+			return
+		}
+
+		if (spinner) spinner.stop()
+
+		console.log("")
+		console.log(chalk.bold("  Marketplace Earnings"))
+		console.log("")
+
+		if (!data.totalSales) {
+			console.log(chalk.dim("  No marketplace sales yet."))
+			console.log(
+				chalk.dim(
+					"  Publish a package with Marketplace distribution to start selling.",
+				),
+			)
+			console.log("")
+			return
+		}
+
+		console.log(
+			`  ${chalk.dim("Total Sales:")}      ${data.totalSales.toLocaleString()}`,
+		)
+		console.log(
+			`  ${chalk.dim("Gross Revenue:")}    ${formatCents(data.grossRevenueCents)}`,
+		)
+		console.log(
+			`  ${chalk.dim("Platform Fees:")}    ${chalk.red(formatCents(data.platformFeesCents))}`,
+		)
+		console.log(
+			`  ${chalk.bold("Net Revenue:")}      ${chalk.green(formatCents(data.netRevenueCents))}`,
+		)
+		console.log("")
+	} catch (error) {
+		if (spinner)
+			spinner.fail(chalk.red("Failed to fetch marketplace earnings."))
+		if (options.json) {
+			console.log(JSON.stringify({ error: error.message }))
+		} else {
+			console.error(chalk.red(`  ${error.message}`))
+		}
+		process.exit(1)
+	}
+}
+
+export default marketplaceEarnings

package/lib/commands/mcp-setup.js

@@ -0,0 +1,363 @@
+import { spawnSync } from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import * as p from "@clack/prompts"
+import chalk from "chalk"
+import { getRegistryUrl, getToken } from "../config.js"
+import { DEFAULT_REGISTRY_URL } from "../constants.js"
+import {
+	addMcpServer,
+	EDITORS,
+	getMcpServerConfig,
+	hasMcpServer,
+	removeMcpServerEntry,
+	shortPath,
+} from "../editors.js"
+
+const SERVER_NAME = "lpm-registry"
+
+const MCP_SERVER_PACKAGE = "@lpm-registry/mcp-server"
+const THIS_FILE_DIR = path.dirname(fileURLToPath(import.meta.url))
+const LOCAL_MCP_SERVER_CANDIDATES = [
+	path.resolve(process.cwd(), "mcp-server", "bin", "mcp-server.js"),
+	path.resolve(process.cwd(), "..", "mcp-server", "bin", "mcp-server.js"),
+	path.resolve(
+		THIS_FILE_DIR,
+		"..",
+		"..",
+		"..",
+		"..",
+		"mcp-server",
+		"bin",
+		"mcp-server.js",
+	),
+]
+
+function resolveNpxCommand() {
+	const lookupCommand = process.platform === "win32" ? "where" : "which"
+	const result = spawnSync(lookupCommand, ["npx"], { encoding: "utf-8" })
+
+	if (result.status === 0) {
+		const lines = (result.stdout || "")
+			.split("\n")
+			.map(line => line.trim())
+			.filter(Boolean)
+
+		if (lines.length > 0) {
+			return lines[0]
+		}
+	}
+
+	return "npx"
+}
+
+function getLocalMcpServerPath() {
+	for (const candidate of LOCAL_MCP_SERVER_CANDIDATES) {
+		if (fs.existsSync(candidate)) {
+			return candidate
+		}
+	}
+
+	return null
+}
+
+export function getServerConfig(registryUrl = DEFAULT_REGISTRY_URL) {
+	const localServerPath = getLocalMcpServerPath()
+	const hasCustomRegistry =
+		typeof registryUrl === "string" &&
+		registryUrl.length > 0 &&
+		registryUrl !== DEFAULT_REGISTRY_URL
+
+	const env = hasCustomRegistry ? { LPM_REGISTRY_URL: registryUrl } : undefined
+
+	if (localServerPath) {
+		return {
+			command: process.execPath,
+			args: [localServerPath],
+			...(env ? { env } : {}),
+		}
+	}
+
+	return {
+		command: resolveNpxCommand(),
+		args: ["-y", `${MCP_SERVER_PACKAGE}@latest`],
+		...(env ? { env } : {}),
+	}
+}
+
+function isCommandRunnable(command) {
+	if (!command) return false
+
+	if (path.isAbsolute(command)) {
+		return fs.existsSync(command)
+	}
+
+	const lookupCommand = process.platform === "win32" ? "where" : "which"
+	const result = spawnSync(lookupCommand, [command], { stdio: "ignore" })
+	return result.status === 0
+}
+
+function getEditorStatus(editor, isProject = false) {
+	const configPath =
+		isProject && editor.projectPath
+			? path.resolve(process.cwd(), editor.projectPath)
+			: editor.globalPath
+
+	const entry = getMcpServerConfig(configPath, editor.serverKey, SERVER_NAME)
+	const installed = !!entry
+
+	if (!installed) {
+		return {
+			editor,
+			configPath,
+			installed: false,
+			runnable: false,
+			entry: null,
+		}
+	}
+
+	const command = entry.command
+	const runnable = isCommandRunnable(command)
+
+	return {
+		editor,
+		configPath,
+		installed: true,
+		runnable,
+		entry,
+	}
+}
+
+// ============================================================================
+// Setup command
+// ============================================================================
+
+export async function mcpSetup(options = {}) {
+	p.intro(chalk.bgCyan(chalk.black(" lpm mcp setup ")))
+	const registryUrl = getRegistryUrl()
+	const serverConfig = getServerConfig(registryUrl)
+
+	// Check authentication and offer login
+	let token = await getToken()
+	if (!token) {
+		const shouldLogin = await p.confirm({
+			message:
+				"Not logged in. Login now for full MCP functionality? (recommended)",
+			initialValue: true,
+		})
+
+		if (p.isCancel(shouldLogin)) {
+			p.cancel("Setup cancelled.")
+			process.exit(0)
+		}
+
+		if (shouldLogin) {
+			p.log.info("Opening browser for login...\n")
+			const result = spawnSync("lpm", ["login"], {
+				stdio: "inherit",
+			})
+
+			if (result.status === 0) {
+				token = await getToken()
+			} else {
+				p.log.warn("Login did not complete. Continuing without authentication.")
+			}
+		}
+	}
+
+	const isProject = !!options.project
+
+	// Detect installed editors
+	const detected = EDITORS.filter(e => e.detect())
+
+	if (detected.length === 0) {
+		p.log.warn("No supported editors detected on this machine.")
+		p.note(
+			"Supported: Claude Code, Cursor, VS Code, Claude Desktop, Windsurf",
+			"Supported editors",
+		)
+		p.outro("Install a supported editor and try again.")
+		return
+	}
+
+	// Filter to editors that support project config when --project is used
+	const eligible = isProject ? detected.filter(e => e.projectPath) : detected
+
+	if (eligible.length === 0) {
+		p.log.warn("No detected editors support project-level MCP config.")
+		p.outro(
+			`Try ${chalk.cyan("lpm mcp setup")} without --project for global setup.`,
+		)
+		return
+	}
+
+	// Build multiselect options
+	const selectOptions = eligible.map(editor => {
+		const configPath =
+			isProject && editor.projectPath
+				? path.resolve(process.cwd(), editor.projectPath)
+				: editor.globalPath
+
+		const installed = hasMcpServer(configPath, editor.serverKey, SERVER_NAME)
+
+		return {
+			value: editor.id,
+			label: installed
+				? `${editor.name} ${chalk.dim("(already configured)")}`
+				: editor.name,
+			hint: shortPath(configPath),
+		}
+	})
+
+	const selected = await p.multiselect({
+		message: isProject
+			? "Add LPM MCP server to (project-level):"
+			: "Add LPM MCP server to:",
+		options: selectOptions,
+		initialValues: selectOptions.map(o => o.value),
+		required: true,
+	})
+
+	if (p.isCancel(selected)) {
+		p.cancel("Setup cancelled.")
+		process.exit(0)
+	}
+
+	// Write configs
+	let count = 0
+	for (const editorId of selected) {
+		const editor = EDITORS.find(e => e.id === editorId)
+		const configPath =
+			isProject && editor.projectPath
+				? path.resolve(process.cwd(), editor.projectPath)
+				: editor.globalPath
+
+		try {
+			addMcpServer(configPath, editor.serverKey, SERVER_NAME, {
+				...serverConfig,
+			})
+			p.log.success(`${editor.name} ${chalk.dim(shortPath(configPath))}`)
+			count++
+		} catch (err) {
+			p.log.error(`${editor.name}: ${err.message}`)
+		}
+	}
+
+	if (count > 0) {
+		const authLine = token
+			? `Auth: Using keychain token from ${chalk.cyan("lpm login")}`
+			: `Auth: Run ${chalk.cyan("lpm login")} to enable authenticated tools`
+
+		p.note(authLine, `Added to ${count} editor${count > 1 ? "s" : ""}`)
+
+		if (registryUrl !== DEFAULT_REGISTRY_URL) {
+			p.log.info(
+				`Using custom registry URL for MCP: ${chalk.cyan(registryUrl)}`,
+			)
+		}
+	}
+
+	p.outro("Restart your editors to activate the MCP server.")
+}
+
+// ============================================================================
+// Remove command
+// ============================================================================
+
+export async function mcpRemove(options = {}) {
+	p.intro(chalk.bgCyan(chalk.black(" lpm mcp remove ")))
+
+	const isProject = !!options.project
+	let count = 0
+
+	for (const editor of EDITORS) {
+		if (isProject && !editor.projectPath) continue
+
+		const configPath =
+			isProject && editor.projectPath
+				? path.resolve(process.cwd(), editor.projectPath)
+				: editor.globalPath
+
+		if (removeMcpServerEntry(configPath, editor.serverKey, SERVER_NAME)) {
+			p.log.success(
+				`Removed from ${editor.name} ${chalk.dim(shortPath(configPath))}`,
+			)
+			count++
+		}
+	}
+
+	if (count === 0) {
+		p.log.info("LPM MCP server was not configured in any editor.")
+	}
+
+	p.outro(
+		count > 0 ? "Done. Restart your editors to apply." : "Nothing to remove.",
+	)
+}
+
+// ============================================================================
+// Status command
+// ============================================================================
+
+export async function mcpStatus(options = {}) {
+	p.intro(chalk.bgCyan(chalk.black(" lpm mcp status ")))
+
+	const token = await getToken()
+	const isVerbose = !!options.verbose
+	let found = 0
+	let notRunnable = 0
+
+	for (const editor of EDITORS) {
+		const status = getEditorStatus(editor, false)
+		const globalInstalled = status.installed
+
+		if (globalInstalled) {
+			if (status.runnable) {
+				p.log.success(
+					`${editor.name} ${chalk.dim(shortPath(editor.globalPath))}`,
+				)
+			} else {
+				p.log.warn(
+					`${editor.name} ${chalk.dim(shortPath(editor.globalPath))} ${chalk.dim("(configured, command not found)")}`,
+				)
+				notRunnable++
+			}
+
+			if (isVerbose) {
+				const args = Array.isArray(status.entry?.args) ? status.entry.args : []
+				const command = status.entry?.command || "(missing)"
+				p.log.info(`  command: ${command}`)
+				p.log.info(`  args: ${args.length > 0 ? args.join(" ") : "(none)"}`)
+				if (!status.runnable) {
+					p.log.info(
+						`  hint: use ${chalk.cyan("lpm mcp setup")} again to refresh config on this machine`,
+					)
+				}
+			}
+			found++
+		} else if (isVerbose) {
+			p.log.info(
+				`${editor.name} ${chalk.dim(shortPath(editor.globalPath))} ${chalk.dim("(not configured)")}`,
+			)
+		}
+	}
+
+	if (found === 0) {
+		p.log.info("LPM MCP server is not configured in any editor.")
+		p.note(`Run ${chalk.cyan("lpm mcp setup")} to configure it.`, "Get started")
+	} else if (notRunnable > 0) {
+		p.note(
+			`${notRunnable} configured editor${notRunnable > 1 ? "s" : ""} have a command that is not runnable in this environment.`,
+			"Action needed",
+		)
+	}
+
+	const authStatus = token
+		? chalk.green("Authenticated")
+		: chalk.yellow(`Not logged in — run ${chalk.cyan("lpm login")}`)
+
+	p.log.info(`Auth: ${authStatus}`)
+
+	p.outro("")
+}

package/lib/commands/open.js

@@ -0,0 +1,82 @@
+import fs from "node:fs"
+import path from "node:path"
+import open from "open"
+import { request } from "../api.js"
+import { getRegistryUrl } from "../config.js"
+import { createSpinner } from "../ui.js"
+
+/**
+ * Parse owner from LPM package name.
+ * @param {string} name - Package name (e.g., '@lpm.dev/owner.pkg-name')
+ * @returns {{ owner: string, pkgName: string } | null}
+ */
+function parseOwner(name) {
+	if (name.startsWith("@lpm.dev/")) {
+		const nameWithOwner = name.replace("@lpm.dev/", "")
+		const dotIndex = nameWithOwner.indexOf(".")
+		if (dotIndex === -1) return null
+		return {
+			owner: nameWithOwner.substring(0, dotIndex),
+			pkgName: nameWithOwner.substring(dotIndex + 1),
+		}
+	}
+	return null
+}
+
+export async function openDashboard() {
+	const spinner = createSpinner("Opening dashboard...").start()
+	const registryUrl = getRegistryUrl()
+
+	// Default URL
+	let url = `${registryUrl}/dashboard`
+
+	// Check if we are in a package directory
+	const pkgPath = path.join(process.cwd(), "package.json")
+	if (fs.existsSync(pkgPath)) {
+		try {
+			const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"))
+			const parsed = parseOwner(pkg.name)
+
+			if (parsed) {
+				const { owner, pkgName } = parsed
+				spinner.text = `Detected package ${pkg.name}. Checking owner...`
+
+				// Fetch user info to determine if owner is personal or org
+				try {
+					const response = await request("/-/whoami")
+					if (response.ok) {
+						const data = await response.json()
+
+						// Check if owner matches user's personal username
+						if (data.profile_username && data.profile_username === owner) {
+							url = `${registryUrl}/dashboard/packages`
+							spinner.text = `Opening personal packages dashboard...`
+						}
+						// Check if owner matches one of user's organizations
+						else if (data.organizations?.some(org => org.slug === owner)) {
+							url = `${registryUrl}/dashboard/orgs/${owner}/packages`
+							spinner.text = `Opening ${owner} organization packages...`
+						}
+						// Owner not recognized, fall back to public package page
+						else {
+							url = `${registryUrl}/${owner}.${pkgName}`
+							spinner.text = `Opening public package page...`
+						}
+					} else {
+						// Not authenticated, open public package page
+						url = `${registryUrl}/${owner}.${pkgName}`
+						spinner.text = `Opening public package page...`
+					}
+				} catch (_apiError) {
+					// API error, fall back to dashboard
+					url = `${registryUrl}/dashboard`
+				}
+			}
+		} catch (_e) {
+			// ignore JSON parse errors
+		}
+	}
+
+	await open(url)
+	spinner.succeed(`Opened ${url}`)
+}