promptcase 1.0.5 → 1.0.7

package/README.md

@@ -40,6 +40,7 @@ The daemon auto-starts on login/boot and runs in the background.
 | `promptcase show` | Show recent synced prompts |
 | `promptcase stop` | Stop the running daemon (auto-start is preserved for next boot) |
 | `promptcase logout` | Stop daemon, revoke token, clear credentials |
+| `promptcase start` | **Internal** — run the daemon in the foreground. Invoked by the auto-start service (LaunchAgent / systemd / Startup folder). You don't normally need to run this directly. |
 
 ## How it works
 

package/dist/commands/init.js

@@ -8,6 +8,9 @@
 import inquirer from 'inquirer';
 import { Command } from 'commander';
 import { exec, spawn } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 import { APIService } from '../services/api.js';
 import { DaemonService } from '../services/daemon.js';
 import { getConfig } from '../lib/config.js';
@@ -89,6 +92,15 @@ async function verifyAndShowUser(api) {
 }
 /**
  * Start daemon in detached background process
+ *
+ * Polls for the lock dir to appear (the daemon writes the lock as soon as it
+ * finishes starting). This avoids the previous 1500ms fixed wait that would
+ * give false "Daemon may not have started" warnings on slow machines where
+ * Node + module load + lock acquisition took longer than 1500ms — the daemon
+ * would actually be running, but the parent had already given up and
+ * returned, leaving the user to think the spawn failed. The 1500ms was a
+ * too-tight deadline and the real signal is "lock dir exists" which means
+ * "daemon is fully initialized".
  */
 async function startDaemonDetached(apiUrl) {
     // Detach the daemon process so it runs independently
@@ -98,12 +110,21 @@ async function startDaemonDetached(apiUrl) {
         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) {
+    // Poll for the lock to appear. The daemon writes the lock dir as the
+    // first step of its lifecycle, so seeing it is a reliable "running" signal.
+    // Cap at 10 seconds — if the lock hasn't appeared by then, the daemon
+    // process must have died.
+    const lockPath = path.join(os.homedir(), '.promptcase', 'daemon.pid.lock');
+    const deadline = Date.now() + 10_000;
+    let acquired = false;
+    while (Date.now() < deadline) {
+        if (fs.existsSync(lockPath)) {
+            acquired = true;
+            break;
+        }
+        await new Promise(resolve => setTimeout(resolve, 200));
+    }
+    if (acquired) {
         console.log('   ✅ Daemon started in background');
     }
     else {

package/dist/services/claude-capture.js

@@ -287,7 +287,23 @@ export class ClaudeCaptureService {
     }
     /**
      * Get all prompts from all sources (project transcripts + history),
-     * deduplicated by SHA-256 content hash, sorted newest first.
+     * deduplicated by SHA-256 content hash.
+     *
+     * Sort order depends on whether this is a backfill or an incremental sync:
+     *
+     * - **Backfill** (`since` is undefined): the daemon's first sync, with no
+     *   prior cursor. We sort **OLDEST FIRST** so that the server inserts
+     *   prompts in chronological order. Since the server's `created_at`
+     *   column defaults to insert time and the dashboard sorts `created_at
+     *   DESC`, the *most recent* prompt in the batch ends up at the top of
+     *   the dashboard — matching the user's intuition that "latest shows
+     *   first."
+     *
+     * - **Incremental** (`since` is a date): the daemon's subsequent syncs
+     *   pick up only prompts newer than the cursor. We sort **NEWEST FIRST**
+     *   so that when the cursor advances we always send the freshest
+     *   prompts first (and the new cursor lands on the actual latest
+     *   prompt, not a few-batch-behind one).
      */
     async getAllPrompts(since, limit = 100) {
         const sessions = await this.getSessions();
@@ -326,7 +342,14 @@ export class ClaudeCaptureService {
             seenHashes.add(prompt.hash);
             allPrompts.push(prompt);
         }
-        allPrompts.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        // Backfill: oldest first (so newest ends up at top of dashboard).
+        // Incremental: newest first (so the cursor advances to actual latest).
+        if (since) {
+            allPrompts.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+        }
+        else {
+            allPrompts.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+        }
         return allPrompts.slice(0, limit);
     }
     /**

package/dist/services/daemon.js

@@ -114,6 +114,14 @@ export class DaemonService {
     async acquireExclusiveLock() {
         try {
             const lockDir = this.pidFile + '.lock';
+            // Ensure the parent dir exists before we try to mkdir the lock inside
+            // it. Without this, the very first run on a clean machine gets ENOENT
+            // because ~/.promptcase/ doesn't exist yet (writePidFile creates it
+            // later, but only if it gets to run).
+            const parentDir = path.dirname(lockDir);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
             try {
                 fs.mkdirSync(lockDir);
                 // We won the race — write our PID into the lock dir for diagnostics

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "promptcase",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "CLI daemon to capture and sync AI prompts to PromptCase web app",
   "main": "dist/index.js",
   "bin": {