@jxtools/promptline 1.3.16 → 1.3.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxtools/promptline",
-  "version": "1.3.16",
+  "version": "1.3.19",
   "type": "module",
   "license": "ISC",
   "bin": {

package/promptline-session-end.sh

@@ -32,13 +32,18 @@ else
   exit 0
 fi
 
-QUEUE_DIR="$(dirname "$QUEUE_FILE")"
-export QUEUE_FILE QUEUE_DIR SESSION_ID QUEUES_BASE
+export QUEUE_FILE SESSION_ID QUEUES_BASE
 
 python3 << 'PYEOF'
-import json, os, glob, tempfile
+import glob
+import json
+import os
+import subprocess
+import tempfile
 from datetime import datetime, timezone
 
+LEGACY_ORPHAN_TTL_SECONDS = 24 * 60 * 60
+
 def atomic_write(path, obj):
     dir_name = os.path.dirname(path)
     fd, tmp_path = tempfile.mkstemp(dir=dir_name, suffix=".tmp")
@@ -51,6 +56,81 @@ def atomic_write(path, obj):
         except OSError: pass
         raise
 
+def parse_iso_datetime(value):
+    if not isinstance(value, str) or not value:
+        return None
+    try:
+        dt = datetime.fromisoformat(value)
+    except ValueError:
+        if value.endswith("Z"):
+            try:
+                dt = datetime.fromisoformat(value[:-1] + "+00:00")
+            except ValueError:
+                return None
+        else:
+            return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt.astimezone(timezone.utc)
+
+def is_process_alive(pid):
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+def read_process_started_at(pid):
+    try:
+        output = subprocess.check_output(
+            ["ps", "-p", str(pid), "-o", "lstart="],
+            stderr=subprocess.DEVNULL,
+            text=True,
+        ).strip()
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError):
+        return None
+    return output or None
+
+def has_live_owner_process(data):
+    owner_pid = data.get("ownerPid")
+    if type(owner_pid) is not int or owner_pid <= 0:
+        return None
+    if not is_process_alive(owner_pid):
+        return False
+
+    expected_started_at = data.get("ownerStartedAt")
+    if not isinstance(expected_started_at, str) or not expected_started_at.strip():
+        return True
+
+    actual_started_at = read_process_started_at(owner_pid)
+    if actual_started_at is None:
+        return False
+    return actual_started_at == expected_started_at.strip()
+
+def is_legacy_session_stale(data, now_dt):
+    activity_dt = parse_iso_datetime(data.get("lastActivity"))
+    if activity_dt is None:
+        activity_dt = parse_iso_datetime(data.get("startedAt"))
+    if activity_dt is None:
+        return False
+    return (now_dt - activity_dt).total_seconds() >= LEGACY_ORPHAN_TTL_SECONDS
+
+def should_close_as_orphan(data, now_dt):
+    if data.get("closedAt") is not None:
+        return False
+
+    owner_status = has_live_owner_process(data)
+    if owner_status is True:
+        return False
+    if owner_status is False:
+        return True
+
+    return is_legacy_session_stale(data, now_dt)
+
 def close_session(path, now, data=None):
     if data is None:
         with open(path, "r") as f:
@@ -61,12 +141,14 @@ def close_session(path, now, data=None):
             p["completedAt"] = now
     data["closedAt"] = now
     data["lastActivity"] = now
+    data["ownerPid"] = None
+    data["ownerStartedAt"] = None
     atomic_write(path, data)
 
 queue_file = os.environ["QUEUE_FILE"]
-queue_dir = os.environ["QUEUE_DIR"]
 session_id = os.environ["SESSION_ID"]
-now = datetime.now(timezone.utc).isoformat()
+now_dt = datetime.now(timezone.utc)
+now = now_dt.isoformat()
 
 try:
     close_session(queue_file, now)
@@ -83,7 +165,7 @@ for project_dir in glob.glob(os.path.join(queues_base, "*")):
         try:
             with open(path, "r") as f:
                 data = json.load(f)
-            if data.get("closedAt") is not None:
+            if not should_close_as_orphan(data, now_dt):
                 continue
             close_session(path, now, data)
         except (json.JSONDecodeError, IOError, OSError):

package/promptline-session-register.sh

