@impulselab/directory 1.0.7 → 1.1.0

package/index.js

@@ -5,6 +5,7 @@ const path = require('path');
 const https = require('https');
 const http = require('http');
 const os = require('os');
+const readline = require('readline');
 
 const PACKAGE = {
 	scopeName: '@impulselab/directory',
@@ -18,6 +19,13 @@ const DEFAULT_BASE_URL = 'impulse.directory';
 const RAW_PATH = '/raw/';
 const STACK_API_PREFIX = '/api/stacks/';
 const STACK_API_SUFFIX = '/npx';
+const DEVICE_CODE_PATH = '/api/auth/device/code';
+const DEVICE_TOKEN_PATH = '/api/auth/device/token';
+const SESSION_PATH = '/api/auth/get-session';
+const CLI_CLIENT_ID = 'impulse-directory-cli';
+
+const CONFIG_DIR = path.join(os.homedir(), '.impulse-directory');
+const CREDENTIALS_FILE = path.join(CONFIG_DIR, 'credentials.json');
 
 function normalizeBaseHost(input) {
 	const raw = (input || '').trim();
@@ -40,51 +48,361 @@ function canFallbackToHttp(host) {
 	return process.env.ALLOW_HTTP_FALLBACK === '1' || isLocalHost(host);
 }
 
+function shouldUseHttps(baseUrl) {
+	if (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1')) {
+		return false;
+	}
+	return true;
+}
+
 const MODES = {
-  COMMAND: 'command',
-  STACK: 'stack',
+	COMMAND: 'command',
+	STACK: 'stack',
+	LOGIN: 'login',
+	LOGOUT: 'logout',
+	WHOAMI: 'whoami',
 };
 
 const INSTALLATION_TARGETS = {
-  CLAUDE_SLASH: 'claude-slash',
-  CLAUDE_SUB_AGENT: 'claude-sub-agent',
-  CURSOR_COMMAND: 'cursor-command',
-  CURSOR_RULE: 'cursor-rule',
+	CLAUDE_SLASH: 'claude-slash',
+	CLAUDE_SUB_AGENT: 'claude-sub-agent',
+	CURSOR_COMMAND: 'cursor-command',
+	CURSOR_RULE: 'cursor-rule',
 };
 
 const DEFAULT_TARGET = INSTALLATION_TARGETS.CLAUDE_SLASH;
 
 const TARGET_CONFIG = {
-  [INSTALLATION_TARGETS.CLAUDE_SLASH]: {
-    label: 'Claude slash command',
-    description: '.claude/commands (falls back to ~/.claude/commands)',
-    resolveDirectory: () => resolveClaudeDirectory('commands'),
-    extension: '.md',
-  },
-  [INSTALLATION_TARGETS.CLAUDE_SUB_AGENT]: {
-    label: 'Claude sub agent',
-    description: '.claude/agents (falls back to ~/.claude/agents)',
-    resolveDirectory: () => resolveClaudeDirectory('agents'),
-    extension: '.md',
-  },
-  [INSTALLATION_TARGETS.CURSOR_COMMAND]: {
-    label: 'Cursor command',
-    description: '.cursor/commands (project only)',
-    resolveDirectory: () => resolveCursorDirectory('commands'),
-    extension: '.md',
-  },
-  [INSTALLATION_TARGETS.CURSOR_RULE]: {
-    label: 'Cursor rule',
-    description: '.cursor/rules (project only)',
-    resolveDirectory: () => resolveCursorDirectory('rules'),
-    extension: '.mdc',
-  },
+	[INSTALLATION_TARGETS.CLAUDE_SLASH]: {
+		label: 'Claude slash command',
+		description: '.claude/commands (falls back to ~/.claude/commands)',
+		resolveDirectory: () => resolveClaudeDirectory('commands'),
+		extension: '.md',
+	},
+	[INSTALLATION_TARGETS.CLAUDE_SUB_AGENT]: {
+		label: 'Claude sub agent',
+		description: '.claude/agents (falls back to ~/.claude/agents)',
+		resolveDirectory: () => resolveClaudeDirectory('agents'),
+		extension: '.md',
+	},
+	[INSTALLATION_TARGETS.CURSOR_COMMAND]: {
+		label: 'Cursor command',
+		description: '.cursor/commands (project only)',
+		resolveDirectory: () => resolveCursorDirectory('commands'),
+		extension: '.md',
+	},
+	[INSTALLATION_TARGETS.CURSOR_RULE]: {
+		label: 'Cursor rule',
+		description: '.cursor/rules (project only)',
+		resolveDirectory: () => resolveCursorDirectory('rules'),
+		extension: '.mdc',
+	},
 };
 
 const KNOWN_TARGETS = Object.keys(TARGET_CONFIG);
 
+// ============================================
+// Credentials Management
+// ============================================
+
+function ensureConfigDir() {
+	if (!fs.existsSync(CONFIG_DIR)) {
+		fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+	}
+}
+
+function loadCredentials() {
+	try {
+		if (fs.existsSync(CREDENTIALS_FILE)) {
+			const data = fs.readFileSync(CREDENTIALS_FILE, 'utf8');
+			return JSON.parse(data);
+		}
+	} catch {
+		// Ignore errors, return null
+	}
+	return null;
+}
+
+function saveCredentials(credentials) {
+	ensureConfigDir();
+	fs.writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), {
+		encoding: 'utf8',
+		mode: 0o600,
+	});
+}
+
+function clearCredentials() {
+	try {
+		if (fs.existsSync(CREDENTIALS_FILE)) {
+			fs.unlinkSync(CREDENTIALS_FILE);
+		}
+	} catch {
+		// Ignore errors
+	}
+}
+
+function getAuthToken() {
+	const creds = loadCredentials();
+	if (!creds) return null;
+
+	// Check if token is expired
+	if (creds.expiresAt && new Date(creds.expiresAt) <= new Date()) {
+		console.log('⚠️  Session expired. Please run: npx @impulselab/directory login');
+		clearCredentials();
+		return null;
+	}
+
+	return creds.accessToken || null;
+}
+
+// ============================================
+// HTTP Request Helpers
+// ============================================
+
+function httpRequest(options, body = null) {
+	return new Promise((resolve, reject) => {
+		const protocol = options.protocol === 'http:' ? http : https;
+		const req = protocol.request(options, (res) => {
+			let data = '';
+			res.on('data', (chunk) => {
+				data += chunk;
+			});
+			res.on('end', () => {
+				resolve({ statusCode: res.statusCode, headers: res.headers, body: data });
+			});
+		});
+		req.on('error', reject);
+		if (body) {
+			req.write(body);
+		}
+		req.end();
+	});
+}
+
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ============================================
+// Device Authorization Flow
+// ============================================
+
+async function requestDeviceCode(baseUrl) {
+	const useHttps = shouldUseHttps(baseUrl);
+	const protocol = useHttps ? 'https:' : 'http:';
+	const [hostname, port] = baseUrl.split(':');
+
+	const body = JSON.stringify({
+		client_id: CLI_CLIENT_ID,
+	});
+
+	const options = {
+		protocol,
+		hostname,
+		port: port || (useHttps ? 443 : 80),
+		path: DEVICE_CODE_PATH,
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+			'Content-Length': Buffer.byteLength(body),
+		},
+	};
+
+	const res = await httpRequest(options, body);
+
+	if (res.statusCode !== 200) {
+		throw new Error(`Failed to request device code: HTTP ${res.statusCode}`);
+	}
+
+	return JSON.parse(res.body);
+}
+
+async function pollForToken(baseUrl, deviceCode, interval) {
+	const useHttps = shouldUseHttps(baseUrl);
+	const protocol = useHttps ? 'https:' : 'http:';
+	const [hostname, port] = baseUrl.split(':');
+
+	const body = JSON.stringify({
+		grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+		device_code: deviceCode,
+		client_id: CLI_CLIENT_ID,
+	});
+
+	const options = {
+		protocol,
+		hostname,
+		port: port || (useHttps ? 443 : 80),
+		path: DEVICE_TOKEN_PATH,
+		method: 'POST',
+		headers: {
+			'Content-Type': 'application/json',
+			'Content-Length': Buffer.byteLength(body),
+		},
+	};
+
+	while (true) {
+		await sleep(interval * 1000);
+
+		try {
+			const res = await httpRequest(options, body);
+			const data = JSON.parse(res.body);
+
+			if (res.statusCode === 200) {
+				return data;
+			}
+
+			if (data.error === 'authorization_pending') {
+				process.stdout.write('.');
+				continue;
+			}
+
+			if (data.error === 'slow_down') {
+				interval = Math.min(interval + 1, 10);
+				continue;
+			}
+
+			if (data.error === 'access_denied') {
+				throw new Error('Authorization was denied by the user');
+			}
+
+			if (data.error === 'expired_token') {
+				throw new Error('Device code expired. Please try again.');
+			}
+
+			throw new Error(data.error_description || data.error || 'Unknown error');
+		} catch (err) {
+			if (err.message.includes('authorization_pending')) {
+				continue;
+			}
+			throw err;
+		}
+	}
+}
+
+async function fetchSession(baseUrl, token) {
+	const useHttps = shouldUseHttps(baseUrl);
+	const protocol = useHttps ? 'https:' : 'http:';
+	const [hostname, port] = baseUrl.split(':');
+
+	const options = {
+		protocol,
+		hostname,
+		port: port || (useHttps ? 443 : 80),
+		path: SESSION_PATH,
+		method: 'GET',
+		headers: {
+			Authorization: `Bearer ${token}`,
+		},
+	};
+
+	const res = await httpRequest(options);
+
+	if (res.statusCode !== 200) {
+		return null;
+	}
+
+	try {
+		return JSON.parse(res.body);
+	} catch {
+		return null;
+	}
+}
+
+async function doLogin(baseUrl) {
+	console.log('🔐 Authenticating with Impulse Directory...\n');
+
+	try {
+		const deviceCodeResponse = await requestDeviceCode(baseUrl);
+		const {
+			user_code: userCode,
+			verification_uri: verificationUri,
+			verification_uri_complete: verificationUriComplete,
+			device_code: deviceCode,
+			expires_in: expiresIn,
+			interval = 5,
+		} = deviceCodeResponse;
+
+		console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+		console.log('');
+		console.log('  To authenticate, visit:');
+		console.log(`  ${verificationUriComplete || verificationUri}`);
+		console.log('');
+		if (!verificationUriComplete) {
+			console.log(`  And enter code: ${userCode}`);
+			console.log('');
+		}
+		console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+		console.log('');
+		console.log(`⏳ Waiting for authorization (expires in ${Math.floor(expiresIn / 60)} minutes)`);
+
+		const tokenResponse = await pollForToken(baseUrl, deviceCode, interval);
+		console.log('\n');
+
+		// Save credentials
+		saveCredentials({
+			accessToken: tokenResponse.access_token,
+			tokenType: tokenResponse.token_type,
+			expiresIn: tokenResponse.expires_in,
+			expiresAt: tokenResponse.expires_in
+				? new Date(Date.now() + tokenResponse.expires_in * 1000).toISOString()
+				: null,
+			scope: tokenResponse.scope,
+		});
+
+		// Try to fetch user info
+		const session = await fetchSession(baseUrl, tokenResponse.access_token);
+		if (session && session.user) {
+			console.log(`✅ Logged in as ${session.user.name || session.user.email}`);
+		} else {
+			console.log('✅ Successfully authenticated!');
+		}
+
+		console.log('\nYou can now download private prompts and stacks.');
+	} catch (error) {
+		console.error(`\n❌ Login failed: ${error.message}`);
+		process.exit(1);
+	}
+}
+
+async function doLogout() {
+	const creds = loadCredentials();
+	if (!creds) {
+		console.log('ℹ️  Not currently logged in.');
+		return;
+	}
+
+	clearCredentials();
+	console.log('✅ Logged out successfully.');
+}
+
+async function doWhoami(baseUrl) {
+	const token = getAuthToken();
+	if (!token) {
+		console.log('ℹ️  Not logged in.');
+		console.log('   Run: npx @impulselab/directory login');
+		return;
+	}
+
+	try {
+		const session = await fetchSession(baseUrl, token);
+		if (session && session.user) {
+			console.log(`👤 Logged in as: ${session.user.name || 'Unknown'}`);
+			console.log(`   Email: ${session.user.email}`);
+		} else {
+			console.log('⚠️  Session is invalid or expired.');
+			console.log('   Run: npx @impulselab/directory login');
+		}
+	} catch {
+		console.log('⚠️  Could not verify session.');
+	}
+}
+
+// ============================================
+// Help
+// ============================================
+
 function showHelp() {
-	const primaryUsageCmd = `npx impulse-directory`;
+	const primaryUsageCmd = `npx @impulselab/directory`;
 	console.log(`
 Impulse Directory Command Installer
 Made by ${PACKAGE.brand} (${PACKAGE.websiteUrl})
@@ -92,16 +410,24 @@ Made by ${PACKAGE.brand} (${PACKAGE.websiteUrl})
 Usage:
   ${primaryUsageCmd} <user-slug>/<command-slug> [--target <target>]
   ${primaryUsageCmd} stack <stack-id>
-  
+  ${primaryUsageCmd} login
+  ${primaryUsageCmd} logout
+  ${primaryUsageCmd} whoami
 
 Description:
   Downloads a command from Impulse Directory and installs it in the right tool folder.
   When using the stack mode, installs each prompt in the stack to its inferred target.
+  Use 'login' to authenticate and access private prompts.
 
 Arguments:
   user-slug/command-slug    The full path to the command (user/command)
   stack-id                  The stack ULID shown in the Impulse Directory UI
 
+Commands:
+  login                     Authenticate with your Impulse Directory account
+  logout                    Clear stored credentials
+  whoami                    Show current authentication status
+
 Options:
   --target <target>         Installation target (optional for single commands)
   -t <target>               Short alias for --target
@@ -119,594 +445,604 @@ Environment Variables:
                       Examples: impulse.directory | localhost:3000
 
 Examples:
+  ${primaryUsageCmd} login
   ${primaryUsageCmd} john/my-awesome-command
+  ${primaryUsageCmd} john/my-private-command      (requires login)
   ${primaryUsageCmd} john/my-awesome-command --target claude-sub-agent
-  ${primaryUsageCmd} john/my-awesome-command --target cursor-command
-  ${primaryUsageCmd} stack 01JH0000000ABCDEF --target claude-slash
+  ${primaryUsageCmd} stack 01JH0000000ABCDEF
 `);
 }
 
