promptcase 1.0.4

package/dist/commands/stop.js

@@ -0,0 +1,43 @@
+/**
+ * Stop command - Stop daemon for this OS session
+ *
+ * Behavior:
+ * - Stops the daemon process if running
+ * - Keeps auto-start configuration intact so daemon restarts on next boot
+ */
+import { Command } from 'commander';
+import { DaemonService } from '../services/daemon.js';
+import { DEFAULT_API_URL } from '../lib/constants.js';
+export function createStopCommand(apiUrl = DEFAULT_API_URL) {
+    const command = new Command('stop');
+    command
+        .description('Stop the daemon for this OS session (auto-start on next boot preserved)')
+        .action(async () => {
+        const daemon = new DaemonService(apiUrl);
+        console.log('\n🛑 Stopping PromptCase Daemon\n');
+        const isRunning = await daemon.isRunning();
+        if (!isRunning) {
+            console.log('   Daemon is not running.\n');
+            return;
+        }
+        const success = await daemon.stop();
+        if (success) {
+            console.log('   ✅ Daemon stopped successfully');
+            console.log('   ℹ️  Auto-start is still configured. Daemon will restart on next boot.');
+        }
+        else {
+            console.log('   ⚠️  Could not stop daemon gracefully. Kill the process manually:');
+            if (process.platform === 'win32') {
+                console.log('      taskkill /F /IM node.exe');
+            }
+            else {
+                console.log('      pkill -f "promptcase start"');
+            }
+        }
+        console.log('\n   Auto-start preserved. To completely remove auto-start, run:');
+        console.log('     promptcase logout');
+        console.log('   Or manually remove the LaunchAgent / systemd service / .bat file.\n');
+    });
+    return command;
+}
+//# sourceMappingURL=stop.js.map

package/dist/commands/sync.js

