promptcase 1.0.4

package/dist/services/daemon.js

@@ -0,0 +1,432 @@
+/**
+ * Daemon service for background sync
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { APIService } from './api.js';
+import { getConfig } from '../lib/config.js';
+import { ClaudeCaptureService } from './claude-capture.js';
+import { scriptPath } from '../lib/path.js';
+import { DEFAULT_API_URL, MAX_PROMPTS_PER_SYNC } from '../lib/constants.js';
+export class DaemonService {
+    apiService;
+    captureService;
+    configService;
+    syncInterval = null;
+    status;
+    pidFile;
+    constructor(apiUrl = DEFAULT_API_URL) {
+        this.apiService = new APIService(apiUrl);
+        this.captureService = new ClaudeCaptureService();
+        this.configService = getConfig();
+        this.pidFile = this.getPidFilePath();
+        this.status = {
+            lastSyncAt: null,
+            promptsSynced: 0,
+            errors: [],
+            isRunning: false,
+        };
+    }
+    /**
+     * Get PID file path for cross-platform support
+     */
+    getPidFilePath() {
+        const isWindows = process.platform === 'win32';
+        const configDir = path.join(os.homedir(), '.promptcase');
+        if (isWindows) {
+            return path.join(configDir, 'daemon.lock');
+        }
+        return path.join(configDir, 'daemon.pid');
+    }
+    /**
+     * Check if daemon is already running
+     */
+    async isRunning() {
+        if (!fs.existsSync(this.pidFile)) {
+            return false;
+        }
+        try {
+            const pid = parseInt(fs.readFileSync(this.pidFile, 'utf-8').trim(), 10);
+            // On Unix, check if process exists
+            if (process.platform !== 'win32') {
+                try {
+                    process.kill(pid, 0);
+                    return true;
+                }
+                catch {
+                    // Process doesn't exist
+                    await this.cleanupPidFile();
+                    return false;
+                }
+            }
+            // On Windows, just check if PID file exists
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Write PID file
+     */
+    async writePidFile() {
+        const configDir = path.dirname(this.pidFile);
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        fs.writeFileSync(this.pidFile, process.pid.toString());
+    }
+    /**
+     * Clean up PID file
+     */
+    async cleanupPidFile() {
+        if (fs.existsSync(this.pidFile)) {
+            fs.unlinkSync(this.pidFile);
+        }
+    }
+    /**
+     * Initialize with stored credentials
+     */
+    async initialize() {
+        const credentials = await this.configService.getCredentials();
+        if (!credentials) {
+            return false;
+        }
+        this.apiService.setTokens(credentials.accessToken, credentials.refreshToken);
+        // Restore the lifetime promptsSynced counter from the previous run.
+        // This is important for `promptcase sync` which creates a fresh
+        // DaemonService instance each invocation — without restore, every
+        // foreground sync would show the count for just that one call instead
+        // of the cumulative lifetime total.
+        const stored = await this.configService.getDaemonStatus();
+        if (stored && typeof stored.promptsSynced === 'number') {
+            this.status.promptsSynced = stored.promptsSynced;
+        }
+        return true;
+    }
+    /**
+     * Save refreshed tokens back to config.
+     *
+     * The server refresh endpoint returns new `expires_in` (in seconds). We
+     * honour that value instead of hardcoding 180 days so if the server
+     * ever rotates the TTL, the CLI tracks it correctly.
+     */
+    async saveRefreshedTokens() {
+        const credentials = await this.configService.getCredentials();
+        if (!credentials)
+            return;
+        const accessToken = this.apiService.getAccessToken();
+        const refreshToken = this.apiService.getRefreshToken();
+        if (accessToken && refreshToken) {
+            // Use existing expiresAt as fallback; we don't know the server's new
+            // expires_in from outside the refresh path, so the safest is to keep
+            // the existing window unless we have a fresh signal. (The TTL on
+            // tokens in `refreshAccessToken`'s response is 180d server-side.)
+            await this.configService.setCredentials({
+                accessToken,
+                refreshToken,
+                expiresAt: credentials.expiresAt,
+                createdAt: credentials.createdAt,
+            });
+        }
+    }
+    /**
+     * Start the daemon (foreground process)
+     */
+    async start() {
+        // Initialize with credentials
+        if (!await this.initialize()) {
+            console.error('No credentials found. Run "promptcase init" first.');
+            return false;
+        }
+        // Write PID file
+        await this.writePidFile();
+        // Start sync loop
+        const syncInterval = await this.configService.getSyncInterval();
+        this.status.isRunning = true;
+        // Restore the lifetime promptsSynced counter from the previous run so
+        // the count stays cumulative across daemon restarts. The `status`
+        // command reads this from conf, so without restoring it, every fresh
+        // daemon process would report "Total synced: 0" until the first sync.
+        const stored = await this.configService.getDaemonStatus();
+        if (stored && typeof stored.promptsSynced === 'number') {
+            this.status.promptsSynced = stored.promptsSynced;
+        }
+        // Save daemon status
+        await this.configService.setDaemonStatus({
+            isRunning: true,
+            pid: process.pid,
+            startedAt: new Date(),
+            lastSyncAt: null,
+            nextSyncAt: new Date(Date.now() + syncInterval),
+            promptsSynced: this.status.promptsSynced,
+        });
+        console.log(`\n🟢 Daemon started (PID: ${process.pid})`);
+        console.log(`   Syncing every ${syncInterval / 1000} seconds`);
+        console.log(`   Logs: ${this.getPidFilePath().replace(/\/[^\/]+$/, '/daemon.log')}`);
+        console.log(`\n   Press Ctrl+C to stop the daemon\n`);
+        // Initial sync
+        await this.sync();
+        // Schedule periodic syncs. The interval timers MUST stay alive (no
+        // `.unref()`) because they are the only thing keeping the Node event
+        // loop busy once `start()` returns its `new Promise(() => {})`. Adding
+        // `.unref()` here caused the daemon to silently exit after the first
+        // sync (regression from v1.0.2's working behavior). KeepAlive=true in
+        // the LaunchAgent then respawns it, but each respawn dies the same way
+        // — visible to the user as "Daemon: 🔴 Not running".
+        this.syncInterval = setInterval(async () => {
+            await this.sync();
+        }, syncInterval);
+        // Save refreshed tokens every hour.
+        setInterval(async () => {
+            await this.saveRefreshedTokens();
+        }, 60 * 60 * 1000);
+        // Handle graceful shutdown
+        process.on('SIGINT', async () => {
+            console.log('\n\n🛑 Stopping daemon...');
+            await this.stop();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            console.log('\n\n🛑 Stopping daemon...');
+            await this.stop();
+            process.exit(0);
+        });
+        // Keep the process alive
+        return new Promise(() => {
+            // Never resolves - keeps daemon running
+        });
+    }
+    /**
+     * Stop the daemon
+     */
+    async stop() {
+        if (this.syncInterval) {
+            clearInterval(this.syncInterval);
+            this.syncInterval = null;
+        }
+        await this.cleanupPidFile();
+        this.status.isRunning = false;
+        await this.configService.setDaemonStatus({
+            isRunning: false,
+            pid: undefined,
+            startedAt: null,
+            lastSyncAt: this.status.lastSyncAt,
+            nextSyncAt: null,
+            // Preserve the lifetime synced count so the next daemon start picks it up
+            promptsSynced: this.status.promptsSynced,
+        });
+        return true;
+    }
+    /**
+     * Sync prompts from Claude to backend
+     */
+    async sync() {
+        if (!this.apiService.isAuthenticated()) {
+            this.status.errors.push('Not authenticated');
+            return this.status;
+        }
+        try {
+            // Get prompts from Claude. Use a timestamp cursor to skip prompts older
+            // than the last successful sync (server dedups, but skipping locally
+            // saves bandwidth on subsequent syncs).
+            const cursorIso = await this.configService.getLastSyncCursor();
+            const since = cursorIso ? new Date(cursorIso) : undefined;
+            const prompts = await this.captureService.getAllPrompts(since, MAX_PROMPTS_PER_SYNC);
+            if (prompts.length === 0) {
+                this.status.lastSyncAt = new Date();
+                await this.configService.setDaemonStatus({
+                    isRunning: true,
+                    pid: process.pid,
+                    startedAt: new Date(),
+                    lastSyncAt: this.status.lastSyncAt,
+                    nextSyncAt: new Date(Date.now() + (await this.configService.getSyncInterval())),
+                    promptsSynced: this.status.promptsSynced,
+                });
+                return this.status;
+            }
+            // Prepare prompts for API
+            const apiPrompts = prompts.map((p) => ({
+                content: p.content,
+                title: p.title,
+                source_type: 'claude_code',
+                captured_at: p.timestamp.toISOString(),
+                content_hash: p.hash,
+                app_context: {
+                    projectPath: p.projectPath,
+                    sessionId: p.sessionId,
+                },
+            }));
+            // Sync to backend
+            const result = await this.apiService.syncPrompts(apiPrompts);
+            this.status.lastSyncAt = new Date();
+            this.status.promptsSynced += result.synced;
+            // Persist the cursor at the newest prompt we ATTEMPTED to sync (not
+            // just newly-synced ones). The server's content_hash dedup means we'll
+            // see `result.synced: 0` on subsequent runs even though the prompts
+            // are already saved — that's normal. We want the cursor to advance
+            // so the next run only fetches prompts newer than the newest one we've
+            // seen, regardless of whether they were already on the server.
+            if (prompts.length > 0) {
+                const newest = prompts[0].timestamp;
+                await this.configService.setLastSyncCursor(newest.toISOString());
+            }
+            // Update daemon status with new sync time. Include promptsSynced so the
+            // `status` command (which reads from conf) shows the cumulative count
+            // across daemon restarts.
+            const syncInterval = await this.configService.getSyncInterval();
+            await this.configService.setDaemonStatus({
+                isRunning: true,
+                pid: process.pid,
+                startedAt: new Date(),
+                lastSyncAt: this.status.lastSyncAt,
+                nextSyncAt: new Date(Date.now() + syncInterval),
+                promptsSynced: this.status.promptsSynced,
+            });
+            console.log(`[${new Date().toLocaleTimeString()}] ✅ Synced ${result.synced} prompts (total this session: ${this.status.promptsSynced})`);
+            return this.status;
+        }
+        catch (error) {
+            const errorMsg = `Sync error: ${error.message}`;
+            this.status.errors.push(errorMsg);
+            console.error(`[${new Date().toLocaleTimeString()}] ❌ ${errorMsg}`);
+            return this.status;
+        }
+    }
+    /**
+     * Get current status
+     */
+    getStatus() {
+        return { ...this.status };
+    }
+    /**
+     * Setup process manager for auto-start on boot
+     */
+    async setupAutoStart() {
+        try {
+            if (process.platform === 'win32') {
+                return this.setupWindowsService();
+            }
+            else if (process.platform === 'darwin') {
+                return this.setupMacOSLaunchd();
+            }
+            else {
+                return this.setupLinuxSystemd();
+            }
+        }
+        catch (error) {
+            console.error('Failed to setup auto-start:', error.message);
+            return false;
+        }
+    }
+    /**
+     * Get auto-start script command
+     * Uses 'start' subcommand since daemon command is removed
+     */
+    getAutoStartCommand() {
+        return `${process.execPath} ${scriptPath()} start`;
+    }
+    /**
+     * Setup macOS LaunchAgent for auto-start
+     */
+    async setupMacOSLaunchd() {
+        const launchAgentsDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+        const plistPath = path.join(launchAgentsDir, 'app.promptcase.daemon.plist');
+        const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>app.promptcase.daemon</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${process.execPath}</string>
+        <string>${scriptPath()}</string>
+        <string>start</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>ProcessType</key>
+    <string>Background</string>
+    <key>StandardOutPath</key>
+    <string>${path.join(os.homedir(), '.promptcase', 'daemon.log')}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(os.homedir(), '.promptcase', 'daemon.error.log')}</string>
+</dict>
+</plist>`;
+        try {
+            if (!fs.existsSync(launchAgentsDir)) {
+                fs.mkdirSync(launchAgentsDir, { recursive: true });
+            }
+            fs.writeFileSync(plistPath, plistContent);
+            console.log(`✅ LaunchAgent installed at ${plistPath}`);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to setup LaunchAgent:', error.message);
+            return false;
+        }
+    }
+    /**
+     * Setup Linux systemd service for auto-start
+     */
+    async setupLinuxSystemd() {
+        // Use user-level systemd service instead of system-level (no sudo needed)
+        const userServiceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+        const servicePath = path.join(userServiceDir, 'promptcase.service');
+        const serviceContent = `[Unit]
+Description=PromptCase CLI Daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${this.getAutoStartCommand()}
+Restart=on-failure
+RestartSec=10
+StandardOutput=append:${path.join(os.homedir(), '.promptcase', 'daemon.log')}
+StandardError=append:${path.join(os.homedir(), '.promptcase', 'daemon.error.log')}
+
+[Install]
+WantedBy=default.target`;
+        try {
+            if (!fs.existsSync(userServiceDir)) {
+                fs.mkdirSync(userServiceDir, { recursive: true });
+            }
+            fs.writeFileSync(servicePath, serviceContent);
+            console.log(`✅ User systemd service installed at ${servicePath}`);
+            console.log('   To enable auto-start, run:');
+            console.log('     systemctl --user enable promptcase');
+            console.log('     systemctl --user start promptcase');
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to setup systemd service:', error.message);
+            return false;
+        }
+    }
+    /**
+     * Setup Windows service for auto-start
+     */
+    async setupWindowsService() {
+        const startupPath = path.join(os.homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
+        const batchPath = path.join(startupPath, 'promptcase.bat');
+        const batchContent = `@echo off
+"${this.getAutoStartCommand()}"`;
+        try {
+            if (!fs.existsSync(startupPath)) {
+                fs.mkdirSync(startupPath, { recursive: true });
+            }
+            fs.writeFileSync(batchPath, batchContent);
+            console.log(`✅ Startup shortcut installed at ${batchPath}`);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to setup Windows startup:', error.message);
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=daemon.js.map

package/dist/types/index.js

@@ -0,0 +1,13 @@
+/**
+ * Shared types for PromptCase CLI
+ */
+// Supported source types — kept in sync with the `prompts.source_type`
+// check constraint in the database schema (migration 001).
+export const SourceType = {
+    CLAUDE_CODE: 'claude_code',
+    CLAUDE_AI: 'claude_ai',
+    GEMINI: 'gemini',
+    VS_CODE: 'vs_code',
+    CLAUDE_DESKTOP: 'claude_desktop',
+};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "promptcase",
+  "version": "1.0.4",
+  "description": "CLI daemon to capture and sync AI prompts to PromptCase web app",
+  "main": "dist/index.js",
+  "bin": {
+    "promptcase": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix"
+  },
+  "keywords": [
+    "ai",
+    "prompts",
+    "capture",
+    "sync",
+    "daemon"
+  ],
+  "author": "PromptCase",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "conf": "^12.0.0",
+    "got": "^14.2.1",
+    "inquirer": "^9.2.16",
+    "promptcase": "file:"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.10",
+    "@types/node": "^20.10.0",
+    "tsx": "^4.6.1",
+    "typescript": "^5.3.2"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "types": "./dist/index.d.ts"
+}