-function shouldUseHttps(baseUrl) {
-  if (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1')) {
-    return false;
-  }
-  return true;
-}
+// ============================================
+// Download Functions (with auth support)
+// ============================================
 
 function toKebabCase(input) {
-  return String(input)
-    .normalize('NFKD')                    // strip accents
-    .replace(/[\u0300-\u036f]/g, '')
-    .replace(/['"]/g, '')
-    .replace(/[^a-zA-Z0-9]+/g, '-')       // collapse non-alnum to dashes
-    .replace(/^-+|-+$/g, '')
-    .toLowerCase();
+	return String(input)
+		.normalize('NFKD')
+		.replace(/[\u0300-\u036f]/g, '')
+		.replace(/['"]/g, '')
+		.replace(/[^a-zA-Z0-9]+/g, '-')
+		.replace(/^-+|-+$/g, '')
+		.toLowerCase();
 }
 
 function stripTrailingIdSegment(slug) {
-  const normalized = toKebabCase(slug || '');
-  const segments = normalized.split('-');
-  if (segments.length <= 1) return normalized;
-  const last = segments[segments.length - 1];
-  if (/^[a-z0-9]{5,}$/i.test(last)) {
-    segments.pop();
-  }
-  return segments.join('-');
+	const normalized = toKebabCase(slug || '');
+	const segments = normalized.split('-');
+	if (segments.length <= 1) return normalized;
+	const last = segments[segments.length - 1];
+	if (/^[a-z0-9]{5,}$/i.test(last)) {
+		segments.pop();
+	}
+	return segments.join('-');
 }
 
 function sanitizeIdentifierForFilename(identifier) {
-  return String(identifier || '')
-    .normalize('NFKD')
-    .replace(/[\u0300-\u036f]/g, '')      // remove accents
-    .replace(/[\u0000-\u001f\u007f-\u009f]/g, '') // remove control chars
-    .replace(/[<>:"/\\|?*]/g, '')         // remove filesystem unsafe chars
-    .replace(/\.\./g, '')                 // remove parent directory traversal
-    .replace(/[/\\]+/g, '-')              // replace all path separators with dashes
-    .replace(/^\.+/g, '')                 // remove leading dots
-    .replace(/\.+$/g, '')                 // remove trailing dots
-    .replace(/^-+|-+$/g, '')              // trim edge dashes
-    .replace(/-+/g, '-')                  // collapse multiple dashes
-    .toLowerCase()
-    || 'unknown';                         // fallback for empty results
-}
-
-function generateUniqueFilename(directory, baseName, extension) {
-  const baseFilename = `${baseName}${extension}`;
-  
-  if (!checkFileExists(directory, baseFilename)) {
-    return baseFilename;
-  }
-  
-  let counter = 1;
-  let candidate = `${baseName}-${counter}${extension}`;
-  while (checkFileExists(directory, candidate)) {
-    counter += 1;
-    candidate = `${baseName}-${counter}${extension}`;
-  }
-  
-  return candidate;
-}
-
-function downloadCommand(baseUrl, fullPath) {
-  return new Promise((resolve, reject) => {
-    const useHttps = shouldUseHttps(baseUrl);
-    const protocol = useHttps ? https : http;
-    const scheme = useHttps ? 'https' : 'http';
-
-    const url = `${scheme}://${baseUrl}${RAW_PATH}${fullPath}`;
-
-    protocol
-      .get(url, (res) => {
-        if (res.statusCode === 200) {
-          let data = '';
-          res.on('data', (chunk) => {
-            data += chunk;
-          });
-          res.on('end', () => resolve(data));
-        } else if (res.statusCode === 404) {
-          reject(new Error(`Command '${fullPath}' not found (404)`));
-        } else if (useHttps && (res.statusCode === 500 || res.statusCode >= 400)) {
-          if (canFallbackToHttp(baseUrl)) {
-            console.log(`HTTPS failed (${res.statusCode}), trying HTTP...`);
-            downloadWithHttp(baseUrl, fullPath)
-              .then(resolve)
-              .catch(reject);
-          } else {
-            reject(new Error(`HTTPS failed (${res.statusCode}) and HTTP fallback is disabled`));
-          }
-        } else {
-          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-        }
-      })
-      .on('error', (err) => {
-        if (useHttps) {
-          if (canFallbackToHttp(baseUrl)) {
-            console.log(`HTTPS failed (${err.message}), trying HTTP...`);
-            downloadWithHttp(baseUrl, fullPath)
-              .then(resolve)
-              .catch(reject);
-          } else {
-            reject(err);
-          }
-        } else {
-          reject(err);
-        }
-      });
-  });
-}
-
-function downloadWithHttp(baseUrl, fullPath) {
-  return new Promise((resolve, reject) => {
-    const url = `http://${baseUrl}${RAW_PATH}${fullPath}`;
-
-    console.log(`Trying HTTP: ${url}`);
-
-    http
-      .get(url, (res) => {
-        if (res.statusCode === 200) {
-          let data = '';
-          res.on('data', (chunk) => {
-            data += chunk;
-          });
-          res.on('end', () => resolve(data));
-        } else if (res.statusCode === 404) {
-          reject(new Error(`Command '${fullPath}' not found (404)`));
-        } else {
-          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-        }
-      })
-      .on('error', reject);
-  });
+	return (
+		String(identifier || '')
+			.normalize('NFKD')
+			.replace(/[\u0300-\u036f]/g, '')
+			.replace(/[\u0000-\u001f\u007f-\u009f]/g, '')
+			.replace(/[<>:"/\\|?*]/g, '')
+			.replace(/\.\./g, '')
+			.replace(/[/\\]+/g, '-')
+			.replace(/^\.+/g, '')
+			.replace(/\.+$/g, '')
+			.replace(/^-+|-+$/g, '')
+			.replace(/-+/g, '-')
+			.toLowerCase() || 'unknown'
+	);
+}
+
+function getAuthHeaders() {
+	const token = getAuthToken();
+	if (token) {
+		return { Authorization: `Bearer ${token}` };
+	}
+	return {};
 }
 
 function downloadStack(baseUrl, stackId) {
-  return new Promise((resolve, reject) => {
-    const useHttps = shouldUseHttps(baseUrl);
-    const protocol = useHttps ? https : http;
-    const scheme = useHttps ? 'https' : 'http';
-    const url = `${scheme}://${baseUrl}${STACK_API_PREFIX}${stackId}${STACK_API_SUFFIX}`;
-
-    protocol
-      .get(url, (res) => {
-        if (res.statusCode === 200) {
-          let data = '';
-          res.on('data', (chunk) => {
-            data += chunk;
-          });
-          res.on('end', () => {
-            try {
-              const parsed = JSON.parse(data);
-              resolve(parsed);
-            } catch (parseError) {
-              reject(new Error('Received invalid JSON while downloading stack'));
-            }
-          });
-        } else if (res.statusCode === 404) {
-          reject(new Error(`Stack '${stackId}' not found (404)`));
-        } else if (useHttps && (res.statusCode === 500 || res.statusCode >= 400)) {
-          if (canFallbackToHttp(baseUrl)) {
-            console.log(`HTTPS failed (${res.statusCode}), trying HTTP...`);
-            downloadStackWithHttp(baseUrl, stackId)
-              .then(resolve)
-              .catch(reject);
-          } else {
-            reject(new Error(`HTTPS failed (${res.statusCode}) and HTTP fallback is disabled`));
-          }
-        } else {
-          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-        }
-      })
-      .on('error', (err) => {
-        if (useHttps) {
-          if (canFallbackToHttp(baseUrl)) {
-            console.log(`HTTPS failed (${err.message}), trying HTTP...`);
-            downloadStackWithHttp(baseUrl, stackId)
-              .then(resolve)
-              .catch(reject);
-          } else {
-            reject(err);
-          }
-        } else {
-          reject(err);
-        }
-      });
-  });
+	return new Promise((resolve, reject) => {
+		const useHttps = shouldUseHttps(baseUrl);
+		const protocol = useHttps ? https : http;
+		const scheme = useHttps ? 'https' : 'http';
+		const url = `${scheme}://${baseUrl}${STACK_API_PREFIX}${stackId}${STACK_API_SUFFIX}`;
+
+		const urlObj = new URL(url);
+		const options = {
+			hostname: urlObj.hostname,
+			port: urlObj.port || (useHttps ? 443 : 80),
+			path: urlObj.pathname,
+			method: 'GET',
+			headers: getAuthHeaders(),
+		};
+
+		protocol
+			.get(options, (res) => {
+				if (res.statusCode === 200) {
+					let data = '';
+					res.on('data', (chunk) => {
+						data += chunk;
+					});
+					res.on('end', () => {
+						try {
+							const parsed = JSON.parse(data);
+							resolve(parsed);
+						} catch (parseError) {
+							reject(new Error('Received invalid JSON while downloading stack'));
+						}
+					});
+				} else if (res.statusCode === 401 || res.statusCode === 403) {
+					reject(
+						new Error(
+							'This stack is private. Please run: npx @impulselab/directory login'
+						)
+					);
+				} else if (res.statusCode === 404) {
+					reject(new Error(`Stack '${stackId}' not found (404)`));
+				} else if (useHttps && (res.statusCode === 500 || res.statusCode >= 400)) {
+					if (canFallbackToHttp(baseUrl)) {
+						console.log(`HTTPS failed (${res.statusCode}), trying HTTP...`);
+						downloadStackWithHttp(baseUrl, stackId).then(resolve).catch(reject);
+					} else {
+						reject(
+							new Error(
+								`HTTPS failed (${res.statusCode}) and HTTP fallback is disabled`
+							)
+						);
+					}
+				} else {
+					reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+				}
+			})
+			.on('error', (err) => {
+				if (useHttps) {
+					if (canFallbackToHttp(baseUrl)) {
+						console.log(`HTTPS failed (${err.message}), trying HTTP...`);
+						downloadStackWithHttp(baseUrl, stackId).then(resolve).catch(reject);
+					} else {
+						reject(err);
+					}
+				} else {
+					reject(err);
+				}
+			});
+	});
 }
 
 function downloadStackWithHttp(baseUrl, stackId) {
-  return new Promise((resolve, reject) => {
-    const url = `http://${baseUrl}${STACK_API_PREFIX}${stackId}${STACK_API_SUFFIX}`;
-
-    console.log(`Trying HTTP: ${url}`);
-
-    http
-      .get(url, (res) => {
-        if (res.statusCode === 200) {
-          let data = '';
-          res.on('data', (chunk) => {
-            data += chunk;
-          });
-          res.on('end', () => {
-            try {
-              const parsed = JSON.parse(data);
-              resolve(parsed);
-            } catch (parseError) {
-              reject(new Error('Received invalid JSON while downloading stack'));
-            }
-          });
-        } else if (res.statusCode === 404) {
-          reject(new Error(`Stack '${stackId}' not found (404)`));
-        } else {
-          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-        }
-      })
-      .on('error', reject);
-  });
+	return new Promise((resolve, reject) => {
+		const url = `http://${baseUrl}${STACK_API_PREFIX}${stackId}${STACK_API_SUFFIX}`;
+		const urlObj = new URL(url);
+
+		console.log(`Trying HTTP: ${url}`);
+
+		const options = {
+			hostname: urlObj.hostname,
+			port: urlObj.port || 80,
+			path: urlObj.pathname,
+			method: 'GET',
+			headers: getAuthHeaders(),
+		};
+
+		http
+			.get(options, (res) => {
+				if (res.statusCode === 200) {
+					let data = '';
+					res.on('data', (chunk) => {
+						data += chunk;
+					});
+					res.on('end', () => {
+						try {
+							const parsed = JSON.parse(data);
+							resolve(parsed);
+						} catch (parseError) {
+							reject(new Error('Received invalid JSON while downloading stack'));
+						}
+					});
+				} else if (res.statusCode === 401 || res.statusCode === 403) {
+					reject(
+						new Error(
+							'This stack is private. Please run: npx @impulselab/directory login'
+						)
+					);
+				} else if (res.statusCode === 404) {
+					reject(new Error(`Stack '${stackId}' not found (404)`));
+				} else {
+					reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+				}
+			})
+			.on('error', reject);
+	});
 }
 
 function downloadRawWithHeaders(baseUrl, fullPath) {
-  return new Promise((resolve, reject) => {
-    const useHttps = shouldUseHttps(baseUrl);
-    const protocol = useHttps ? https : http;
-    const scheme = useHttps ? 'https' : 'http';
-    const url = `${scheme}://${baseUrl}${RAW_PATH}${fullPath}`;
-
-    const handleOk = (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => resolve({ content: data, headers: res.headers }));
-    };
-
-    const handleHttpsFailover = (reason) => {
-      if (useHttps && canFallbackToHttp(baseUrl)) {
-        console.log(`HTTPS failed (${reason}), trying HTTP...`);
-        downloadRawWithHeadersHttp(baseUrl, fullPath).then(resolve).catch(reject);
-      } else {
-        reject(new Error(typeof reason === 'string' ? reason : reason.message));
-      }
-    };
-
-    protocol
-      .get(url, (res) => {
-        if (res.statusCode === 200) return handleOk(res);
-        if (res.statusCode === 404) return reject(new Error(`Command '${fullPath}' not found (404)`));
-        return handleHttpsFailover(`${res.statusCode}`);
-      })
-      .on('error', handleHttpsFailover);
-  });
+	return new Promise((resolve, reject) => {
+		const useHttps = shouldUseHttps(baseUrl);
+		const protocol = useHttps ? https : http;
+		const scheme = useHttps ? 'https' : 'http';
+		const url = `${scheme}://${baseUrl}${RAW_PATH}${fullPath}`;
+
+		const urlObj = new URL(url);
+		const options = {
+			hostname: urlObj.hostname,
+			port: urlObj.port || (useHttps ? 443 : 80),
+			path: urlObj.pathname,
+			method: 'GET',
+			headers: getAuthHeaders(),
+		};
+
+		const handleOk = (res) => {
+			let data = '';
+			res.on('data', (chunk) => {
+				data += chunk;
+			});
+			res.on('end', () => resolve({ content: data, headers: res.headers }));
+		};
+
+		const handleHttpsFailover = (reason) => {
+			if (useHttps && canFallbackToHttp(baseUrl)) {
+				console.log(`HTTPS failed (${reason}), trying HTTP...`);
+				downloadRawWithHeadersHttp(baseUrl, fullPath).then(resolve).catch(reject);
+			} else {
+				reject(new Error(typeof reason === 'string' ? reason : reason.message));
+			}
+		};
+
+		protocol
+			.get(options, (res) => {
+				if (res.statusCode === 200) return handleOk(res);
+				if (res.statusCode === 401 || res.statusCode === 403) {
+					return reject(
+						new Error(
+							'This prompt is private. Please run: npx @impulselab/directory login'
+						)
+					);
+				}
+				if (res.statusCode === 404)
+					return reject(new Error(`Command '${fullPath}' not found (404)`));
+				return handleHttpsFailover(`${res.statusCode}`);
+			})
+			.on('error', handleHttpsFailover);
+	});
 }
 
 function downloadRawWithHeadersHttp(baseUrl, fullPath) {
-  return new Promise((resolve, reject) => {
-    const url = `http://${baseUrl}${RAW_PATH}${fullPath}`;
-    console.log(`Trying HTTP: ${url}`);
-    http
-      .get(url, (res) => {
-        if (res.statusCode === 200) {
-          let data = '';
-          res.on('data', (chunk) => { data += chunk; });
-          res.on('end', () => resolve({ content: data, headers: res.headers }));
-        } else if (res.statusCode === 404) {
-          reject(new Error(`Command '${fullPath}' not found (404)`));
-        } else {
-          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-        }
-      })
-      .on('error', reject);
-  });
+	return new Promise((resolve, reject) => {
+		const url = `http://${baseUrl}${RAW_PATH}${fullPath}`;
+		const urlObj = new URL(url);
+
+		console.log(`Trying HTTP: ${url}`);
+
+		const options = {
+			hostname: urlObj.hostname,
+			port: urlObj.port || 80,
+			path: urlObj.pathname,
+			method: 'GET',
+			headers: getAuthHeaders(),
+		};
+
+		http
+			.get(options, (res) => {
+				if (res.statusCode === 200) {
+					let data = '';
+					res.on('data', (chunk) => {
+						data += chunk;
+					});
+					res.on('end', () => resolve({ content: data, headers: res.headers }));
+				} else if (res.statusCode === 401 || res.statusCode === 403) {
+					reject(
+						new Error(
+							'This prompt is private. Please run: npx @impulselab/directory login'
+						)
+					);
+				} else if (res.statusCode === 404) {
+					reject(new Error(`Command '${fullPath}' not found (404)`));
+				} else {
+					reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+				}
+			})
+			.on('error', reject);
+	});
 }
 
-function findClosestFolder(folderName) {
-  let currentDir = process.cwd();
-
-  while (true) {
-    const candidate = path.join(currentDir, folderName);
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
+// ============================================
+// Directory Resolution
+// ============================================
 
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) {
-      break;
-    }
-    currentDir = parentDir;
-  }
-
-  return null;
+function findClosestFolder(folderName) {
+	let currentDir = process.cwd();
+
+	while (true) {
+		const candidate = path.join(currentDir, folderName);
+		if (fs.existsSync(candidate)) {
+			return candidate;
+		}
+
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) {
+			break;
+		}
+		currentDir = parentDir;
+	}
+
+	return null;
 }
 
 function resolveClaudeDirectory(subFolder) {
-  const projectClaudeDir = findClosestFolder('.claude');
-  if (projectClaudeDir) {
-    return path.join(projectClaudeDir, subFolder);
-  }
-  return path.join(os.homedir(), '.claude', subFolder);
+	const projectClaudeDir = findClosestFolder('.claude');
+	if (projectClaudeDir) {
+		return path.join(projectClaudeDir, subFolder);
+	}
+	return path.join(os.homedir(), '.claude', subFolder);
 }
 
 function resolveCursorDirectory(subFolder) {
-  const projectCursorDir = findClosestFolder('.cursor');
-  if (!projectCursorDir) {
-    const message =
-      'Unable to find a .cursor directory. Run this command from inside a Cursor project.';
-    throw new Error(message);
-  }
-  return path.join(projectCursorDir, subFolder);
+	const projectCursorDir = findClosestFolder('.cursor');
+	if (!projectCursorDir) {
+		const message =
+			'Unable to find a .cursor directory. Run this command from inside a Cursor project.';
+		throw new Error(message);
+	}
+	return path.join(projectCursorDir, subFolder);
 }
 
 function ensureDirectoryExists(dirPath) {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-    console.log(`Created directory: ${dirPath}`);
-  }
-}
-
-function checkFileExists(commandsDir, filename) {
-  const filePath = path.join(commandsDir, filename);
-  return fs.existsSync(filePath);
+	if (!fs.existsSync(dirPath)) {
+		fs.mkdirSync(dirPath, { recursive: true });
+		console.log(`Created directory: ${dirPath}`);
+	}
 }
 
-function saveCommand({
-  directory,
-  filename,
-  content,
-  fullPath,
-  target,
-}) {
-  const filePath = path.join(directory, filename);
-  const relativeDir = path.relative(process.cwd(), directory);
-  const displayPath = relativeDir
-    ? path.join(relativeDir, filename)
-    : filename;
+function saveCommand({ directory, filename, content, fullPath, target }) {
+	const filePath = path.join(directory, filename);
+	const relativeDir = path.relative(process.cwd(), directory);
+	const displayPath = relativeDir ? path.join(relativeDir, filename) : filename;
 
-  console.log(`📁 Saving command to ${displayPath}`);
+	console.log(`📁 Saving command to ${displayPath}`);
 
-  fs.writeFileSync(filePath, content, 'utf8');
+	fs.writeFileSync(filePath, content, 'utf8');
 
-  const commandName = filename.replace(path.extname(filename), '');
-  logSuccessMessage(target, fullPath, commandName);
+	const commandName = filename.replace(path.extname(filename), '');
+	logSuccessMessage(target, fullPath, commandName);
 }
 
 function logSuccessMessage(target, fullPath, commandName) {
-  switch (target) {
-    case INSTALLATION_TARGETS.CLAUDE_SLASH:
-      console.log(`✅ Command '${fullPath}' installed successfully`);
-      console.log(`\n🎉 You can now use: /${commandName}`);
-      break;
-    case INSTALLATION_TARGETS.CLAUDE_SUB_AGENT:
-      console.log(`✅ Agent '${fullPath}' installed successfully`);
-      console.log(
-        `\n🎉 You can now select '${commandName}' from Claude Desktop's agent menu.`
-      );
-      break;
-    case INSTALLATION_TARGETS.CURSOR_COMMAND:
-      console.log(`✅ Cursor command '${fullPath}' installed successfully`);
-      console.log(
-        `\n🎉 Open Cursor and run '${commandName}' from the command palette.`
-      );
-      break;
-    case INSTALLATION_TARGETS.CURSOR_RULE:
-      console.log(`✅ Cursor rule '${fullPath}' installed successfully`);
-      console.log(
-        `\n🎉 Cursor will apply '${commandName}' to this project.`
-      );
-      break;
-    default:
-      console.log(`✅ '${fullPath}' installed successfully`);
-  }
+	switch (target) {
+		case INSTALLATION_TARGETS.CLAUDE_SLASH:
+			console.log(`✅ Command '${fullPath}' installed successfully`);
+			console.log(`\n🎉 You can now use: /${commandName}`);
+			break;
+		case INSTALLATION_TARGETS.CLAUDE_SUB_AGENT:
+			console.log(`✅ Agent '${fullPath}' installed successfully`);
+			console.log(
+				`\n🎉 You can now select '${commandName}' from Claude Desktop's agent menu.`
+			);
+			break;
+		case INSTALLATION_TARGETS.CURSOR_COMMAND:
+			console.log(`✅ Cursor command '${fullPath}' installed successfully`);
+			console.log(
+				`\n🎉 Open Cursor and run '${commandName}' from the command palette.`
+			);
+			break;
+		case INSTALLATION_TARGETS.CURSOR_RULE:
+			console.log(`✅ Cursor rule '${fullPath}' installed successfully`);
+			console.log(`\n🎉 Cursor will apply '${commandName}' to this project.`);
+			break;
+		default:
+			console.log(`✅ '${fullPath}' installed successfully`);
+	}
 }
 
+// ============================================
+// Argument Parsing
+// ============================================
+
 function parseCommandArgs(args) {
-  let mode = MODES.COMMAND;
-  let identifier = null;
-  let target = null;
-  let showHelpFlag = false;
-
-  for (let i = 0; i < args.length; i += 1) {
-    const arg = args[i];
-
-    if (arg === '--help' || arg === '-h') {
-      showHelpFlag = true;
-      continue;
-    }
-
-    if (arg.startsWith('--target')) {
-      let rawValue = null;
-      if (arg.includes('=')) {
-        rawValue = arg.split('=')[1];
-      } else {
-        rawValue = args[i + 1];
-        i += 1;
-      }
-
-      if (!rawValue) {
-        throw new Error('Missing value for --target option');
-      }
-
-      const normalizedTarget = rawValue.toLowerCase();
-      if (!KNOWN_TARGETS.includes(normalizedTarget)) {
-        throw new Error(
-          `Unknown target '${rawValue}'. Available targets: ${KNOWN_TARGETS.join(', ')}`
-        );
-      }
-
-      target = normalizedTarget;
-      continue;
-    }
-
-    if (arg === '-t') {
-      const rawValue = args[i + 1];
-      i += 1;
-
-      if (!rawValue) {
-        throw new Error('Missing value for -t option');
-      }
-
-      const normalizedTarget = rawValue.toLowerCase();
-      if (!KNOWN_TARGETS.includes(normalizedTarget)) {
-        throw new Error(
-          `Unknown target '${rawValue}'. Available targets: ${KNOWN_TARGETS.join(', ')}`
-        );
-      }
-
-      target = normalizedTarget;
-      continue;
-    }
-
-    if (mode === MODES.COMMAND && arg === 'stack' && !identifier) {
-      mode = MODES.STACK;
-      continue;
-    }
-
-    if (!identifier) {
-      identifier = arg;
-      continue;
-    }
-
-    throw new Error(`Unknown argument: ${arg}`);
-  }
-
-  return { mode, identifier, target, showHelp: showHelpFlag };
+	let mode = MODES.COMMAND;
+	let identifier = null;
+	let target = null;
+	let showHelpFlag = false;
+
+	for (let i = 0; i < args.length; i += 1) {
+		const arg = args[i];
+
+		if (arg === '--help' || arg === '-h') {
+			showHelpFlag = true;
+			continue;
+		}
+
+		if (arg.startsWith('--target')) {
+			let rawValue = null;
+			if (arg.includes('=')) {
+				rawValue = arg.split('=')[1];
+			} else {
+				rawValue = args[i + 1];
+				i += 1;
+			}
+
+			if (!rawValue) {
+				throw new Error('Missing value for --target option');
+			}
+
+			const normalizedTarget = rawValue.toLowerCase();
+			if (!KNOWN_TARGETS.includes(normalizedTarget)) {
+				throw new Error(
+					`Unknown target '${rawValue}'. Available targets: ${KNOWN_TARGETS.join(', ')}`
+				);
+			}
+
+			target = normalizedTarget;
+			continue;
+		}
+
+		if (arg === '-t') {
+			const rawValue = args[i + 1];
+			i += 1;
+
+			if (!rawValue) {
+				throw new Error('Missing value for -t option');
+			}
+
+			const normalizedTarget = rawValue.toLowerCase();
+			if (!KNOWN_TARGETS.includes(normalizedTarget)) {
+				throw new Error(
+					`Unknown target '${rawValue}'. Available targets: ${KNOWN_TARGETS.join(', ')}`
+				);
+			}
+
+			target = normalizedTarget;
+			continue;
+		}
+
+		// Check for auth commands
+		if (arg === 'login' && !identifier) {
+			mode = MODES.LOGIN;
+			continue;
+		}
+
+		if (arg === 'logout' && !identifier) {
+			mode = MODES.LOGOUT;
+			continue;
+		}
+
+		if (arg === 'whoami' && !identifier) {
+			mode = MODES.WHOAMI;
+			continue;
+		}
+
+		if (mode === MODES.COMMAND && arg === 'stack' && !identifier) {
+			mode = MODES.STACK;
+			continue;
+		}
+
+		if (!identifier) {
+			identifier = arg;
+			continue;
+		}
+
+		throw new Error(`Unknown argument: ${arg}`);
+	}
+
+	return { mode, identifier, target, showHelp: showHelpFlag };
 }
 
+// ============================================
+// Main
+// ============================================
+
 async function main() {
-  const args = process.argv.slice(2);
-
-  try {
-    const {
-      mode,
-      identifier,
-      target,
-      showHelp: helpRequested,
-    } = parseCommandArgs(args);
-
-    if (helpRequested || args.length === 0) {
-      showHelp();
-      return;
-    }
-
-    const baseUrl = normalizeBaseHost(process.env.IMPULSE_BASE_URL || DEFAULT_BASE_URL);
-
-    if (mode === MODES.COMMAND) {
-      if (!identifier) {
-        console.error('❌ Error: Missing command path');
-        showHelp();
-        process.exit(1);
-      }
-
-      if (!identifier.includes('/')) {
-        console.error('❌ Error: Path must include user/command format');
-        showHelp();
-        process.exit(1);
-      }
-
-      const resolvedTarget = target || DEFAULT_TARGET;
-      const targetConfig = TARGET_CONFIG[resolvedTarget];
-
-      if (!targetConfig) {
-        console.error(`❌ Error: Unsupported target '${resolvedTarget}'`);
-        process.exit(1);
-      }
-
-      const directory = targetConfig.resolveDirectory();
-
-      ensureDirectoryExists(directory);
-
-      const commandNameFromPath = identifier.split('/').pop();
-      // First download the content to capture headers (and title)
-      const { content, headers } = await downloadRawWithHeaders(baseUrl, identifier);
-      const titleHeader = headers['x-prompt-title'];
-      const title = Array.isArray(titleHeader) ? titleHeader[0] : titleHeader;
-
-      const baseNameCandidate = title
-        ? toKebabCase(title)
-        : stripTrailingIdSegment(commandNameFromPath);
-      const finalBaseName = sanitizeIdentifierForFilename(baseNameCandidate);
-
-      // Overwrite if exists; do not append author or random suffix
-      const filename = `${finalBaseName}${targetConfig.extension}`;
-
-      saveCommand({
-        directory,
-        filename,
-        content,
-        fullPath: identifier,
-        target: resolvedTarget,
-      });
-      return;
-    }
-
-    if (!identifier) {
-      console.error('❌ Error: Missing stack identifier');
-      showHelp();
-      process.exit(1);
-    }
-
-    const stackPayload = await downloadStack(baseUrl, identifier);
-    const stack = stackPayload.stack || {};
-    const prompts = Array.isArray(stackPayload.prompts)
-      ? stackPayload.prompts
-      : [];
-
-    console.log(
-      `📦 Installing stack '${stack.title || identifier}' (${prompts.length} prompt${
-        prompts.length === 1 ? '' : 's'
-      })`
-    );
-
-    let installed = 0;
-    let skipped = 0;
-
-    for (let index = 0; index < prompts.length; index += 1) {
-      const prompt = prompts[index];
-      const commandPath = prompt.path || prompt.slug || prompt.id || `prompt-${index + 1}`;
-      const baseName = prompt.title
-        ? toKebabCase(prompt.title)
-        : stripTrailingIdSegment(prompt.slug || `prompt-${index + 1}`);
-
-      const resolvedTarget = target || prompt.target || DEFAULT_TARGET;
-      const targetConfig = TARGET_CONFIG[resolvedTarget];
-      if (!targetConfig) {
-        console.warn(`⚠️  Skipping prompt '${commandPath}' (unsupported target '${resolvedTarget}')`);
-        skipped += 1;
-        continue;
-      }
-
-      const directory = targetConfig.resolveDirectory();
-      ensureDirectoryExists(directory);
-
-      // Sanitize and overwrite if exists (no author or random suffix)
-      const sanitizedBaseName = sanitizeIdentifierForFilename(baseName);
-      const filename = `${sanitizedBaseName}${targetConfig.extension}`;
-
-      if (!prompt.markdown) {
-        console.warn(`⚠️  Skipping prompt '${commandPath}' (no content available)`);
-        skipped += 1;
-        continue;
-      }
-
-      saveCommand({
-        directory,
-        filename,
-        content: prompt.markdown,
-        fullPath: commandPath,
-        target: resolvedTarget,
-      });
-      installed += 1;
-    }
-
-    console.log(
-      `🎉 Installed ${installed} prompt${installed === 1 ? '' : 's'} from stack '${
-        stack.title || identifier
-      }'${skipped ? ` (skipped ${skipped})` : ''}`
-    );
-  } catch (error) {
-    console.error(`❌ Error: ${error.message}`);
-    process.exit(1);
-  }
+	const args = process.argv.slice(2);
+
+	try {
+		const { mode, identifier, target, showHelp: helpRequested } = parseCommandArgs(args);
+
+		if (helpRequested || args.length === 0) {
+			showHelp();
+			return;
+		}
+
+		const baseUrl = normalizeBaseHost(
+			process.env.IMPULSE_BASE_URL || DEFAULT_BASE_URL
+		);
+
+		// Handle auth commands
+		if (mode === MODES.LOGIN) {
+			await doLogin(baseUrl);
+			return;
+		}
+
+		if (mode === MODES.LOGOUT) {
+			await doLogout();
+			return;
+		}
+
+		if (mode === MODES.WHOAMI) {
+			await doWhoami(baseUrl);
+			return;
+		}
+
+		if (mode === MODES.COMMAND) {
+			if (!identifier) {
+				console.error('❌ Error: Missing command path');
+				showHelp();
+				process.exit(1);
+			}
+
+			if (!identifier.includes('/')) {
+				console.error('❌ Error: Path must include user/command format');
+				showHelp();
+				process.exit(1);
+			}
+
+			const resolvedTarget = target || DEFAULT_TARGET;
+			const targetConfig = TARGET_CONFIG[resolvedTarget];
+
+			if (!targetConfig) {
+				console.error(`❌ Error: Unsupported target '${resolvedTarget}'`);
+				process.exit(1);
+			}
+
+			const directory = targetConfig.resolveDirectory();
+
+			ensureDirectoryExists(directory);
+
+			const commandNameFromPath = identifier.split('/').pop();
+			const { content, headers } = await downloadRawWithHeaders(baseUrl, identifier);
+			const titleHeader = headers['x-prompt-title'];
+			const title = Array.isArray(titleHeader) ? titleHeader[0] : titleHeader;
+
+			const baseNameCandidate = title
+				? toKebabCase(title)
+				: stripTrailingIdSegment(commandNameFromPath);
+			const finalBaseName = sanitizeIdentifierForFilename(baseNameCandidate);
+
+			const filename = `${finalBaseName}${targetConfig.extension}`;
+
+			saveCommand({
+				directory,
+				filename,
+				content,
+				fullPath: identifier,
+				target: resolvedTarget,
+			});
+			return;
+		}
+
+		if (!identifier) {
+			console.error('❌ Error: Missing stack identifier');
+			showHelp();
+			process.exit(1);
+		}
+
+		const stackPayload = await downloadStack(baseUrl, identifier);
+		const stack = stackPayload.stack || {};
+		const prompts = Array.isArray(stackPayload.prompts) ? stackPayload.prompts : [];
+
+		console.log(
+			`📦 Installing stack '${stack.title || identifier}' (${prompts.length} prompt${
+				prompts.length === 1 ? '' : 's'
+			})`
+		);
+
+		let installed = 0;
+		let skipped = 0;
+
+		for (let index = 0; index < prompts.length; index += 1) {
+			const prompt = prompts[index];
+			const commandPath =
+				prompt.path || prompt.slug || prompt.id || `prompt-${index + 1}`;
+			const baseName = prompt.title
+				? toKebabCase(prompt.title)
+				: stripTrailingIdSegment(prompt.slug || `prompt-${index + 1}`);
+
+			const resolvedTarget = target || prompt.target || DEFAULT_TARGET;
+			const targetConfig = TARGET_CONFIG[resolvedTarget];
+			if (!targetConfig) {
+				console.warn(
+					`⚠️  Skipping prompt '${commandPath}' (unsupported target '${resolvedTarget}')`
+				);
+				skipped += 1;
+				continue;
+			}
+
+			const directory = targetConfig.resolveDirectory();
+			ensureDirectoryExists(directory);
+
+			const sanitizedBaseName = sanitizeIdentifierForFilename(baseName);
+			const filename = `${sanitizedBaseName}${targetConfig.extension}`;
+
+			if (!prompt.markdown) {
+				console.warn(`⚠️  Skipping prompt '${commandPath}' (no content available)`);
+				skipped += 1;
+				continue;
+			}
+
+			saveCommand({
+				directory,
+				filename,
+				content: prompt.markdown,
+				fullPath: commandPath,
+				target: resolvedTarget,
+			});
+			installed += 1;
+		}
+
+		console.log(
+			`🎉 Installed ${installed} prompt${installed === 1 ? '' : 's'} from stack '${
+				stack.title || identifier
+			}'${skipped ? ` (skipped ${skipped})` : ''}`
+		);
+	} catch (error) {
+		console.error(`❌ Error: ${error.message}`);
+		process.exit(1);
+	}
 }
 
 if (require.main === module) {
-  main();
+	main();
 }
 
 module.exports = { main };