clocktopus 1.9.0 → 1.10.1

package/dist/index.js

@@ -1,23 +1,32 @@
 #!/usr/bin/env bun
 import { Command } from 'commander';
-import inquirer from 'inquirer';
 import chalk from 'chalk';
-import { Clockify } from './clockify.js';
 import * as fs from 'fs';
 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 { stopJiraTimer } from './lib/jira.js';
-import { startDashboard } from './dashboard/server.js';
 import { ensureNativeAddons } from './lib/ensure-native-addons.js';
 import { DASHBOARD_PORT, DASHBOARD_URL } from './lib/constants.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const program = new Command();
-const clockify = new Clockify();
+// Clockify + Jira pull in axios (via follow-redirects), which in Bun triggers
+// a tty WriteStream crash when loaded from a git hook context. Defer.
+let _clockify = null;
+async function clockify() {
+    if (!_clockify) {
+        const { Clockify } = await import('./clockify.js');
+        _clockify = new Clockify();
+    }
+    return _clockify;
+}
+async function stopJiraTimer(...args) {
+    const { stopJiraTimer: fn } = await import('./lib/jira.js');
+    return fn(...args);
+}
 async function getLocalProjects() {
     const dataDir = path.join(__dirname, '../data');
     const localProjectsPath = path.join(dataDir, 'local-projects.json');
@@ -39,7 +48,7 @@ async function getLocalProjects() {
     }
 }
 async function getWorkspaceAndUser() {
-    const user = await clockify.getUser();
+    const user = await (await clockify()).getUser();
     if (!user) {
         console.log(chalk.red('[index] Could not connect to Clockify. Please check your API key.'));
         process.exit(1);
@@ -72,7 +81,7 @@ program
         return;
     }
     const { workspaceId } = await getWorkspaceAndUser();
-    let projects = await clockify.getProjects(workspaceId);
+    let projects = await (await clockify()).getProjects(workspaceId);
     let localProjects = await getLocalProjects();
     if (localProjects.length === 0) {
         const allProjects = projects.map((p) => ({ id: p.id, name: p.name }));
@@ -89,6 +98,7 @@ program
         console.log(chalk.yellow('No projects found in your workspace.'));
         return;
     }
+    const inquirer = (await import('inquirer')).default;
     const { selectedProjectId } = await inquirer.prompt([
         {
             type: 'list',
@@ -113,7 +123,7 @@ program
     const latestSession = getLatestSession();
     if (isClockifyEnabled()) {
         const { workspaceId, userId } = await getWorkspaceAndUser();
-        const stoppedEntry = await clockify.stopTimer(workspaceId, userId);
+        const stoppedEntry = await (await clockify()).stopTimer(workspaceId, userId);
         if (!stoppedEntry) {
             console.log(chalk.yellow('No timer was running.'));
             return;
@@ -148,7 +158,7 @@ program
     .action(async () => {
     if (isClockifyEnabled()) {
         const { workspaceId, userId } = await getWorkspaceAndUser();
-        const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+        const activeEntry = await (await clockify()).getActiveTimer(workspaceId, userId);
         if (activeEntry) {
             const startTime = new Date(activeEntry.timeInterval.start);
             const duration = (new Date().getTime() - startTime.getTime()) / 1000;
@@ -188,11 +198,28 @@ 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();
         if (clockifyOn) {
-            const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+            const activeEntry = await (await clockify()).getActiveTimer(workspaceId, userId);
             if (!activeEntry)
                 return false;
         }
@@ -201,9 +228,24 @@ 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 clockify.stopTimer(workspaceId, userId);
+            const stoppedEntry = await (await clockify()).stopTimer(workspaceId, userId);
             if (!stoppedEntry)
                 return false;
         }
@@ -243,10 +285,10 @@ program
         if (isClockifyEnabled()) {
             if (!latestSession.projectId)
                 return;
-            const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+            const activeEntry = await (await clockify()).getActiveTimer(workspaceId, userId);
             if (activeEntry)
                 return;
-            await clockify.startTimer(workspaceId, latestSession.projectId, latestSession.description, latestSession.jiraTicket ?? undefined);
+            await (await clockify()).startTimer(workspaceId, latestSession.projectId, latestSession.description, latestSession.jiraTicket ?? undefined);
             console.log(chalk.green('Timer restarted for the last used project.'));
             lastResumeAt = Date.now();
             return;
@@ -352,7 +394,8 @@ program
 program
     .command('dash')
     .description(`Start the Clocktopus web dashboard on localhost:${DASHBOARD_PORT}.`)
-    .action(() => {
+    .action(async () => {
+    const { startDashboard } = await import('./dashboard/server.js');
     startDashboard();
 });
 const isDev = __dirname.includes('/Projects/') || __dirname.includes('/src/');
@@ -492,7 +535,8 @@ program
     const { installHuskyHook } = await import('./lib/husky-install.js');
     const result = installHuskyHook(process.cwd());
     if (result.installed) {
-        console.log(chalk.green(`Husky post-checkout installed at ${result.path}.`));
+        const verb = result.overwritten ? 'Overwrote' : 'Installed';
+        console.log(chalk.green(`${verb} husky post-checkout at ${result.path}.`));
         console.log(chalk.gray('  Commit it so teammates using husky get it too.'));
         return;
     }
@@ -500,10 +544,6 @@ program
         console.error(chalk.red('No .husky/ directory found. Run from the root of a husky-enabled repo.'));
         process.exit(1);
     }
-    if (result.reason === 'already-exists') {
-        console.log(chalk.yellow(`Existing ${result.path} left alone.`));
-        console.log(chalk.gray('  Add this line manually: exec ~/.clocktopus/hooks/post-checkout "$@"'));
-    }
 });
 program
     .command('hook:prompt <branch>')
@@ -516,7 +556,8 @@ program
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
         console.error(chalk.red(`Hook prompt failed: ${msg}`));
-        process.exit(0); // never block git checkout
     }
+    // Force exit — /dev/tty fs streams and the sqlite handle keep the event loop alive.
+    process.exit(0);
 });
 program.parse(process.argv);

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/hook-prompt.js

@@ -1,21 +1,15 @@
-import inquirer from 'inquirer';
 import chalk from 'chalk';
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
 import { extractTicket } from './branch-parser.js';
 import { isRepoIgnored as realIsRepoIgnored } from './hook-ignore.js';
 import { isClockifyEnabled as realIsClockifyEnabled } from './credentials.js';
 import { getJiraSummary as realGetJiraSummary } from './jira-summary.js';
-import { getOpenSession as realGetOpenSession } from './db.js';
+import { getOpenSession as realGetOpenSession, getActiveProjects } from './db.js';
 import { matchProjectByTicket } from './project-matcher.js';
+import { simplePrompt } from './simple-prompt.js';
 import { startTimer as realStartTimer } from './start-timer.js';
 function defaultReadProjects() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    const p = path.join(__dirname, '../data/local-projects.json');
     try {
-        return JSON.parse(fs.readFileSync(p, 'utf8'));
+        return getActiveProjects().map((p) => ({ id: p.id, name: p.name }));
     }
     catch {
         return [];
@@ -28,7 +22,7 @@ export async function runHookPrompt(branch, opts) {
     const getJiraSummary = d.getJiraSummary ?? realGetJiraSummary;
     const getOpenSession = d.getOpenSession ?? realGetOpenSession;
     const readProjects = d.readProjects ?? defaultReadProjects;
-    const prompt = d.prompt ?? ((qs) => inquirer.prompt(qs));
+    const prompt = d.prompt ?? simplePrompt;
     const startTimer = d.startTimer ?? realStartTimer;
     if (isRepoIgnored(opts.cwd)) {
         return { started: false, ticket: null, projectId: null, description: null, reason: 'ignored' };
@@ -51,7 +45,7 @@ export async function runHookPrompt(branch, opts) {
     const promptMsg = ticket
         ? `Start timer for ${chalk.bold(ticket)} (branch: ${branch})?`
         : `Start timer for branch ${chalk.bold(branch)}?`;
-    const confirmAnswer = await prompt([{ type: 'confirm', name: 'confirmStart', message: promptMsg, default: true }]);
+    const confirmAnswer = await prompt([{ type: 'confirm', name: 'confirmStart', message: promptMsg, default: false }]);
     if (!confirmAnswer.confirmStart) {
         return { started: false, ticket, projectId: null, description: null, reason: 'declined' };
     }

package/dist/lib/hook-script.js

@@ -6,8 +6,9 @@ if [ "$3" != "1" ]; then
   exit 0
 fi
 
-# Require an attached tty; otherwise the prompt has nowhere to render.
-if ! [ -t 0 ] || ! [ -t 1 ]; then
+# Require a tty on stdout; otherwise the prompt has nowhere to render.
+# Git commonly redirects hook stdin, so we only check stdout here.
+if ! [ -t 1 ]; then
   exit 0
 fi
 
@@ -24,6 +25,6 @@ if ! command -v clocktopus >/dev/null 2>&1; then
   exit 0
 fi
 
-clocktopus hook:prompt "$branch" </dev/tty >/dev/tty 2>&1 || true
+NO_COLOR=1 FORCE_COLOR=0 clocktopus hook:prompt "$branch" </dev/tty || true
 exit 0
 `;

package/dist/lib/husky-install.js

@@ -13,9 +13,7 @@ export function installHuskyHook(cwd) {
         return { installed: false, reason: 'no-husky-dir' };
     }
     const target = path.join(huskyDir, 'post-checkout');
-    if (fs.existsSync(target)) {
-        return { installed: false, reason: 'already-exists', path: target };
-    }
+    const overwritten = fs.existsSync(target);
     fs.writeFileSync(target, huskyHookBody(), { mode: 0o755 });
-    return { installed: true, path: target };
+    return { installed: true, path: target, overwritten };
 }

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/dist/lib/simple-prompt.js

@@ -0,0 +1,72 @@
+import * as fs from 'fs';
+function readLineSync(fd) {
+    const buf = Buffer.alloc(1);
+    let line = '';
+    while (true) {
+        const n = fs.readSync(fd, buf, 0, 1, null);
+        if (n === 0)
+            return line;
+        const ch = buf.toString('utf8');
+        if (ch === '\n')
+            return line;
+        if (ch === '\r')
+            continue;
+        line += ch;
+    }
+}
+export async function simplePrompt(qs) {
+    let inFd;
+    let outFd;
+    try {
+        inFd = fs.openSync('/dev/tty', 'r');
+        outFd = fs.openSync('/dev/tty', 'w');
+    }
+    catch {
+        throw new Error('simplePrompt: cannot open /dev/tty');
+    }
+    const write = (s) => fs.writeSync(outFd, s);
+    const out = {};
+    try {
+        for (const raw of qs) {
+            const q = raw;
+            const label = q.message.replace(/:\s*$/, '');
+            if (q.type === 'confirm') {
+                const def = q.default !== false;
+                write(`${label} ${def ? '[Y/n]' : '[y/N]'}: `);
+                const answer = readLineSync(inFd).trim().toLowerCase();
+                out[q.name] = answer === '' ? def : answer === 'y' || answer === 'yes';
+            }
+            else if (q.type === 'input') {
+                const def = typeof q.default === 'string' ? q.default : '';
+                write(def ? `${label} [${def}]: ` : `${label}: `);
+                const answer = readLineSync(inFd).trim();
+                out[q.name] = answer || def;
+            }
+            else if (q.type === 'list') {
+                write(`${label}\n`);
+                const choices = q.choices ?? [];
+                choices.forEach((c, i) => write(`  ${i + 1}) ${c.name}\n`));
+                while (true) {
+                    write(`Pick 1-${choices.length}: `);
+                    const answer = readLineSync(inFd).trim();
+                    const n = Number.parseInt(answer, 10);
+                    if (Number.isFinite(n) && n >= 1 && n <= choices.length) {
+                        out[q.name] = choices[n - 1].value;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        try {
+            fs.closeSync(inFd);
+        }
+        catch { }
+        try {
+            fs.closeSync(outFd);
+        }
+        catch { }
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clocktopus",
-  "version": "1.9.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",