@@ -24,6 +24,12 @@ if [ -z "$CWD" ] || [ -z "$SESSION_ID" ]; then
   exit 0
 fi
 
+OWNER_PID="${PPID:-}"
+OWNER_STARTED_AT=""
+if [ -n "$OWNER_PID" ]; then
+  OWNER_STARTED_AT=$(ps -p "$OWNER_PID" -o lstart= 2>/dev/null | sed 's/^[[:space:]]*//' || true)
+fi
+
 # Search for existing session across all projects
 QUEUES_BASE="$HOME/.promptline/queues"
 EXISTING=$(find "$QUEUES_BASE" -maxdepth 2 -name "$SESSION_ID.json" -print -quit 2>/dev/null || true)
@@ -39,7 +45,7 @@ else
   mkdir -p "$QUEUE_DIR"
 fi
 
-export QUEUE_FILE SESSION_ID CWD PROJECT TRANSCRIPT_PATH
+export QUEUE_FILE SESSION_ID CWD PROJECT TRANSCRIPT_PATH OWNER_PID OWNER_STARTED_AT
 
 python3 << 'PYEOF'
 import json, os, tempfile
@@ -89,15 +95,31 @@ session_id = os.environ["SESSION_ID"]
 cwd = os.environ["CWD"]
 project = os.environ["PROJECT"]
 transcript_path = os.environ.get("TRANSCRIPT_PATH", "")
+owner_pid_raw = os.environ.get("OWNER_PID", "").strip()
+owner_started_at = os.environ.get("OWNER_STARTED_AT", "").strip() or None
 now = datetime.now(timezone.utc).isoformat()
 
+try:
+    owner_pid = int(owner_pid_raw) if owner_pid_raw else None
+except ValueError:
+    owner_pid = None
+
 if os.path.isfile(queue_file):
     try:
         with open(queue_file, "r") as f:
             data = json.load(f)
         data["lastActivity"] = now
+        data["closedAt"] = None
         if not data.get("sessionName"):
             data["sessionName"] = extract_session_name(transcript_path)
+        if owner_pid is not None and owner_pid > 0:
+            data["ownerPid"] = owner_pid
+        elif "ownerPid" not in data:
+            data["ownerPid"] = None
+        if owner_started_at is not None:
+            data["ownerStartedAt"] = owner_started_at
+        elif "ownerStartedAt" not in data:
+            data["ownerStartedAt"] = None
         atomic_write(queue_file, data)
     except (json.JSONDecodeError, IOError):
         pass
@@ -114,6 +136,8 @@ else:
         "currentPromptId": None,
         "completedAt": None,
         "closedAt": None,
+        "ownerPid": owner_pid if owner_pid is not None and owner_pid > 0 else None,
+        "ownerStartedAt": owner_started_at,
     }
     atomic_write(queue_file, data)
 

package/src/backend/queue-store.ts

@@ -82,6 +82,9 @@ function hasPendingWork(session: SessionQueue): boolean {
 }
 
 export function withComputedStatus(session: SessionQueue): SessionQueue & { status: SessionStatus } {
+  if (session.closedAt != null) {
+    return { ...session, status: 'idle' };
+  }
   const hasRunningPrompt = session.prompts.some(p => p.status === 'running');
   const isStale = msSinceLastActivity(session) > SESSION_ACTIVE_TIMEOUT_MS;
   const status: SessionStatus = (hasRunningPrompt || !isStale) ? 'active' : 'idle';
@@ -89,8 +92,8 @@ export function withComputedStatus(session: SessionQueue): SessionQueue & { stat
 }
 
 export function isSessionVisible(session: SessionQueue, now: number = Date.now()): boolean {
-  if (hasPendingWork(session)) return true;
   if (session.closedAt != null) return false;
+  if (hasPendingWork(session)) return true;
   const msSinceStart = now - new Date(session.startedAt).getTime();
   return msSinceStart <= SESSION_ABANDONED_TIMEOUT_MS;
 }

package/src/types/queue.ts

@@ -21,6 +21,8 @@ export interface SessionQueue {
   currentPromptId: string | null;
   completedAt: string | null;
   closedAt: string | null;
+  ownerPid?: number | null;
+  ownerStartedAt?: string | null;
 }
 
 export type SessionWithStatus = SessionQueue & { status: SessionStatus };