promptcase 1.0.4

package/README.md

@@ -0,0 +1,67 @@
+# PromptCase CLI
+
+A background daemon that captures AI prompts you send to Claude Code and syncs them to your [PromptCase](https://promptcase.app) account for later search, tagging, and organisation.
+
+## Install
+
+```bash
+npm install -g promptcase
+```
+
+Requires **Node.js 20 or newer**.
+
+## Quick start
+
+```bash
+# 1. Authenticate (opens browser, then auto-starts the daemon)
+promptcase init
+
+# 2. Check status
+promptcase status
+
+# 3. Force a sync
+promptcase sync
+
+# 4. View recent prompts
+promptcase show
+```
+
+The daemon runs in the background and auto-starts on system boot (LaunchAgent on macOS, user-level systemd on Linux, Startup folder on Windows).
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `promptcase init` | Authenticate and start the daemon |
+| `promptcase status` | Show auth, daemon, and auto-start status |
+| `promptcase sync` | Force a sync and run diagnostics |
+| `promptcase show` | Show recent synced prompts |
+| `promptcase stop` | Stop the running daemon (auto-start preserved) |
+| `promptcase logout` | Stop daemon, revoke token, clear credentials |
+
+## Non-interactive authentication
+
+Pipe a token JSON to `init`:
+
+```bash
+echo '{"access_token":"...","refresh_token":"...","expires_in":15552000}' | promptcase init
+```
+
+## Configuration
+
+Config and credentials are stored in `~/.promptcase/`. Logs:
+
+- `~/.promptcase/daemon.log` (stdout)
+- `~/.promptcase/daemon.error.log` (stderr)
+
+## Troubleshooting
+
+```bash
+promptcase status   # overall health
+promptcase sync     # diagnose and force a refresh
+promptcase logout && promptcase init   # reset credentials
+```
+
+## License
+
+MIT

package/dist/commands/init.js

@@ -0,0 +1,319 @@
+/**
+ * Init command - Authenticate with PromptCase
+ *
+ * Behavior:
+ * - If authenticated: show status, verify token, ensure daemon is running, setup auto-start
+ * - If not authenticated: start auth flow, then auto-start daemon and setup auto-start
+ */
+import inquirer from 'inquirer';
+import { Command } from 'commander';
+import { exec, spawn } from 'child_process';
+import { APIService } from '../services/api.js';
+import { DaemonService } from '../services/daemon.js';
+import { getConfig } from '../lib/config.js';
+import { scriptPath } from '../lib/path.js';
+import { DEFAULT_API_URL, CLI_TOKEN_URL } from '../lib/constants.js';
+/**
+ * Open URL in default browser (cross-platform)
+ * Returns true if the browser was launched, false on failure.
+ */
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open' :
+        process.platform === 'win32' ? 'start' : 'xdg-open';
+    try {
+        exec(`${cmd} "${url}"`, (error) => {
+            if (error) {
+                console.log(`   ⚠️  Could not open browser automatically. Open this URL manually:\n   ${url}\n`);
+            }
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if already authenticated and show status
+ */
+async function checkAuthStatus() {
+    const config = getConfig();
+    const isAuthenticated = await config.isAuthenticated();
+    if (isAuthenticated) {
+        const credentials = await config.getCredentials();
+        return { isAuthenticated: true, credentials: credentials || undefined };
+    }
+    return { isAuthenticated: false };
+}
+/**
+ * Save token after validation
+ */
+async function saveToken(tokenJson, api, config) {
+    try {
+        const tokens = JSON.parse(tokenJson);
+        if (!tokens.access_token || !tokens.refresh_token) {
+            console.error('❌ Invalid token format. Both access_token and refresh_token are required.');
+            return false;
+        }
+        if (!tokens.access_token.startsWith('pc_tok_') || !tokens.refresh_token.startsWith('pc_ref_')) {
+            console.error('❌ Invalid token format. Tokens should start with pc_tok_ and pc_ref_');
+            return false;
+        }
+        const expiresAt = new Date(Date.now() + (tokens.expires_in || 15552000) * 1000);
+        const credentials = {
+            accessToken: tokens.access_token,
+            refreshToken: tokens.refresh_token,
+            expiresAt: expiresAt.toISOString(),
+            createdAt: new Date().toISOString(),
+        };
+        await config.setCredentials(credentials);
+        api.setTokens(credentials.accessToken, credentials.refreshToken);
+        return true;
+    }
+    catch (error) {
+        console.error('❌ Invalid JSON format:', error.message);
+        return false;
+    }
+}
+/**
+ * Verify token and fetch user info
+ */
+async function verifyAndShowUser(api) {
+    const userInfo = await api.verifyToken();
+    if (userInfo) {
+        console.log(`   User-ID:    ${userInfo.userId}`);
+        console.log(`   Device:     ${userInfo.deviceName} (${userInfo.deviceType})`);
+    }
+    else {
+        console.log('   ⚠️  Token validation failed (but tokens stored)');
+    }
+}
+/**
+ * Start daemon in detached background process
+ */
+async function startDaemonDetached(apiUrl) {
+    // Detach the daemon process so it runs independently
+    const child = spawn(process.execPath, [scriptPath(), 'start'], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.unref();
+    // Give it a moment to start
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    // Verify it started
+    const daemon = new DaemonService(apiUrl);
+    const isRunning = await daemon.isRunning();
+    if (isRunning) {
+        console.log('   ✅ Daemon started in background');
+    }
+    else {
+        console.log('   ⚠️  Daemon may not have started. Check with "promptcase status"');
+    }
+}
+/**
+ * Main init flow - handles authentication and daemon startup
+ */
+export async function initFlow(apiUrl = DEFAULT_API_URL) {
+    const config = getConfig();
+    const api = new APIService(apiUrl);
+    console.log('\n🔐 PromptCase CLI\n');
+    // Check if already authenticated
+    const { isAuthenticated, credentials } = await checkAuthStatus();
+    if (isAuthenticated && credentials) {
+        const expiresAt = new Date(credentials.expiresAt);
+        const daysLeft = Math.ceil((expiresAt.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
+        console.log('   Status:         ✅ Authenticated');
+        console.log(`   Access Token:   ${credentials.accessToken.slice(0, 20)}...`);
+        console.log(`   Refresh Token:  ${credentials.refreshToken.slice(0, 20)}...`);
+        console.log(`   Expires:        ${expiresAt.toLocaleDateString()} (${daysLeft} days left)\n`);
+        // Verify token and get user info
+        api.setTokens(credentials.accessToken, credentials.refreshToken);
+        await verifyAndShowUser(api);
+        // Check if daemon is running
+        const daemon = new DaemonService(apiUrl);
+        const daemonRunning = await daemon.isRunning();
+        if (!daemonRunning) {
+            console.log('\n   Starting daemon in background...\n');
+            // Start daemon detached (in background)
+            await startDaemonDetached(apiUrl);
+        }
+        else {
+            console.log('\n   Daemon is already running');
+        }
+        // Setup auto-start on boot if not already set up
+        console.log('\n   Setting up auto-start on system boot...');
+        const autoStartSuccess = await daemon.setupAutoStart();
+        if (autoStartSuccess) {
+            console.log('   ✅ Auto-start configured');
+        }
+        else {
+            console.log('   ⚠️  Auto-start setup failed (daemon will not auto-restart on reboot)');
+        }
+        console.log('\n   Run "promptcase status" to check daemon status');
+        console.log('   Run "promptcase sync" to manually trigger a sync');
+        console.log('   Run "promptcase stop" to stop the daemon');
+        console.log('   Run "promptcase logout" to clear credentials\n');
+        return;
+    }
+    // Not authenticated - start auth flow
+    console.log('   Status: 🔴 Not authenticated\n');
+    try {
+        const { choice } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'choice',
+                message: 'How would you like to authenticate?',
+                choices: [
+                    { name: '🌐 Open browser to generate token (Recommended)', value: 'browser' },
+                    { name: '📋 Paste token JSON manually', value: 'manual' },
+                ],
+            },
+        ]);
+        let tokenJson;
+        if (choice === 'browser') {
+            console.log('\n   Opening browser to generate CLI token...\n');
+            console.log(`   ${CLI_TOKEN_URL}\n`);
+            openBrowser(CLI_TOKEN_URL);
+            console.log('   (If the browser did not open automatically, copy the URL above.)\n');
+            const { proceed } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'proceed',
+                    message: 'Press Enter after you have copied the token (or "n" to cancel)',
+                    default: true,
+                },
+            ]);
+            if (!proceed) {
+                console.log('\n   Cancelled. You can run "promptcase init" again later.\n');
+                return;
+            }
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'tokenJson',
+                    message: 'Paste the copied token JSON:',
+                    validate: (input) => {
+                        try {
+                            const parsed = JSON.parse(input);
+                            if (!parsed.access_token || !parsed.refresh_token) {
+                                return 'Invalid token format. Both access_token and refresh_token are required.';
+                            }
+                            return true;
+                        }
+                        catch {
+                            return 'Invalid JSON format';
+                        }
+                    },
+                },
+            ]);
+            tokenJson = answer.tokenJson;
+        }
+        else {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'tokenJson',
+                    message: 'Paste token JSON:',
+                    validate: (input) => {
+                        try {
+                            const parsed = JSON.parse(input);
+                            if (!parsed.access_token || !parsed.refresh_token) {
+                                return 'Invalid token format. Both access_token and refresh_token are required.';
+                            }
+                            return true;
+                        }
+                        catch {
+                            return 'Invalid JSON format';
+                        }
+                    },
+                },
+            ]);
+            tokenJson = answer.tokenJson;
+        }
+        // Save tokens
+        const saved = await saveToken(tokenJson, api, config);
+        if (!saved) {
+            process.exit(1);
+        }
+        console.log('\n   ✅ Authentication successful!\n');
+        // Verify and show user info
+        const tokens = JSON.parse(tokenJson);
+        api.setTokens(tokens.access_token, tokens.refresh_token);
+        await verifyAndShowUser(api);
+        // Auto-start daemon
+        console.log('\n   Starting daemon in background...\n');
+        await startDaemonDetached(apiUrl);
+        // Setup auto-start on boot
+        console.log('   Setting up auto-start on system boot...');
+        const daemon = new DaemonService(apiUrl);
+        const autoStartSuccess = await daemon.setupAutoStart();
+        if (autoStartSuccess) {
+            console.log('   ✅ Auto-start configured');
+        }
+        else {
+            console.log('   ⚠️  Auto-start setup failed');
+        }
+        console.log('\n   ✅ Setup complete!');
+        console.log('\n   Commands:');
+        console.log('     promptcase status    Check daemon status');
+        console.log('     promptcase sync      Manually trigger a sync');
+        console.log('     promptcase stop      Stop the daemon');
+        console.log('     promptcase logout    Clear credentials\n');
+    }
+    catch (error) {
+        if (error.isTtyError) {
+            console.log('Opening browser for token generation...\n');
+            openBrowser(CLI_TOKEN_URL);
+            console.log('Please copy the token and run: promptcase init --token <json>\n');
+        }
+        else {
+            console.error('❌ Authentication failed:', error.message);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Non-interactive auth handler for piped input
+ */
+export function handleNonInteractiveToken(tokenJson, apiUrl = DEFAULT_API_URL) {
+    const config = getConfig();
+    const api = new APIService(apiUrl);
+    saveToken(tokenJson, api, config).then(async (saved) => {
+        if (!saved) {
+            process.exit(1);
+        }
+        console.log('\n✅ Authentication successful!\n');
+        try {
+            const tokens = JSON.parse(tokenJson);
+            api.setTokens(tokens.access_token, tokens.refresh_token);
+            await verifyAndShowUser(api);
+            // Auto-start daemon
+            console.log('\n   Starting daemon in background...');
+            await startDaemonDetached(apiUrl);
+            // Setup auto-start
+            console.log('   Setting up auto-start on system boot...');
+            const daemon = new DaemonService(apiUrl);
+            const autoStartSuccess = await daemon.setupAutoStart();
+            if (autoStartSuccess) {
+                console.log('   ✅ Auto-start configured');
+            }
+            else {
+                console.log('   ⚠️  Auto-start setup failed');
+            }
+            console.log('\n   ✅ Setup complete!\n');
+        }
+        catch (error) {
+            console.error('Setup error:', error.message);
+        }
+    });
+}
+export function createInitCommand() {
+    const command = new Command('init');
+    command
+        .description('Authenticate with PromptCase and start the daemon')
+        .action(async () => {
+        await initFlow();
+    });
+    return command;
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/logout.js

@@ -0,0 +1,57 @@
+/**
+ * Logout command - Clear local credentials and invalidate token on server
+ */
+import { Command } from 'commander';
+import { APIService } from '../services/api.js';
+import { getConfig } from '../lib/config.js';
+import { DaemonService } from '../services/daemon.js';
+import { DEFAULT_API_URL } from '../lib/constants.js';
+export function createLogoutCommand(apiUrl = DEFAULT_API_URL) {
+    const command = new Command('logout');
+    command
+        .description('Clear credentials and invalidate CLI token on server')
+        .action(async () => {
+        const config = getConfig();
+        const api = new APIService(apiUrl);
+        const daemon = new DaemonService(apiUrl);
+        console.log('\n🔒 Logging out of PromptCase\n');
+        // Check if there's anything to logout
+        const hasCreds = await config.hasCredentials();
+        if (!hasCreds) {
+            console.log('   No active authentication found.\n');
+            return;
+        }
+        const credentials = await config.getCredentials();
+        if (!credentials) {
+            await config.clearAll();
+            console.log('   ✅ Cleared local credentials.\n');
+            return;
+        }
+        // Stop daemon if running
+        const isRunning = await daemon.isRunning();
+        if (isRunning) {
+            console.log('   Stopping daemon...');
+            await daemon.stop();
+            console.log('   ✅ Daemon stopped');
+        }
+        // Try to invalidate token on server
+        console.log('   Invalidating token on server...');
+        api.setTokens(credentials.accessToken, credentials.refreshToken);
+        const revoked = await api.revokeDevice();
+        if (revoked) {
+            console.log('   ✅ Token revoked on server');
+        }
+        else {
+            console.log('   ⚠️  Could not revoke token on server (will expire naturally)');
+        }
+        // Clear all local data
+        await config.clearAll();
+        console.log('   ✅ Local credentials cleared');
+        // Note: Auto-start is removed automatically since the daemon is stopped and we cleared data
+        // But we should leave the auto-start config so re-running init re-enables it
+        console.log('\n   ✅ Logged out successfully!');
+        console.log('   Run "promptcase init" to authenticate again.\n');
+    });
+    return command;
+}
+//# sourceMappingURL=logout.js.map

package/dist/commands/show.js

@@ -0,0 +1,59 @@
+/**
+ * Show command - Display recent synced prompts
+ */
+import { Command } from 'commander';
+import { APIService } from '../services/api.js';
+import { getConfig } from '../lib/config.js';
+import { DEFAULT_API_URL } from '../lib/constants.js';
+export function createShowCommand(apiUrl = DEFAULT_API_URL) {
+    const command = new Command('show');
+    command
+        .description('Show recent prompts synced to PromptCase')
+        .option('-n, --limit <number>', 'Number of prompts to show', '15')
+        .option('-q, --quiet', 'Only show prompt content, no metadata')
+        .action(async (options) => {
+        const config = getConfig();
+        const api = new APIService(apiUrl);
+        console.log('\n📝 Recent Prompts\n');
+        // Check authentication
+        if (!(await config.isAuthenticated())) {
+            console.log('❌ Not authenticated. Run "promptcase init" first.');
+            return;
+        }
+        // Get credentials
+        const credentials = await config.getCredentials();
+        if (!credentials) {
+            console.log('❌ No credentials found. Run "promptcase init" first.');
+            return;
+        }
+        api.setTokens(credentials.accessToken, credentials.refreshToken);
+        try {
+            const limit = parseInt(options.limit, 10) || 15;
+            const prompts = await api.getRecentPrompts(limit);
+            if (prompts.length === 0) {
+                console.log('No prompts synced yet.\n');
+                return;
+            }
+            prompts.forEach((prompt, index) => {
+                const date = new Date(prompt.created_at);
+                const source = prompt.source || 'unknown';
+                if (options.quiet) {
+                    console.log(`[${index + 1}] ${prompt.content.slice(0, 200)}${prompt.content.length > 200 ? '...' : ''}`);
+                }
+                else {
+                    console.log(`┌─ ${index + 1}. ${prompt.title || 'Untitled'}`);
+                    console.log(`│  Source: ${source}`);
+                    console.log(`│  Date: ${date.toLocaleDateString()} ${date.toLocaleTimeString()}`);
+                    console.log(`│  ${prompt.content.slice(0, 150)}${prompt.content.length > 150 ? '...' : ''}`);
+                    console.log(`└────────────────────────────────────────`);
+                }
+            });
+            console.log(`\nShowing ${prompts.length} of ${prompts.length} prompts\n`);
+        }
+        catch (error) {
+            console.log(`❌ Failed to fetch prompts: ${error.message}`);
+        }
+    });
+    return command;
+}
+//# sourceMappingURL=show.js.map

package/dist/commands/start.js

@@ -0,0 +1,34 @@
+/**
+ * Start command - Run daemon in foreground (used by auto-start services)
+ *
+ * This is the entry point for auto-start services on all platforms.
+ * It runs the daemon in foreground and only exits when killed.
+ */
+import { Command } from 'commander';
+import { DaemonService } from '../services/daemon.js';
+import { DEFAULT_API_URL, DAEMON_PROCESS_TITLE } from '../lib/constants.js';
+export function createStartCommand(apiUrl = DEFAULT_API_URL) {
+    const command = new Command('start');
+    command
+        .description('Run daemon in foreground (used by auto-start services)')
+        .action(async () => {
+        // Rename this process for `ps`/Activity Monitor so users see
+        // "PromptCase Daemon" instead of "node". Note: the macOS Settings
+        // → Privacy & Security panel still shows the original terminal
+        // session that spawned this process for a brief window — the only
+        // way to override that is to ship a signed .app bundle, which
+        // requires an Apple Developer ID ($99/year).
+        process.title = DAEMON_PROCESS_TITLE;
+        const daemon = new DaemonService(apiUrl);
+        // Check auth and ensure we have credentials
+        const initialized = await daemon.initialize();
+        if (!initialized) {
+            // Silently exit if not authenticated - service manager will retry on next boot
+            process.exit(0);
+        }
+        // Start daemon in foreground (never returns unless killed)
+        await daemon.start();
+    });
+    return command;
+}
+//# sourceMappingURL=start.js.map

package/dist/commands/status.js

@@ -0,0 +1,126 @@
+/**
+ * Status command - Show authentication, daemon, and sync status
+ */
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { APIService } from '../services/api.js';
+import { DaemonService } from '../services/daemon.js';
+import { getConfig } from '../lib/config.js';
+import { DEFAULT_API_URL } from '../lib/constants.js';
+export function createStatusCommand(apiUrl = DEFAULT_API_URL) {
+    const command = new Command('status');
+    command
+        .description('Show authentication, daemon, and sync status')
+        .action(async () => {
+        const config = getConfig();
+        const api = new APIService(apiUrl);
+        const daemon = new DaemonService(apiUrl);
+        console.log('\n📊 PromptCase Status\n');
+        // --- Authentication Status ---
+        const isAuthenticated = await config.isAuthenticated();
+        const credentials = await config.getCredentials();
+        console.log('🔐 Authentication:');
+        if (isAuthenticated && credentials) {
+            const expiresAt = new Date(credentials.expiresAt);
+            const daysLeft = Math.ceil((expiresAt.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
+            api.setTokens(credentials.accessToken, credentials.refreshToken);
+            console.log('   Status:         ✅ Authenticated');
+            console.log(`   Access Token:   ${credentials.accessToken.slice(0, 24)}...`);
+            console.log(`   Refresh Token:  ${credentials.refreshToken.slice(0, 24)}...`);
+            console.log(`   Expires:        ${expiresAt.toLocaleDateString()} (${daysLeft} days left)`);
+            // Get user info from API
+            const userInfo = await api.verifyToken();
+            if (userInfo) {
+                console.log(`   User-ID:        ${userInfo.userId}`);
+                console.log(`   Device:         ${userInfo.deviceName}`);
+            }
+            else {
+                console.log(`   User-ID:        ⚠️  Could not verify token`);
+            }
+        }
+        else {
+            const hasCreds = await config.hasCredentials();
+            if (hasCreds) {
+                console.log('   Status:         ⚠️  Token expired - run "promptcase init" to refresh');
+            }
+            else {
+                console.log('   Status:         🔴 Not authenticated');
+                console.log('   Run "promptcase init" to authenticate');
+            }
+        }
+        // --- Daemon Status ---
+        const isRunning = await daemon.isRunning();
+        const daemonStatus = await config.getDaemonStatus();
+        const lifetimeSynced = daemonStatus.promptsSynced ?? 0;
+        console.log('\n🔄 Daemon:');
+        if (isRunning) {
+            console.log('   Status:         🟢 Running');
+            console.log(`   PID:            ${daemonStatus.pid || process.pid}`);
+            console.log(`   Started:        ${daemonStatus.startedAt ? new Date(daemonStatus.startedAt).toLocaleString() : 'Unknown'}`);
+            const lastSync = daemonStatus.lastSyncAt;
+            if (lastSync) {
+                const lastSyncDate = new Date(lastSync);
+                const agoMinutes = Math.floor((Date.now() - lastSyncDate.getTime()) / 60000);
+                const agoText = agoMinutes < 1 ? 'just now' :
+                    agoMinutes < 60 ? `${agoMinutes} min ago` :
+                        agoMinutes < 1440 ? `${Math.floor(agoMinutes / 60)} hr ago` :
+                            `${Math.floor(agoMinutes / 1440)} days ago`;
+                console.log(`   Last sync:      ${lastSyncDate.toLocaleString()} (${agoText})`);
+                console.log(`   Total synced:   ${lifetimeSynced} prompts (lifetime)`);
+            }
+            else {
+                console.log('   Last sync:      Never');
+                console.log(`   Total synced:   ${lifetimeSynced} prompts (lifetime)`);
+            }
+            if (daemonStatus.nextSyncAt) {
+                const nextSyncDate = new Date(daemonStatus.nextSyncAt);
+                console.log(`   Next sync:      ${nextSyncDate.toLocaleString()}`);
+            }
+        }
+        else {
+            console.log('   Status:         🔴 Not running');
+            if (isAuthenticated) {
+                console.log('   Run "promptcase init" to start the daemon');
+            }
+        }
+        // --- Auto-Start Status ---
+        console.log('\n🚀 Auto-start:');
+        const platform = process.platform === 'darwin' ? 'macOS' :
+            process.platform === 'win32' ? 'Windows' : 'Linux';
+        console.log(`   Platform:       ${platform}`);
+        // Check if auto-start is configured
+        if (process.platform === 'darwin') {
+            const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'app.promptcase.daemon.plist');
+            if (fs.existsSync(plistPath)) {
+                console.log('   Status:         ✅ Configured');
+            }
+            else {
+                console.log('   Status:         🔴 Not configured');
+            }
+        }
+        else if (process.platform === 'win32') {
+            const batchPath = path.join(os.homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', 'promptcase.bat');
+            if (fs.existsSync(batchPath)) {
+                console.log('   Status:         ✅ Configured');
+            }
+            else {
+                console.log('   Status:         🔴 Not configured');
+            }
+        }
+        else {
+            const servicePath = path.join(os.homedir(), '.config', 'systemd', 'user', 'promptcase.service');
+            if (fs.existsSync(servicePath)) {
+                console.log('   Status:         ✅ Configured');
+            }
+            else {
+                console.log('   Status:         🔴 Not configured');
+                console.log('   Enable with: systemctl --user enable promptcase');
+            }
+        }
+        console.log('');
+    });
+    return command;
+}
+//# sourceMappingURL=status.js.map