clocktopus 1.7.0 → 1.8.0

package/dist/dashboard/routes/calendar.js

@@ -3,11 +3,15 @@ import { google } from 'googleapis';
 import { getAuthenticatedClient, getRefreshedToken } from '../../lib/google.js';
 import { getLatestToken, storeToken, getEventProject, setEventProject, getActiveProjects } from '../../lib/db.js';
 import { Clockify } from '../../clockify.js';
+import { isClockifyEnabled } from '../../lib/credentials.js';
 // Hardcoded — registered with Google OAuth; cannot vary with CLOCKTOPUS_PORT
 // without re-registering the redirect URI in the Google Cloud console.
 const DASHBOARD_REDIRECT_URI = 'http://localhost:4001/api/google/callback';
 const calendarRoutes = new Hono();
 calendarRoutes.get('/calendar/events', async (c) => {
+    if (!isClockifyEnabled()) {
+        return c.json({ ok: false, error: 'Calendar sync requires Clockify.' }, 400);
+    }
     const start = c.req.query('start');
     const end = c.req.query('end');
     if (!start || !end) {
@@ -88,6 +92,9 @@ calendarRoutes.get('/calendar/events', async (c) => {
     }
 });
 calendarRoutes.post('/calendar/log', async (c) => {
+    if (!isClockifyEnabled()) {
+        return c.json({ ok: false, error: 'Calendar sync requires Clockify.' }, 400);
+    }
     const { entries } = await c.req.json();
     if (!entries || !Array.isArray(entries) || entries.length === 0) {
         return c.json({ ok: false, error: 'Entries array is required.' }, 400);

package/dist/dashboard/routes/clockify.js

@@ -1,7 +1,12 @@
 import { Hono } from 'hono';
 import axios from 'axios';
-import { saveCredential } from '../../lib/credentials.js';
+import { saveCredential, setClockifyDisabled } from '../../lib/credentials.js';
 const clockifyRoutes = new Hono();
+clockifyRoutes.post('/clockify/enabled', async (c) => {
+    const { enabled } = await c.req.json();
+    setClockifyDisabled(!enabled);
+    return c.json({ ok: true });
+});
 clockifyRoutes.post('/clockify', async (c) => {
     const { apiKey } = await c.req.json();
     if (!apiKey) {

package/dist/dashboard/routes/data.js

@@ -1,6 +1,8 @@
 import { Hono } from 'hono';
 import { getRecentSessions, getSessionCount, getActiveProjects, getAllProjects, upsertProjects, toggleProjectActive, } from '../../lib/db.js';
 import { Clockify } from '../../clockify.js';
+import { isClockifyEnabled, isJiraDisabled } from '../../lib/credentials.js';
+import { getJiraTicket } from '../../lib/jira.js';
 const dataRoutes = new Hono();
 // Active projects for timer dropdown
 dataRoutes.get('/projects', (c) => {
@@ -14,6 +16,9 @@ dataRoutes.get('/projects/all', (c) => {
 });
 // Fetch projects from Clockify and save to DB
 dataRoutes.post('/projects/fetch', async (c) => {
+    if (!isClockifyEnabled()) {
+        return c.json({ ok: false, error: 'Clockify not configured.' }, 400);
+    }
     try {
         const clockify = new Clockify();
         const user = await clockify.getUser();
@@ -48,7 +53,7 @@ dataRoutes.get('/sessions', (c) => {
     const projectMap = new Map(allProjects.map((p) => [p.id, p.name]));
     const enriched = sessions.map((s) => ({
         ...s,
-        projectName: projectMap.get(s.projectId) ?? 'Unknown',
+        projectName: s.projectId ? (projectMap.get(s.projectId) ?? 'Unknown') : null,
     }));
     return c.json({
         data: enriched,
@@ -58,4 +63,23 @@ dataRoutes.get('/sessions', (c) => {
         totalPages: Math.ceil(total / limit),
     });
 });
+// Current Jira ticket summary for timer description preview
+dataRoutes.get('/jira/ticket-summary', async (c) => {
+    const ticket = (c.req.query('jira') || '').trim().toUpperCase();
+    if (!ticket || !/^[A-Z][A-Z0-9]+-\d+$/.test(ticket)) {
+        return c.json({ ok: false, error: 'Invalid ticket.' }, 400);
+    }
+    if (isJiraDisabled())
+        return c.json({ ok: true, description: null });
+    try {
+        const issue = (await getJiraTicket(ticket));
+        const summary = issue?.fields?.summary?.trim();
+        if (summary)
+            return c.json({ ok: true, description: summary });
+    }
+    catch (err) {
+        console.warn('Jira summary lookup failed for', ticket, err);
+    }
+    return c.json({ ok: true, description: null });
+});
 export default dataRoutes;

package/dist/dashboard/routes/jira.js

@@ -1,9 +1,14 @@
 import { Hono } from 'hono';
 import axios from 'axios';
-import { saveCredential } from '../../lib/credentials.js';
+import { saveCredential, setJiraDisabled } from '../../lib/credentials.js';
 import { storeAtlassianToken } from '../../lib/db.js';
 import { getAtlassianAuthUrl, exchangeCodeForTokens, getAccessibleResources } from '../../lib/atlassian.js';
 const jiraRoutes = new Hono();
+jiraRoutes.post('/jira/enabled', async (c) => {
+    const { enabled } = await c.req.json();
+    setJiraDisabled(!enabled);
+    return c.json({ ok: true });
+});
 // OAuth: redirect to Atlassian authorization (browser fallback)
 jiraRoutes.get('/jira/connect', async (c) => {
     try {

package/dist/dashboard/routes/status.js

@@ -1,28 +1,33 @@
 import { Hono } from 'hono';
 import axios from 'axios';
-import { resolveCredential } from '../../lib/credentials.js';
+import { isClockifyDisabled, isJiraDisabled, resolveCredential } from '../../lib/credentials.js';
 import { getLatestToken, getAtlassianToken } from '../../lib/db.js';
 import { getValidAccessToken } from '../../lib/atlassian.js';
 const statusRoutes = new Hono();
 statusRoutes.get('/status', async (c) => {
     const results = {
         clockify: false,
+        clockifyDisabled: isClockifyDisabled(),
         google: false,
         jira: false,
+        jiraDisabled: isJiraDisabled(),
+        jiraConfigured: false,
         jiraOAuth: false,
     };
     // Check Clockify
     const clockifyKey = resolveCredential('CLOCKIFY_API_KEY');
     if (clockifyKey) {
         results.clockifyKeyHint = '***' + clockifyKey.slice(-4);
-        try {
-            const res = await axios.get('https://api.clockify.me/api/v1/user', {
-                headers: { 'X-Api-Key': clockifyKey },
-                timeout: 5000,
-            });
-            results.clockify = res.status === 200;
+        if (!results.clockifyDisabled) {
+            try {
+                const res = await axios.get('https://api.clockify.me/api/v1/user', {
+                    headers: { 'X-Api-Key': clockifyKey },
+                    timeout: 5000,
+                });
+                results.clockify = res.status === 200;
+            }
+            catch { }
         }
-        catch { }
     }
     // Check Google — token exists in DB
     const token = getLatestToken();
@@ -36,29 +41,32 @@ statusRoutes.get('/status', async (c) => {
     const storedAtlassianToken = getAtlassianToken();
     if (storedAtlassianToken) {
         results.jiraOAuth = true;
+        results.jiraConfigured = true;
         if (storedAtlassianToken.site_url)
             results.jiraSiteUrl = storedAtlassianToken.site_url;
-        try {
-            const validToken = await getValidAccessToken();
-            if (validToken) {
-                const res = await axios.get(`https://api.atlassian.com/ex/jira/${validToken.cloud_id}/rest/api/3/myself`, {
-                    headers: {
-                        Authorization: `Bearer ${validToken.access_token}`,
-                        Accept: 'application/json',
-                    },
-                    timeout: 5000,
-                });
-                results.jira = res.status === 200;
-            }
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                console.error('Jira OAuth status check failed:', error.response?.status, error.response?.data);
+        if (!results.jiraDisabled) {
+            try {
+                const validToken = await getValidAccessToken();
+                if (validToken) {
+                    const res = await axios.get(`https://api.atlassian.com/ex/jira/${validToken.cloud_id}/rest/api/3/myself`, {
+                        headers: {
+                            Authorization: `Bearer ${validToken.access_token}`,
+                            Accept: 'application/json',
+                        },
+                        timeout: 5000,
+                    });
+                    results.jira = res.status === 200;
+                }
             }
-            else {
-                console.error('Jira OAuth status check failed:', error);
+            catch (error) {
+                if (axios.isAxiosError(error)) {
+                    console.error('Jira OAuth status check failed:', error.response?.status, error.response?.data);
+                }
+                else {
+                    console.error('Jira OAuth status check failed:', error);
+                }
+                results.jira = false;
             }
-            results.jira = false;
         }
     }
     else {
@@ -66,17 +74,20 @@ statusRoutes.get('/status', async (c) => {
         const jiraToken = resolveCredential('ATLASSIAN_API_TOKEN');
         const jiraEmail = resolveCredential('ATLASSIAN_EMAIL');
         if (jiraUrl && jiraToken && jiraEmail) {
-            try {
-                const res = await axios.get(`${jiraUrl}/myself`, {
-                    headers: {
-                        Authorization: `Basic ${Buffer.from(`${jiraEmail}:${jiraToken}`).toString('base64')}`,
-                        Accept: 'application/json',
-                    },
-                    timeout: 5000,
-                });
-                results.jira = res.status === 200;
+            results.jiraConfigured = true;
+            if (!results.jiraDisabled) {
+                try {
+                    const res = await axios.get(`${jiraUrl}/myself`, {
+                        headers: {
+                            Authorization: `Basic ${Buffer.from(`${jiraEmail}:${jiraToken}`).toString('base64')}`,
+                            Accept: 'application/json',
+                        },
+                        timeout: 5000,
+                    });
+                    results.jira = res.status === 200;
+                }
+                catch { }
             }
-            catch { }
         }
     }
     return c.json(results);

package/dist/dashboard/routes/timer.js

@@ -2,26 +2,54 @@ import { Hono } from 'hono';
 import { v4 as uuidv4 } from 'uuid';
 import { Clockify } from '../../clockify.js';
 import { completeLatestSession, deleteSessionById, getOpenSession, getSessionById, logCompletedSession, logSessionStart, setSessionJiraWorklogId, } from '../../lib/db.js';
-import { deleteJiraWorklog, stopJiraTimer } from '../../lib/jira.js';
+import { deleteJiraWorklog, getJiraTicket, stopJiraTimer } from '../../lib/jira.js';
+import { isClockifyEnabled, isJiraDisabled } from '../../lib/credentials.js';
 function extractJiraTicket(description) {
     const match = description.match(/\b([A-Z][A-Z0-9]+-\d+)\b/);
     return match?.[1];
 }
+async function buildJiraDescription(ticket, typed) {
+    if (typed && typed !== ticket)
+        return typed;
+    if (isJiraDisabled())
+        return ticket;
+    try {
+        const issue = (await getJiraTicket(ticket));
+        const summary = issue?.fields?.summary?.trim();
+        if (summary)
+            return ticket + ' ' + summary;
+    }
+    catch (err) {
+        console.warn('Jira summary lookup failed for', ticket, err);
+    }
+    return ticket;
+}
 const timerRoutes = new Hono();
 timerRoutes.get('/timer/active', async (c) => {
     try {
+        if (!isClockifyEnabled()) {
+            const openSession = getOpenSession();
+            if (!openSession)
+                return c.json({ active: false });
+            return c.json({
+                active: true,
+                description: openSession.description,
+                projectId: openSession.projectId,
+                start: openSession.startedAt,
+                ...(openSession.jiraTicket ? { jiraTicket: openSession.jiraTicket } : {}),
+            });
+        }
         const clockify = new Clockify();
         const user = await clockify.getUser();
         if (!user)
             return c.json({ active: false });
         const timer = await clockify.getActiveTimer(user.defaultWorkspace, user.id);
         if (!timer) {
-            // Timer stopped externally (e.g. in Clockify app) — close any lingering open session
             const openSession = getOpenSession();
             if (openSession) {
                 const completedAt = new Date().toISOString();
                 completeLatestSession(completedAt, false);
-                if (openSession.jiraTicket) {
+                if (openSession.jiraTicket && !isJiraDisabled()) {
                     const timeSpentSeconds = Math.round((new Date(completedAt).getTime() - new Date(openSession.startedAt).getTime()) / 1000);
                     if (timeSpentSeconds >= 60) {
                         try {
@@ -37,7 +65,6 @@ timerRoutes.get('/timer/active', async (c) => {
             }
             return c.json({ active: false });
         }
-        // Sync externally-started timers (e.g. from Clockify app or Jira plugin) to DB
         const timerStart = timer.timeInterval.start;
         const jiraTicket = extractJiraTicket(timer.description ?? '');
         const openSession = getOpenSession();
@@ -59,36 +86,78 @@ timerRoutes.get('/timer/active', async (c) => {
 });
 timerRoutes.post('/timer/start', async (c) => {
     const { projectId, description, jiraTicket, billable } = await c.req.json();
-    if (!projectId || !description) {
-        return c.json({ ok: false, error: 'Project and description are required.' }, 400);
+    const cleanDescription = (description ?? '').trim();
+    const cleanJira = jiraTicket?.trim() || undefined;
+    const clockifyOn = isClockifyEnabled();
+    if (clockifyOn) {
+        if (!projectId || !cleanDescription) {
+            return c.json({ ok: false, error: 'Project and description are required.' }, 400);
+        }
+        let clockifyStarted = false;
+        try {
+            const clockify = new Clockify();
+            const user = await clockify.getUser();
+            if (user) {
+                const result = await clockify.startTimer(user.defaultWorkspace, projectId, cleanDescription, cleanJira, billable ?? true);
+                if (result)
+                    clockifyStarted = true;
+                else
+                    console.warn('Clockify startTimer returned null; falling through to Jira-only path.');
+            }
+            else {
+                console.warn('Clockify enabled but getUser failed; falling through to Jira-only path.');
+            }
+        }
+        catch (err) {
+            console.warn('Clockify start threw; falling through to Jira-only path:', err);
+        }
+        if (clockifyStarted)
+            return c.json({ ok: true });
     }
+    // Jira-only or local-only path (also used as fallback when Clockify is unreachable)
+    if (!cleanJira && !cleanDescription) {
+        return c.json({ ok: false, error: 'Description or Jira ticket is required.' }, 400);
+    }
+    const finalDescription = cleanJira ? await buildJiraDescription(cleanJira, cleanDescription) : cleanDescription;
+    const sessionId = uuidv4();
+    const startedAt = new Date().toISOString();
     try {
-        const clockify = new Clockify();
-        const user = await clockify.getUser();
-        if (!user)
-            return c.json({ ok: false, error: 'Could not connect to Clockify.' }, 500);
-        const result = await clockify.startTimer(user.defaultWorkspace, projectId, description, jiraTicket, billable ?? true);
-        if (!result)
-            return c.json({ ok: false, error: 'Failed to start timer.' }, 500);
+        logSessionStart(sessionId, projectId ?? null, finalDescription, startedAt, cleanJira);
         return c.json({ ok: true });
     }
-    catch {
+    catch (err) {
+        console.error('Error starting session:', err);
         return c.json({ ok: false, error: 'Failed to start timer.' }, 500);
     }
 });
 timerRoutes.post('/timer/stop', async (c) => {
     try {
-        const clockify = new Clockify();
-        const user = await clockify.getUser();
-        if (!user)
-            return c.json({ ok: false, error: 'Could not connect to Clockify.' }, 500);
         const openSession = getOpenSession();
-        const result = await clockify.stopTimer(user.defaultWorkspace, user.id);
-        if (!result)
-            return c.json({ ok: false, error: 'Failed to stop timer.' }, 500);
+        if (isClockifyEnabled()) {
+            try {
+                const clockify = new Clockify();
+                const user = await clockify.getUser();
+                if (user) {
+                    const result = await clockify.stopTimer(user.defaultWorkspace, user.id);
+                    if (!result)
+                        console.warn('Clockify stopTimer returned null; proceeding with DB + worklog.');
+                }
+                else {
+                    console.warn('Clockify enabled but getUser failed; proceeding with DB + worklog.');
+                }
+            }
+            catch (err) {
+                console.warn('Clockify stop threw; proceeding with DB + worklog:', err);
+            }
+            if (!openSession)
+                return c.json({ ok: false, error: 'No active timer.' }, 404);
+        }
+        else if (!openSession) {
+            return c.json({ ok: false, error: 'No active timer.' }, 404);
+        }
         const completedAt = new Date().toISOString();
         completeLatestSession(completedAt, false);
-        if (openSession?.jiraTicket) {
+        if (openSession?.jiraTicket && !isJiraDisabled()) {
             const timeSpentSeconds = Math.round((new Date(completedAt).getTime() - new Date(openSession.startedAt).getTime()) / 1000);
             if (timeSpentSeconds >= 60) {
                 try {
@@ -109,9 +178,6 @@ timerRoutes.post('/timer/stop', async (c) => {
 });
 timerRoutes.post('/timer/log', async (c) => {
     const { projectId, description, start, end, jiraTicket, billable } = await c.req.json();
-    if (!projectId) {
-        return c.json({ ok: false, error: 'Project is required.' }, 400);
-    }
     if (!start || !end) {
         return c.json({ ok: false, error: 'Start and end are required.' }, 400);
     }
@@ -125,23 +191,51 @@ timerRoutes.post('/timer/log', async (c) => {
     }
     const cleanDescription = (description ?? '').trim();
     const cleanJira = jiraTicket?.trim() || undefined;
+    const clockifyOn = isClockifyEnabled();
+    if (clockifyOn && !projectId) {
+        return c.json({ ok: false, error: 'Project is required.' }, 400);
+    }
     if (!cleanDescription && !cleanJira) {
         return c.json({ ok: false, error: 'Description or Jira ticket is required.' }, 400);
     }
+    const startIso = new Date(startMs).toISOString();
+    const endIso = new Date(endMs).toISOString();
+    const clockifyDescription = cleanDescription || cleanJira || '';
+    let entryId;
+    let clockifySucceeded = false;
     try {
-        const clockify = new Clockify();
-        const user = await clockify.getUser();
-        if (!user)
-            return c.json({ ok: false, error: 'Could not connect to Clockify.' }, 500);
-        const startIso = new Date(startMs).toISOString();
-        const endIso = new Date(endMs).toISOString();
-        const finalDescription = cleanDescription || cleanJira;
-        const entry = await clockify.logTime(user.defaultWorkspace, projectId, startIso, endIso, finalDescription, billable ?? true);
-        if (!entry)
-            return c.json({ ok: false, error: 'Failed to log time in Clockify.' }, 500);
-        const entryId = entry.id ?? uuidv4();
-        logCompletedSession(entryId, projectId, finalDescription, startIso, endIso, cleanJira);
-        if (cleanJira) {
+        if (clockifyOn) {
+            try {
+                const clockify = new Clockify();
+                const user = await clockify.getUser();
+                if (user) {
+                    const entry = await clockify.logTime(user.defaultWorkspace, projectId, startIso, endIso, clockifyDescription, billable ?? true);
+                    if (entry) {
+                        entryId = entry.id ?? uuidv4();
+                        clockifySucceeded = true;
+                    }
+                    else {
+                        console.warn('Clockify logTime returned null; falling through to Jira-only path.');
+                    }
+                }
+                else {
+                    console.warn('Clockify enabled but getUser failed; falling through to Jira-only path.');
+                }
+            }
+            catch (err) {
+                console.warn('Clockify log threw; falling through to Jira-only path:', err);
+            }
+        }
+        if (!entryId) {
+            entryId = uuidv4();
+        }
+        const finalDescription = clockifySucceeded
+            ? clockifyDescription
+            : cleanJira
+                ? await buildJiraDescription(cleanJira, cleanDescription)
+                : cleanDescription;
+        logCompletedSession(entryId, projectId ?? null, finalDescription, startIso, endIso, cleanJira);
+        if (cleanJira && !isJiraDisabled()) {
             const timeSpentSeconds = Math.round((endMs - startMs) / 1000);
             if (timeSpentSeconds >= 60) {
                 try {
@@ -169,15 +263,19 @@ timerRoutes.delete('/timer/:id', async (c) => {
     if (!session)
         return c.json({ ok: false, error: 'Session not found.' }, 404);
     try {
-        const clockify = new Clockify();
-        const user = await clockify.getUser();
-        if (!user)
-            return c.json({ ok: false, error: 'Could not connect to Clockify.' }, 500);
-        const clockifyOk = await clockify.deleteTimeEntry(user.defaultWorkspace, id);
-        // Continue even if Clockify delete fails — the entry may already be gone remotely.
-        if (!clockifyOk)
-            console.warn(`Clockify delete returned failure for ${id}; removing local record anyway.`);
-        if (session.jiraTicket && session.jiraWorklogId) {
+        if (isClockifyEnabled()) {
+            const clockify = new Clockify();
+            const user = await clockify.getUser();
+            if (user) {
+                const clockifyOk = await clockify.deleteTimeEntry(user.defaultWorkspace, id);
+                if (!clockifyOk)
+                    console.warn(`Clockify delete returned failure for ${id}; removing local record anyway.`);
+            }
+            else {
+                console.warn('Clockify enabled but getUser failed; skipping remote delete.');
+            }
+        }
+        if (session.jiraTicket && session.jiraWorklogId && !isJiraDisabled()) {
             try {
                 await deleteJiraWorklog(session.jiraTicket, session.jiraWorklogId);
             }