clocktopus 1.6.17 → 1.8.0

package/dist/index.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { execSync } from 'child_process';
 import { 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';
@@ -59,6 +60,20 @@ program
     .option('-j, --jira <ticket>', 'Jira ticket number')
     .option('--no-billable', 'Mark the time entry as non-billable')
     .action(async (message, options) => {
+    if (!isClockifyEnabled()) {
+        if (!options.jira) {
+            console.error(chalk.red('Jira-only mode requires --jira <ticket>.'));
+            process.exit(1);
+        }
+        const { v4: uuidv4 } = await import('uuid');
+        const { logSessionStart } = await import('./lib/db.js');
+        const sessionId = uuidv4();
+        const startedAt = new Date().toISOString();
+        const description = (message && String(message).trim()) || options.jira;
+        logSessionStart(sessionId, null, description, startedAt, options.jira);
+        console.log(chalk.green(`Timer started for ${chalk.bold(options.jira)} (Jira-only mode).`));
+        return;
+    }
     const { workspaceId } = await getWorkspaceAndUser();
     let projects = await clockify.getProjects(workspaceId);
     let localProjects = await getLocalProjects();
@@ -96,49 +111,74 @@ program
     .command('stop')
     .description('Stop the currently running time entry.')
     .action(async () => {
-    const { workspaceId, userId } = await getWorkspaceAndUser();
     const latestSession = getLatestSession();
-    const stoppedEntry = await clockify.stopTimer(workspaceId, userId);
-    if (stoppedEntry) {
-        const completedAt = new Date().toISOString();
-        completeLatestSession(completedAt);
-        if (latestSession.jiraTicket) {
-            const timeSpentSeconds = Math.round((new Date(completedAt).getTime() - new Date(latestSession.startedAt).getTime()) / 1000);
-            if (timeSpentSeconds >= 60) {
-                try {
-                    const worklog = await stopJiraTimer(latestSession.jiraTicket, timeSpentSeconds);
-                    if (worklog?.id)
-                        setSessionJiraWorklogId(latestSession.id, worklog.id);
-                }
-                catch (error) {
-                    console.error('Error stopping Jira timer:', error);
-                }
-            }
+    if (isClockifyEnabled()) {
+        const { workspaceId, userId } = await getWorkspaceAndUser();
+        const stoppedEntry = await clockify.stopTimer(workspaceId, userId);
+        if (!stoppedEntry) {
+            console.log(chalk.yellow('No timer was running.'));
+            return;
         }
-        console.log(chalk.red('Timer stopped.'));
     }
     else {
-        console.log(chalk.yellow('No timer was running.'));
+        if (!latestSession || latestSession.completedAt) {
+            console.log(chalk.yellow('No timer was running.'));
+            return;
+        }
     }
+    const completedAt = new Date().toISOString();
+    completeLatestSession(completedAt);
+    if (latestSession?.jiraTicket) {
+        const timeSpentSeconds = Math.round((new Date(completedAt).getTime() - new Date(latestSession.startedAt).getTime()) / 1000);
+        if (timeSpentSeconds >= 60) {
+            try {
+                const worklog = await stopJiraTimer(latestSession.jiraTicket, timeSpentSeconds);
+                if (worklog?.id)
+                    setSessionJiraWorklogId(latestSession.id, worklog.id);
+            }
+            catch (error) {
+                console.error('Error stopping Jira timer:', error);
+            }
+        }
+    }
+    console.log(chalk.red('Timer stopped.'));
 });
 program
     .command('status')
     .description('Check the status of the current timer.')
     .action(async () => {
-    const { workspaceId, userId } = await getWorkspaceAndUser();
-    const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
-    if (activeEntry) {
-        const startTime = new Date(activeEntry.timeInterval.start);
-        const duration = (new Date().getTime() - startTime.getTime()) / 1000; // in seconds
-        const hours = Math.floor(duration / 3600);
-        const minutes = Math.floor((duration % 3600) / 60);
-        console.log(chalk.green('🕒 A timer is currently running.'));
-        console.log(`   - ${chalk.bold('Project:')} ${activeEntry.project.name}`);
-        console.log(`   - ${chalk.bold('Running for:')} ${hours}h ${minutes}m`);
+    if (isClockifyEnabled()) {
+        const { workspaceId, userId } = await getWorkspaceAndUser();
+        const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+        if (activeEntry) {
+            const startTime = new Date(activeEntry.timeInterval.start);
+            const duration = (new Date().getTime() - startTime.getTime()) / 1000;
+            const hours = Math.floor(duration / 3600);
+            const minutes = Math.floor((duration % 3600) / 60);
+            console.log(chalk.green('🕒 A timer is currently running.'));
+            console.log(`   - ${chalk.bold('Project:')} ${activeEntry.project.name}`);
+            console.log(`   - ${chalk.bold('Running for:')} ${hours}h ${minutes}m`);
+            return;
+        }
+        console.log(chalk.yellow('No timer is currently running.'));
+        return;
     }
-    else {
+    // Jira-only mode: read from DB
+    const { getOpenSession } = await import('./lib/db.js');
+    const open = getOpenSession();
+    if (!open) {
         console.log(chalk.yellow('No timer is currently running.'));
+        return;
     }
+    const startTime = new Date(open.startedAt);
+    const duration = (new Date().getTime() - startTime.getTime()) / 1000;
+    const hours = Math.floor(duration / 3600);
+    const minutes = Math.floor((duration % 3600) / 60);
+    console.log(chalk.green('🕒 A timer is currently running (Jira-only mode).'));
+    if (open.jiraTicket)
+        console.log(`   - ${chalk.bold('Jira:')} ${open.jiraTicket}`);
+    console.log(`   - ${chalk.bold('Description:')} ${open.description}`);
+    console.log(`   - ${chalk.bold('Running for:')} ${hours}h ${minutes}m`);
 });
 function sleep(ms) {
     return new Promise((res) => setTimeout(res, ms));
@@ -147,17 +187,27 @@ program
     .command('monitor:run', { hidden: true })
     .description('Run monitor in foreground (used by PM2).')
     .action(async () => {
-    const { workspaceId, userId } = await getWorkspaceAndUser();
+    const creds = isClockifyEnabled() ? await getWorkspaceAndUser() : { workspaceId: '', userId: '' };
+    const { workspaceId, userId } = creds;
     async function stopTimerAndLog(reason) {
-        const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
-        if (!activeEntry)
-            return false;
+        const clockifyOn = isClockifyEnabled();
+        const latestSession = getLatestSession();
+        if (clockifyOn) {
+            const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+            if (!activeEntry)
+                return false;
+        }
+        else {
+            if (!latestSession || latestSession.completedAt)
+                return false;
+        }
         console.log(chalk.yellow(reason));
         const completedAt = new Date().toISOString();
-        const latestSession = getLatestSession();
-        const stoppedEntry = await clockify.stopTimer(workspaceId, userId);
-        if (!stoppedEntry)
-            return false;
+        if (clockifyOn) {
+            const stoppedEntry = await clockify.stopTimer(workspaceId, userId);
+            if (!stoppedEntry)
+                return false;
+        }
         completeLatestSession(completedAt, true);
         if (latestSession?.jiraTicket) {
             const timeSpentSeconds = Math.round((new Date(completedAt).getTime() - new Date(latestSession.startedAt).getTime()) / 1000);
@@ -187,16 +237,30 @@ program
         const latestSession = getLatestSession();
         if (!latestSession)
             return;
-        const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
-        if (activeEntry)
-            return;
         const twoHoursAgo = Date.now() - 2 * 60 * 60 * 1000;
-        const completedAt = latestSession.completedAt ? new Date(latestSession.completedAt).getTime() : 0;
-        const eligible = latestSession.isAutoCompleted && completedAt > twoHoursAgo && !!latestSession.projectId;
-        if (!eligible)
+        const completedMs = latestSession.completedAt ? new Date(latestSession.completedAt).getTime() : 0;
+        if (!latestSession.isAutoCompleted || completedMs <= twoHoursAgo)
+            return;
+        if (isClockifyEnabled()) {
+            if (!latestSession.projectId)
+                return;
+            const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+            if (activeEntry)
+                return;
+            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;
+        }
+        // Jira-only resume: new DB session with a fresh uuid, same ticket
+        if (!latestSession.jiraTicket)
             return;
-        await clockify.startTimer(workspaceId, latestSession.projectId, latestSession.description, latestSession.jiraTicket ?? undefined);
-        console.log(chalk.green('Timer restarted for the last used project.'));
+        const { v4: uuidv4 } = await import('uuid');
+        const { logSessionStart } = await import('./lib/db.js');
+        const sessionId = uuidv4();
+        const startedAt = new Date().toISOString();
+        logSessionStart(sessionId, latestSession.projectId ?? null, latestSession.description, startedAt, latestSession.jiraTicket);
+        console.log(chalk.green(`Resumed Jira timer for ${latestSession.jiraTicket}.`));
         lastResumeAt = Date.now();
     }
     console.log(chalk.blue('Monitoring display events (Unified Log) and idle time...'));

package/dist/lib/credentials.js

@@ -8,3 +8,21 @@ export function resolveCredential(key) {
 export function saveCredential(key, value) {
     setCredential(key, value);
 }
+export function isClockifyKeyValid(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+export function isClockifyDisabled() {
+    return resolveCredential('CLOCKIFY_DISABLED') === '1';
+}
+export function setClockifyDisabled(disabled) {
+    setCredential('CLOCKIFY_DISABLED', disabled ? '1' : '0');
+}
+export function isClockifyEnabled() {
+    return isClockifyKeyValid(resolveCredential('CLOCKIFY_API_KEY')) && !isClockifyDisabled();
+}
+export function isJiraDisabled() {
+    return resolveCredential('JIRA_DISABLED') === '1';
+}
+export function setJiraDisabled(disabled) {
+    setCredential('JIRA_DISABLED', disabled ? '1' : '0');
+}

package/dist/lib/credentials.test.js

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'bun:test';
+import { isClockifyKeyValid } from './credentials.js';
+describe('isClockifyKeyValid', () => {
+    it('returns false when value is undefined', () => {
+        expect(isClockifyKeyValid(undefined)).toBe(false);
+    });
+    it('returns false when value is an empty string', () => {
+        expect(isClockifyKeyValid('')).toBe(false);
+    });
+    it('returns true when value is a non-empty string', () => {
+        expect(isClockifyKeyValid('abc123')).toBe(true);
+    });
+});

package/dist/lib/db.js

@@ -17,7 +17,7 @@ if (!fs.existsSync(DB_DIR)) {
 }
 const SessionSchema = z.object({
     id: z.string(),
-    projectId: z.string(),
+    projectId: z.string().nullable(),
     description: z.string(),
     startedAt: z.string(),
     completedAt: z.string().nullable(),
@@ -33,7 +33,7 @@ function getDb() {
         dbInstance.exec(`
       CREATE TABLE IF NOT EXISTS sessions (
         id TEXT PRIMARY KEY,
-        projectId TEXT NOT NULL,
+        projectId TEXT,
         description TEXT NOT NULL,
         startedAt TEXT NOT NULL,
         completedAt TEXT,
@@ -47,6 +47,34 @@ function getDb() {
         if (!sessionCols.some((c) => c.name === 'jiraWorklogId')) {
             dbInstance.exec('ALTER TABLE sessions ADD COLUMN jiraWorklogId TEXT');
         }
+        // Migration: drop NOT NULL on sessions.projectId if it was created with the old schema
+        const projectIdCol = sessionCols.find((c) => c.name === 'projectId');
+        if (projectIdCol && projectIdCol.notnull === 1) {
+            dbInstance.exec('BEGIN');
+            try {
+                dbInstance.exec(`
+          CREATE TABLE sessions_new (
+            id TEXT PRIMARY KEY,
+            projectId TEXT,
+            description TEXT NOT NULL,
+            startedAt TEXT NOT NULL,
+            completedAt TEXT,
+            isAutoCompleted INTEGER DEFAULT 0,
+            jiraTicket TEXT,
+            jiraWorklogId TEXT
+          )
+        `);
+                dbInstance.exec('INSERT INTO sessions_new (id, projectId, description, startedAt, completedAt, isAutoCompleted, jiraTicket, jiraWorklogId) ' +
+                    'SELECT id, projectId, description, startedAt, completedAt, isAutoCompleted, jiraTicket, jiraWorklogId FROM sessions');
+                dbInstance.exec('DROP TABLE sessions');
+                dbInstance.exec('ALTER TABLE sessions_new RENAME TO sessions');
+                dbInstance.exec('COMMIT');
+            }
+            catch (err) {
+                dbInstance.exec('ROLLBACK');
+                throw err;
+            }
+        }
         dbInstance.exec(`
       CREATE TABLE IF NOT EXISTS google_tokens (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -113,12 +141,12 @@ export function getLatestToken() {
 export function logSessionStart(id, projectId, description, startedAt, jiraTicket) {
     const db = getDb();
     const stmt = db.prepare('INSERT OR IGNORE INTO sessions (id, projectId, description, startedAt, isAutoCompleted, jiraTicket) VALUES (?, ?, ?, ?, ?, ?)');
-    stmt.run(id, projectId, description, startedAt, 0, jiraTicket ?? null);
+    stmt.run(id, projectId ?? null, description, startedAt, 0, jiraTicket ?? null);
 }
 export function logCompletedSession(id, projectId, description, startedAt, completedAt, jiraTicket) {
     const db = getDb();
     const stmt = db.prepare('INSERT OR IGNORE INTO sessions (id, projectId, description, startedAt, completedAt, isAutoCompleted, jiraTicket) VALUES (?, ?, ?, ?, ?, 0, ?)');
-    stmt.run(id, projectId, description, startedAt, completedAt, jiraTicket ?? null);
+    stmt.run(id, projectId ?? null, description, startedAt, completedAt, jiraTicket ?? null);
 }
 export function completeLatestSession(completedAt, isAutoCompleted = false) {
     const db = getDb();

package/dist/scripts/log-calendar-events.js

@@ -50,6 +50,11 @@ if (!startDate || !endDate) {
     process.exit(1);
 }
 async function main() {
+    const { isClockifyEnabled } = await import('../lib/credentials.js');
+    if (!isClockifyEnabled()) {
+        console.log('Calendar sync requires Clockify. Configure Clockify API key and re-run.');
+        return;
+    }
     const clockify = new Clockify();
     const user = await clockify.getUser();
     if (!user) {

package/package.json

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