clocktopus 1.10.0 → 1.10.1

package/dist/index.js

@@ -6,7 +6,7 @@ import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { execSync } from 'child_process';
-import { completeLatestSession, getLatestSession, setSessionJiraWorklogId } from './lib/db.js';
+import { closeStaleOpenSessions, completeLatestSession, getLatestSession, setSessionJiraWorklogId } from './lib/db.js';
 import { isClockifyEnabled } from './lib/credentials.js';
 import { ensureNativeAddons } from './lib/ensure-native-addons.js';
 import { DASHBOARD_PORT, DASHBOARD_URL } from './lib/constants.js';
@@ -198,6 +198,23 @@ program
     .action(async () => {
     const creds = isClockifyEnabled() ? await getWorkspaceAndUser() : { workspaceId: '', userId: '' };
     const { workspaceId, userId } = creds;
+    // Auto-close any session left open longer than this on monitor startup,
+    // so a PM2 restart after a long sleep doesn't accidentally bill the
+    // entire gap to Jira when the next idle/lock event fires.
+    const MAX_OPEN_SESSION_MS = 12 * 60 * 60 * 1000; // 12h
+    try {
+        const stale = closeStaleOpenSessions(MAX_OPEN_SESSION_MS);
+        if (stale.length > 0) {
+            console.log(chalk.yellow(`Auto-closed ${stale.length} stale open session(s) older than ${MAX_OPEN_SESSION_MS / 3600000}h. ` +
+                `No Jira worklog was posted for these; review and log manually if needed.`));
+            for (const s of stale) {
+                console.log(chalk.gray(`  - id=${s.id} jira=${s.jiraTicket ?? '-'} startedAt=${s.startedAt} closedAt=${s.completedAt}`));
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('Failed to scan for stale open sessions:'), err);
+    }
     async function stopTimerAndLog(reason) {
         const clockifyOn = isClockifyEnabled();
         const latestSession = getLatestSession();
@@ -211,7 +228,22 @@ program
                 return false;
         }
         console.log(chalk.yellow(reason));
-        const completedAt = new Date().toISOString();
+        // Use idleTime to rewind end-of-work to the moment user actually went idle,
+        // so a weekend gap or long sleep doesn't get billed to Jira.
+        let idleSec = 0;
+        try {
+            const idleModule = await import('desktop-idle');
+            idleSec = Math.max(0, Math.floor(idleModule.default.getIdleTime() || 0));
+        }
+        catch { }
+        let completedMs = Date.now() - idleSec * 1000;
+        if (latestSession) {
+            const startedMs = new Date(latestSession.startedAt).getTime();
+            // Don't let the adjusted end fall before start; floor at start+1s.
+            if (completedMs < startedMs)
+                completedMs = startedMs + 1000;
+        }
+        const completedAt = new Date(completedMs).toISOString();
         if (clockifyOn) {
             const stoppedEntry = await (await clockify()).stopTimer(workspaceId, userId);
             if (!stoppedEntry)

package/dist/lib/db.js

@@ -3,10 +3,17 @@ import * as path from 'path';
 import { Database } from 'bun:sqlite';
 import { z } from 'zod';
 function getDataDir() {
+    // Explicit override always wins (useful for tests, CI, or per-shell isolation).
+    const override = process.env.CLOCKTOPUS_DATA_DIR;
+    if (override && override.trim())
+        return path.resolve(override);
     const scriptDir = path.dirname(new URL(import.meta.url).pathname);
     const isDev = scriptDir.includes('/Projects/') || scriptDir.includes('/src/');
     if (isDev) {
-        return path.join(process.cwd(), 'data/db');
+        // Anchor to the repo (scriptDir is <repo>/dist/lib), NOT process.cwd().
+        // Otherwise the git post-checkout hook, which runs in the target project's
+        // cwd, would spawn a stray data/ directory there.
+        return path.resolve(scriptDir, '..', '..', 'data', 'db');
     }
     return path.join(process.env.HOME || '~', '.clocktopus', 'data');
 }
@@ -200,6 +207,33 @@ export function getLatestSession() {
   `);
     return SessionSchema.parse(stmt.get());
 }
+// Close any session that has been open longer than maxAgeMs.
+// completedAt is set to min(startedAt + maxAgeMs, now - maxAgeMs) so the
+// row's duration stays bounded AND completedAt is always at least maxAgeMs
+// in the past — that guarantees safeRestartTimerIfNeeded's 2h-recency
+// check rejects these rows and they don't get auto-resumed.
+// Does NOT post to Jira; caller controls that.
+// Returns the closed rows so the caller can warn or audit.
+export function closeStaleOpenSessions(maxAgeMs) {
+    const db = getDb();
+    const cutoffMs = Date.now() - maxAgeMs;
+    const cutoffIso = new Date(cutoffMs).toISOString();
+    const rows = db
+        .prepare('SELECT id, jiraTicket, startedAt FROM sessions WHERE completedAt IS NULL AND startedAt < ?')
+        .all(cutoffIso);
+    if (rows.length === 0)
+        return [];
+    const stmt = db.prepare('UPDATE sessions SET completedAt = ?, isAutoCompleted = 1 WHERE id = ?');
+    const closed = [];
+    for (const r of rows) {
+        const startedMs = new Date(r.startedAt).getTime();
+        const completedMs = Math.min(startedMs + maxAgeMs, cutoffMs);
+        const completedAt = new Date(completedMs).toISOString();
+        stmt.run(completedAt, r.id);
+        closed.push({ ...r, completedAt });
+    }
+    return closed;
+}
 export function deleteOldSessions(days) {
     const db = getDb();
     const date = new Date();

package/dist/lib/jira.js

@@ -61,7 +61,20 @@ async function jiraApiRequest(endpoint, method, body) {
         return null;
     }
 }
+// Hard cap so a corrupted duration (orphaned session, missed idle, etc.)
+// cannot post a multi-day worklog to Jira.
+export const MAX_WORKLOG_SECONDS = 12 * 60 * 60; // 12h
 export async function stopJiraTimer(ticketId, timeSpentSeconds) {
+    if (!Number.isFinite(timeSpentSeconds) || timeSpentSeconds <= 0) {
+        console.warn(`[jira] stopJiraTimer: refusing non-positive duration (${timeSpentSeconds}s) for ${ticketId}.`);
+        return null;
+    }
+    if (timeSpentSeconds > MAX_WORKLOG_SECONDS) {
+        const hours = (timeSpentSeconds / 3600).toFixed(1);
+        console.warn(`[jira] stopJiraTimer: refusing oversized worklog (${timeSpentSeconds}s ≈ ${hours}h) for ${ticketId}. ` +
+            `Cap is ${MAX_WORKLOG_SECONDS}s (${MAX_WORKLOG_SECONDS / 3600}h). Log manually via the dashboard if needed.`);
+        return null;
+    }
     const body = {
         timeSpentSeconds,
         comment: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clocktopus",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "Time-tracking automation for Clockify with idle monitoring, Jira integration, Google Calendar sync, CLI, web dashboard, and desktop app.",
   "type": "module",
   "main": "dist/index.js",