@@ -0,0 +1,117 @@
+/**
+ * Sync command - Force a sync without invalidating login
+ *
+ * Used when daemon gets stuck or sync isn't working.
+ * Performs diagnostics and forces a refresh of the sync process.
+ */
+import { Command } from 'commander';
+import { spawn } from 'child_process';
+import { APIService } from '../services/api.js';
+import { DaemonService } from '../services/daemon.js';
+import { ClaudeCaptureService } from '../services/claude-capture.js';
+import { getConfig } from '../lib/config.js';
+import { scriptPath } from '../lib/path.js';
+import { DEFAULT_API_URL } from '../lib/constants.js';
+export function createSyncCommand(apiUrl = DEFAULT_API_URL) {
+    const command = new Command('sync');
+    command
+        .description('Force a sync and run diagnostics (does not invalidate login)')
+        .action(async () => {
+        console.log('\n🔄 Force Sync & Diagnostics\n');
+        const config = getConfig();
+        const api = new APIService(apiUrl);
+        const daemon = new DaemonService(apiUrl);
+        // 1. Authentication check
+        const isAuthenticated = await config.isAuthenticated();
+        if (!isAuthenticated) {
+            console.log('   ❌ Not authenticated. Run "promptcase init" first.');
+            return;
+        }
+        const credentials = await config.getCredentials();
+        if (!credentials) {
+            console.log('   ❌ No credentials found. Run "promptcase init" first.');
+            return;
+        }
+        api.setTokens(credentials.accessToken, credentials.refreshToken);
+        // 2. Verify token is still valid
+        console.log('   📡 Checking API connection...');
+        const userInfo = await api.verifyToken();
+        if (!userInfo) {
+            console.log('   ❌ Token is invalid or expired. Run "promptcase init" to re-authenticate.');
+            return;
+        }
+        console.log(`   ✅ API connection successful (User: ${userInfo.userId})`);
+        // 3. Check daemon status
+        console.log('\n   📊 Daemon status:');
+        const isRunning = await daemon.isRunning();
+        if (isRunning) {
+            const daemonStatus = await config.getDaemonStatus();
+            console.log(`      Status: Running (PID ${daemonStatus.pid})`);
+            console.log(`      Last sync: ${daemonStatus.lastSyncAt ? new Date(daemonStatus.lastSyncAt).toLocaleString() : 'Never'}`);
+        }
+        else {
+            console.log('      Status: Not running');
+            console.log('      ⚠️  Daemon is not running - starting a sync anyway');
+        }
+        // 4. Check Claude installation
+        console.log('\n   📦 Claude Code check:');
+        const capture = new ClaudeCaptureService();
+        const sessionCount = await capture.countSessionFiles();
+        if (sessionCount > 0) {
+            console.log(`      ✅ Claude installed with ${sessionCount} session file(s)`);
+        }
+        else {
+            console.log('      ⚠️  Claude Code not installed (~/.claude not found)');
+            console.log('      Nothing to capture until Claude Code is installed and used.');
+        }
+        // 5. Perform sync
+        console.log('\n   🔄 Triggering sync...');
+        const initialized = await daemon.initialize();
+        if (!initialized) {
+            console.log('   ❌ Failed to initialize daemon');
+            return;
+        }
+        const status = await daemon.sync();
+        console.log('\n   📈 Results:');
+        if (status.lastSyncAt) {
+            console.log(`      Last sync: ${status.lastSyncAt.toLocaleString()}`);
+            console.log(`      Total synced (lifetime): ${status.promptsSynced} prompts`);
+            if (status.errors.length > 0) {
+                console.log(`      Errors (${status.errors.length}):`);
+                status.errors.slice(-3).forEach((err) => console.log(`         - ${err}`));
+            }
+        }
+        // 6. If daemon is not running, start it
+        if (!isRunning) {
+            console.log('\n   🚀 Daemon was not running. Starting now in background...');
+            const child = spawn(process.execPath, [scriptPath(), 'start'], {
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+            child.unref();
+            // Wait then verify
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            const nowRunning = await daemon.isRunning();
+            if (nowRunning) {
+                console.log('   ✅ Daemon started successfully');
+                console.log('   ℹ️  Auto-start is configured - daemon will resume on next boot');
+            }
+            else {
+                console.log('   ⚠️  Daemon may not have started. Check with "promptcase status"');
+            }
+        }
+        // 7. Refresh token if needed
+        const expiresAt = new Date(credentials.expiresAt);
+        const daysLeft = Math.ceil((expiresAt.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
+        if (daysLeft < 7) {
+            console.log(`\n   ⚠️  Token expires in ${daysLeft} days. Consider running "promptcase init" to refresh.`);
+        }
+        else {
+            console.log(`\n   ✅ Login still valid for ${daysLeft} more days`);
+        }
+        console.log('');
+    });
+    return command;
+}
+//# sourceMappingURL=sync.js.map

package/dist/index.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+/**
+ * PromptCase CLI - Main Entry Point
+ *
+ * A daemon to capture and sync AI prompts from Claude Code
+ * to the PromptCase web application.
+ */
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { createInitCommand, handleNonInteractiveToken } from './commands/init.js';
+import { createStartCommand } from './commands/start.js';
+import { createStopCommand } from './commands/stop.js';
+import { createSyncCommand } from './commands/sync.js';
+import { createShowCommand } from './commands/show.js';
+import { createStatusCommand } from './commands/status.js';
+import { createLogoutCommand } from './commands/logout.js';
+import { DEFAULT_API_URL } from './lib/constants.js';
+// Default API URL (same as deployed web app)
+// Read version from package.json so it always matches the published version
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const program = new Command();
+program
+    .name('promptcase')
+    .description('CLI daemon to capture and sync AI prompts from Claude Code to PromptCase')
+    .version(pkg.version)
+    .option('-a, --api-url <url>', 'API URL', DEFAULT_API_URL);
+// Check if init command is called with piped input (no TTY and no options/flags)
+const isPipedInit = process.argv[2] === 'init' &&
+    process.argv.length === 3 &&
+    !process.stdin.isTTY;
+if (isPipedInit) {
+    // Read piped JSON from stdin
+    let pipedData = '';
+    let handled = false;
+    process.stdin.on('data', (chunk) => {
+        pipedData += chunk;
+    });
+    process.stdin.on('end', () => {
+        if (!handled && pipedData) {
+            handled = true;
+            handleNonInteractiveToken(pipedData.trim(), DEFAULT_API_URL);
+        }
+    });
+    // Failsafe timeout in case stdin never ends
+    setTimeout(() => {
+        if (!handled) {
+            handled = true;
+            // No piped data within 200ms - use commander
+            runCommander();
+        }
+    }, 200);
+}
+else {
+    runCommander();
+}
+function runCommander() {
+    // Register commands
+    program.addCommand(createInitCommand());
+    // `start` is an internal entry point used by auto-start services; hide it from help
+    program.addCommand(createStartCommand(DEFAULT_API_URL), { hidden: true });
+    program.addCommand(createStopCommand(DEFAULT_API_URL));
+    program.addCommand(createSyncCommand(DEFAULT_API_URL));
+    program.addCommand(createShowCommand(DEFAULT_API_URL));
+    program.addCommand(createStatusCommand(DEFAULT_API_URL));
+    program.addCommand(createLogoutCommand(DEFAULT_API_URL));
+    // Parse and execute
+    program.parse(process.argv);
+    // Show help if no command provided
+    if (process.argv.length === 2) {
+        console.log('');
+        program.outputHelp();
+        console.log('\nExamples:');
+        console.log('  promptcase init          Authenticate (and auto-start daemon)');
+        console.log('  promptcase status        Show auth + daemon + sync status');
+        console.log('  promptcase sync          Force sync + run diagnostics');
+        console.log('  promptcase show          Show last 15 synced prompts');
+        console.log('  promptcase stop          Stop daemon (auto-start kept)');
+        console.log('  promptcase logout        Logout and invalidate token\n');
+    }
+}
+// Handle uncaught errors
+process.on('uncaughtException', (error) => {
+    console.error('\n❌ Unexpected error:', error.message);
+    process.exit(1);
+});
+// Log unhandled rejections but don't exit. The daemon and other commands
+// handle their own promise errors; a transient network failure shouldn't
+// crash a long-running background process.
+process.on('unhandledRejection', (reason) => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    console.error('\n⚠️  Unhandled promise rejection:', message);
+});
+//# sourceMappingURL=index.js.map

package/dist/lib/config.js

@@ -0,0 +1,132 @@
+/**
+ * Configuration store for CLI credentials and settings
+ */
+import Conf from 'conf';
+import { createRequire } from 'module';
+import os from 'os';
+import path from 'path';
+import { DEFAULT_API_URL, SYNC_INTERVAL_MS } from './constants.js';
+const require = createRequire(import.meta.url);
+// From compiled file at `dist/lib/config.js`, package.json lives at
+// `dist/../package.json` (two levels up). Reading via createRequire with
+// an absolute path avoids any path-resolution drift between dev and prod.
+const pkg = require('../../package.json');
+const CLI_VERSION = pkg.version;
+export class ConfigService {
+    store;
+    configDir;
+    constructor() {
+        // Use OS-appropriate config directory
+        this.configDir = path.join(os.homedir(), '.promptcase');
+        this.store = new Conf({
+            projectName: 'promptcase',
+            projectVersion: CLI_VERSION,
+            defaults: {
+                credentials: null,
+                daemon: {
+                    status: {
+                        isRunning: false,
+                        pid: undefined,
+                        startedAt: null,
+                        lastSyncAt: null,
+                        nextSyncAt: null,
+                        promptsSynced: 0,
+                    },
+                },
+                settings: {
+                    syncInterval: SYNC_INTERVAL_MS,
+                    apiUrl: DEFAULT_API_URL,
+                    lastKnownHistoryFile: null,
+                    lastSyncCursor: null,
+                },
+            },
+        });
+    }
+    // Credentials
+    async getCredentials() {
+        return this.store.get('credentials');
+    }
+    async setCredentials(credentials) {
+        this.store.set('credentials', credentials);
+    }
+    async clearCredentials() {
+        this.store.delete('credentials');
+    }
+    async hasCredentials() {
+        const creds = await this.getCredentials();
+        return creds !== null;
+    }
+    // Daemon status
+    async getDaemonStatus() {
+        return this.store.get('daemon.status');
+    }
+    async setDaemonStatus(status) {
+        this.store.set('daemon.status', status);
+    }
+    // Settings
+    async getSyncInterval() {
+        return this.store.get('settings.syncInterval');
+    }
+    async setSyncInterval(interval) {
+        this.store.set('settings.syncInterval', interval);
+    }
+    async getApiUrl() {
+        return this.store.get('settings.apiUrl');
+    }
+    async setApiUrl(url) {
+        this.store.set('settings.apiUrl', url);
+    }
+    async getLastKnownHistoryFile() {
+        return this.store.get('settings.lastKnownHistoryFile');
+    }
+    async setLastKnownHistoryFile(file) {
+        this.store.set('settings.lastKnownHistoryFile', file);
+    }
+    /**
+     * ISO timestamp string of the most recent prompt successfully synced.
+     * Used as a cursor so subsequent syncs only fetch newer prompts.
+     * `null` means "no cursor yet, do a full backfill".
+     */
+    async getLastSyncCursor() {
+        return this.store.get('settings.lastSyncCursor');
+    }
+    async setLastSyncCursor(cursor) {
+        this.store.set('settings.lastSyncCursor', cursor);
+    }
+    // Check if token is expired
+    async isTokenExpired() {
+        const creds = await this.getCredentials();
+        if (!creds)
+            return true;
+        const expiresAt = new Date(creds.expiresAt);
+        return expiresAt.getTime() < Date.now();
+    }
+    // Get config directory path
+    getConfigDir() {
+        return this.configDir;
+    }
+    // Get credentials file path
+    getCredentialsFilePath() {
+        return path.join(this.configDir, 'credentials');
+    }
+    // Clear all data (for logout)
+    async clearAll() {
+        this.store.clear();
+    }
+    // Check if authenticated (has valid credentials)
+    async isAuthenticated() {
+        const hasCreds = await this.hasCredentials();
+        if (!hasCreds)
+            return false;
+        return !(await this.isTokenExpired());
+    }
+}
+// Singleton instance
+let configInstance = null;
+export function getConfig() {
+    if (!configInstance) {
+        configInstance = new ConfigService();
+    }
+    return configInstance;
+}
+//# sourceMappingURL=config.js.map

package/dist/lib/constants.js

@@ -0,0 +1,18 @@
+/**
+ * Centralized constants for the CLI
+ *
+ * Previously these were duplicated across 7+ files. Keeping them in one
+ * place makes it obvious what to change when the production URL changes.
+ */
+export const DEFAULT_API_URL = 'https://web-six-iota-a0lchij54v.vercel.app';
+/** Where users generate a CLI token from the web app. */
+export const CLI_TOKEN_URL = `${DEFAULT_API_URL}/dashboard/devices/cli-token`;
+/** Sync interval (1 minute) — daemon loop ticks this often. */
+export const SYNC_INTERVAL_MS = 60_000;
+/** Max prompts fetched per sync (avoid huge payloads). */
+export const MAX_PROMPTS_PER_SYNC = 100;
+/** Prompts shorter than this are filtered out as noise. */
+export const PROMPT_MIN_LENGTH = 10;
+/** Friendly process name shown in `ps`/Activity Monitor when daemon is running. */
+export const DAEMON_PROCESS_TITLE = 'PromptCase Daemon';
+//# sourceMappingURL=constants.js.map

package/dist/lib/path.js

@@ -0,0 +1,26 @@
+/**
+ * Shared ESM path helpers
+ *
+ * Node.js ESM does not provide `__filename` / `__dirname`. This module
+ * computes them once (per module evaluation) and exposes:
+ *   - `scriptPath()` — absolute path to dist/index.js (used to spawn
+ *     detached daemon processes)
+ *   - `here()` — directory of the current source file (for any other
+ *     call site that needs `__dirname`)
+ */
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+const here_filename = fileURLToPath(import.meta.url);
+const here_dirname = dirname(here_filename);
+/**
+ * Absolute path to this CLI's compiled entry point. Used to spawn the
+ * daemon process detached from the parent's terminal.
+ */
+export function scriptPath() {
+    return resolve(here_dirname, '..', 'index.js');
+}
+/** Absolute path to the directory containing the compiled file. */
+export function here() {
+    return here_dirname;
+}
+//# sourceMappingURL=path.js.map

package/dist/services/api.js

@@ -0,0 +1,211 @@
+/**
+ * API service for communicating with PromptCase backend
+ */
+import got from 'got';
+import { createHash } from 'crypto';
+export class APIService {
+    apiUrl;
+    accessToken = null;
+    refreshToken = null;
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl.replace(/\/$/, ''); // Remove trailing slash
+    }
+    /**
+     * Set authentication tokens
+     */
+    setTokens(accessToken, refreshToken) {
+        this.accessToken = accessToken;
+        this.refreshToken = refreshToken;
+    }
+    /**
+     * Clear authentication tokens
+     */
+    clearTokens() {
+        this.accessToken = null;
+        this.refreshToken = null;
+    }
+    /**
+     * Check if authenticated
+     */
+    isAuthenticated() {
+        return this.accessToken !== null;
+    }
+    /**
+     * Read the current access token. Exposed for callers that need to persist
+     * refreshed tokens (e.g. the daemon's hourly refresh-write task).
+     */
+    getAccessToken() {
+        return this.accessToken;
+    }
+    /**
+     * Read the current refresh token.
+     */
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    /**
+     * Refresh the access token using refresh token
+     */
+    async refreshAccessToken() {
+        if (!this.refreshToken) {
+            throw new Error('No refresh token available');
+        }
+        try {
+            const response = await got.post(`${this.apiUrl}/api/auth/refresh`, {
+                json: {
+                    refresh_token: this.refreshToken,
+                },
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                responseType: 'json',
+            });
+            const data = response.body;
+            this.accessToken = data.access_token;
+            if (data.refresh_token) {
+                this.refreshToken = data.refresh_token;
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to refresh token:', error.message);
+            return false;
+        }
+    }
+    /**
+     * Make an authenticated API request
+     */
+    async request(endpoint, options = {}) {
+        const { method = 'GET', body, retry = true } = options;
+        if (!this.accessToken) {
+            throw new Error('Not authenticated');
+        }
+        const headers = {
+            'Authorization': `Bearer ${this.accessToken}`,
+            'Content-Type': 'application/json',
+        };
+        try {
+            const response = await got(`${this.apiUrl}${endpoint}`, {
+                method,
+                json: body,
+                headers,
+                responseType: 'json',
+            });
+            return response.body;
+        }
+        catch (error) {
+            // Handle 401 - try to refresh token
+            if (error.response?.statusCode === 401 && retry) {
+                const refreshed = await this.refreshAccessToken();
+                if (refreshed) {
+                    // Retry the request with new token
+                    return this.request(endpoint, { method, body, retry: false });
+                }
+            }
+            // Re-throw with more info
+            if (error.response?.body) {
+                throw new Error(error.response.body.error || error.message);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Sync prompts to the backend via /api/prompts/batch
+     *
+     * The batch endpoint accepts an array of prompt objects and dedupes by
+     * content_hash (falls back to SHA-256 of content if not provided). Returns
+     * `{synced, failed, total}` so the daemon can update its counters.
+     */
+    async syncPrompts(prompts) {
+        if (!this.accessToken) {
+            throw new Error('Not authenticated');
+        }
+        // Compute SHA-256 for any prompt missing a content_hash, so the server
+        // can dedup reliably. Prompts that already have a hash pass through as-is.
+        const payload = prompts.map((p) => ({
+            ...p,
+            content_hash: p.content_hash ?? generatePromptHash(p.content),
+        }));
+        const response = await got.post(`${this.apiUrl}/api/prompts/batch`, {
+            json: { prompts: payload },
+            headers: {
+                'Authorization': `Bearer ${this.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            responseType: 'json',
+            // Server processes up to 100 prompts sequentially with dedup; observed
+            // ~56s for a full batch on slow networks. Use 90s headroom.
+            timeout: { request: 90_000 },
+        });
+        const body = response.body;
+        return {
+            synced: body.synced ?? 0,
+            failed: body.failed ?? 0,
+            total: body.total ?? payload.length,
+        };
+    }
+    /**
+     * Get recent prompts from backend
+     */
+    async getRecentPrompts(limit = 15) {
+        const response = await this.request(`/api/prompts?limit=${limit}`);
+        return response.prompts;
+    }
+    /**
+     * Verify token is valid by calling /api/auth/device
+     * Returns user info if valid
+     */
+    async verifyToken() {
+        if (!this.accessToken)
+            return null;
+        try {
+            const response = await got(`${this.apiUrl}/api/auth/device`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                responseType: 'json',
+            });
+            const data = response.body;
+            return {
+                userId: data.device?.client_id || 'unknown',
+                deviceId: data.device?.id,
+                deviceName: data.device?.name || 'CLI',
+                deviceType: data.device?.type || 'cli',
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Revoke device token (logout)
+     */
+    async revokeDevice() {
+        if (!this.accessToken)
+            return false;
+        try {
+            await got(`${this.apiUrl}/api/auth/device`, {
+                method: 'DELETE',
+                headers: {
+                    'Authorization': `Bearer ${this.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+                responseType: 'json',
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to revoke device:', error.message);
+            return false;
+        }
+    }
+}
+/**
+ * Generate hash for deduplication
+ */
+export function generatePromptHash(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+//# sourceMappingURL=api.js.map