clocktopus 1.1.6 → 1.2.1

package/dist/clockify.js

@@ -162,6 +162,20 @@ export class Clockify {
             return null;
         }
     }
+    async getTimeEntries(workspaceId, userId, start, end) {
+        try {
+            const response = await this.httpClient.get(`/workspaces/${workspaceId}/user/${userId}/time-entries`, {
+                params: { start, end, 'page-size': 200 },
+            });
+            return response.data;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error('Error fetching time entries:', error.message);
+            }
+            return [];
+        }
+    }
     async logTime(workspaceId, projectId, start, end, description) {
         if (!projectId) {
             return null;

package/dist/dashboard/routes/calendar.js

@@ -0,0 +1,101 @@
+import { Hono } from 'hono';
+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';
+const DASHBOARD_REDIRECT_URI = 'http://localhost:4001/api/google/callback';
+const calendarRoutes = new Hono();
+calendarRoutes.get('/calendar/events', async (c) => {
+    const start = c.req.query('start');
+    const end = c.req.query('end');
+    if (!start || !end) {
+        return c.json({ ok: false, error: 'Both start and end query parameters are required.' }, 400);
+    }
+    try {
+        let token = await getLatestToken();
+        if (!token) {
+            return c.json({ ok: false, error: 'Google account not connected. Please authenticate first.' }, 401);
+        }
+        const oAuth2Client = getAuthenticatedClient(DASHBOARD_REDIRECT_URI);
+        // Refresh if expired or if expiry_date is unknown (proxy tokens only have expires_in)
+        const isExpired = token.expiry_date ? new Date(token.expiry_date) < new Date() : true;
+        if (isExpired && token.refresh_token) {
+            token = await getRefreshedToken(token);
+            storeToken(token);
+        }
+        oAuth2Client.setCredentials(token);
+        const calendar = google.calendar({ version: 'v3', auth: oAuth2Client });
+        const timeMin = new Date(start).toISOString();
+        const endOfDay = new Date(end);
+        endOfDay.setDate(endOfDay.getDate() + 1);
+        const timeMax = endOfDay.toISOString();
+        const res = await calendar.events.list({
+            calendarId: 'primary',
+            timeMin,
+            timeMax,
+            singleEvents: true,
+            orderBy: 'startTime',
+        });
+        // Fetch existing Clockify entries for the same range to detect duplicates
+        const clockify = new Clockify();
+        const user = await clockify.getUser();
+        const existingEntries = user ? await clockify.getTimeEntries(user.defaultWorkspace, user.id, timeMin, timeMax) : [];
+        // Build a set of "description|startEpoch" for quick lookup (normalize timezones)
+        const loggedSet = new Set(existingEntries.map((e) => `${e.description}|${new Date(e.timeInterval.start).getTime()}`));
+        const events = (res.data.items || [])
+            .filter((event) => !event.start?.date) // Filter out all-day events
+            .filter((event) => event.summary && event.start?.dateTime && event.end?.dateTime)
+            .map((event) => {
+            const savedProjectId = getEventProject(event.summary);
+            const alreadyLogged = loggedSet.has(`${event.summary}|${new Date(event.start.dateTime).getTime()}`);
+            return {
+                summary: event.summary,
+                start: event.start.dateTime,
+                end: event.end.dateTime,
+                savedProjectId: savedProjectId ?? undefined,
+                skipped: savedProjectId === null,
+                alreadyLogged,
+            };
+        });
+        const projects = getActiveProjects();
+        return c.json({ ok: true, events, projects });
+    }
+    catch (error) {
+        console.error('Calendar events error:', error instanceof Error ? error.message : error);
+        return c.json({ ok: false, error: 'Failed to fetch calendar events.' }, 500);
+    }
+});
+calendarRoutes.post('/calendar/log', async (c) => {
+    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);
+    }
+    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 logged = [];
+        const failed = [];
+        for (const entry of entries) {
+            if (!entry.summary || !entry.start || !entry.end || !entry.projectId) {
+                failed.push(entry.summary ?? '(unknown)');
+                continue;
+            }
+            try {
+                await clockify.logTime(user.defaultWorkspace, entry.projectId, entry.start, entry.end, entry.summary);
+                setEventProject(entry.summary, entry.projectId);
+                logged.push(entry.summary);
+            }
+            catch {
+                failed.push(entry.summary);
+            }
+        }
+        return c.json({ ok: true, logged, failed });
+    }
+    catch {
+        return c.json({ ok: false, error: 'Failed to log calendar events.' }, 500);
+    }
+});
+export default calendarRoutes;

package/dist/dashboard/routes/timer.js

@@ -1,6 +1,12 @@
 import { Hono } from 'hono';
+import { v4 as uuidv4 } from 'uuid';
 import { Clockify } from '../../clockify.js';
-import { completeLatestSession } from '../../lib/db.js';
+import { completeLatestSession, getOpenSession, logSessionStart } from '../../lib/db.js';
+import { stopJiraTimer } from '../../lib/jira.js';
+function extractJiraTicket(description) {
+    const match = description.match(/\b([A-Z][A-Z0-9]+-\d+)\b/);
+    return match?.[1];
+}
 const timerRoutes = new Hono();
 timerRoutes.get('/timer/active', async (c) => {
     try {
@@ -11,11 +17,19 @@ timerRoutes.get('/timer/active', async (c) => {
         const timer = await clockify.getActiveTimer(user.defaultWorkspace, user.id);
         if (!timer)
             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 openSession = getOpenSession();
+        const alreadyTracked = openSession && openSession.startedAt.slice(0, 19) === timerStart.slice(0, 19);
+        if (!alreadyTracked) {
+            const jiraTicket = extractJiraTicket(timer.description ?? '');
+            logSessionStart(timer.id ?? uuidv4(), timer.projectId, timer.description ?? '', timerStart, jiraTicket);
+        }
         return c.json({
             active: true,
             description: timer.description,
             projectId: timer.projectId,
-            start: timer.timeInterval.start,
+            start: timerStart,
         });
     }
     catch {
@@ -47,10 +61,23 @@ timerRoutes.post('/timer/stop', async (c) => {
         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);
-        completeLatestSession(new Date().toISOString(), false);
+        const completedAt = new Date().toISOString();
+        completeLatestSession(completedAt, false);
+        if (openSession?.jiraTicket) {
+            const timeSpentSeconds = Math.round((new Date(completedAt).getTime() - new Date(openSession.startedAt).getTime()) / 1000);
+            if (timeSpentSeconds >= 60) {
+                try {
+                    await stopJiraTimer(openSession.jiraTicket, timeSpentSeconds);
+                }
+                catch (err) {
+                    console.error('Error stopping Jira timer:', err);
+                }
+            }
+        }
         return c.json({ ok: true });
     }
     catch {

package/dist/dashboard/server.js

@@ -8,6 +8,7 @@ import googleRoutes from './routes/google.js';
 import timerRoutes from './routes/timer.js';
 import dataRoutes from './routes/data.js';
 import monitorRoutes from './routes/monitor.js';
+import calendarRoutes from './routes/calendar.js';
 const app = new Hono();
 app.get('/', (c) => c.html(indexPage()));
 app.route('/api', statusRoutes);
@@ -17,6 +18,7 @@ app.route('/api', googleRoutes);
 app.route('/api', timerRoutes);
 app.route('/api', dataRoutes);
 app.route('/api', monitorRoutes);
+app.route('/api', calendarRoutes);
 export function startDashboard() {
     const port = 4001;
     console.log(`Clocktopus dashboard running at http://localhost:${port}`);

package/dist/dashboard/views.js

@@ -41,7 +41,7 @@ export function indexPage() {
     .dot.red { background: #f85149; }
     .dot.gray { background: #484f58; }
     label { display: block; font-size: 0.85rem; color: #8b949e; margin-bottom: 0.25rem; margin-top: 0.75rem; }
-    input, select { width: 100%; padding: 0.5rem 0.75rem; background: #0d1117; border: 1px solid #30363d; border-radius: 6px; color: #e1e4e8; font-size: 0.9rem; }
+    input, select { width: 100%; padding: 0.5rem 0.75rem; background: #0d1117; border: 1px solid #30363d; border-radius: 6px; color: #e1e4e8; font-size: 0.9rem; color-scheme: dark; }
     input:focus, select:focus { outline: none; border-color: #58a6ff; }
     select { appearance: none; -webkit-appearance: none; cursor: pointer; }
     button { margin-top: 1rem; padding: 0.5rem 1.25rem; background: #238636; border: none; border-radius: 6px; color: #fff; font-size: 0.9rem; cursor: pointer; }
@@ -69,6 +69,14 @@ export function indexPage() {
 
     /* Inline form row */
     .form-row { display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; }
+    /* Calendar event cards */
+    .cal-event-card { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 0.75rem; margin-bottom: 0.5rem; }
+    .cal-event-card .cal-card-name { color: #e1e4e8; font-size: 0.85rem; font-weight: 500; margin-bottom: 0.5rem; }
+    .cal-event-card .cal-card-time { font-size: 0.75rem; color: #8b949e; margin-bottom: 0.4rem; }
+    .cal-event-card .cal-card-badge { color: #3fb950; font-size: 0.7rem; }
+    .cal-event-card select { margin-top: 0.25rem; }
+    .cal-event-card.logged { opacity: 0.5; }
+
     @media (max-width: 600px) {
       body { padding: 0.75rem; }
       .form-row { grid-template-columns: 1fr; }
@@ -95,6 +103,7 @@ export function indexPage() {
     <div class="nav">
       <button class="nav-btn active" onclick="switchTab('home')" id="nav-home">Home</button>
       <button class="nav-btn" onclick="switchTab('projects')" id="nav-projects">Projects</button>
+      <button class="nav-btn" onclick="switchTab('calendar')" id="nav-calendar">Calendar</button>
       <button class="nav-btn" onclick="switchTab('settings')" id="nav-settings">Settings</button>
     </div>
   </div>
@@ -262,6 +271,33 @@ export function indexPage() {
     </div>
   </div>
 
+  <!-- CALENDAR TAB -->
+  <div id="tab-calendar" class="tab-content">
+    <div class="cards">
+      <div class="card card-full">
+        <h2>Log Calendar Events</h2>
+        <div class="form-row" style="margin-top:1rem;">
+          <div>
+            <label for="cal-from">From</label>
+            <input type="date" id="cal-from" />
+          </div>
+          <div>
+            <label for="cal-to">To</label>
+            <input type="date" id="cal-to" />
+          </div>
+        </div>
+        <button onclick="fetchCalendarEvents()">Fetch Events</button>
+        <div class="msg" id="cal-msg"></div>
+
+        <div id="cal-table-wrap" style="display:none; margin-top:1rem;">
+          <div id="cal-cards"></div>
+          <button id="cal-log-btn" onclick="logCalendarEvents()" style="margin-top:1rem;">Log to Clockify</button>
+          <div class="msg" id="cal-log-msg"></div>
+        </div>
+      </div>
+    </div>
+  </div>
+
   <script>
     let elapsedInterval = null;
     let currentPage = 1;
@@ -299,8 +335,11 @@ export function indexPage() {
     function formatDate(iso) {
       if (!iso) return '-';
       const d = new Date(iso);
-      return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' }) + ' ' +
-             d.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+      const y = d.getFullYear();
+      const m = String(d.getMonth() + 1).padStart(2, '0');
+      const day = String(d.getDate()).padStart(2, '0');
+      const time = d.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+      return y + '/' + m + '/' + day + ' ' + time;
     }
 
     // --- Timer ---
@@ -828,6 +867,131 @@ export function indexPage() {
       }
     })();
 
+    // --- Calendar ---
+    let calEvents = [];
+    let calProjects = [];
+
+    async function fetchCalendarEvents() {
+      const from = document.getElementById('cal-from').value;
+      const to = document.getElementById('cal-to').value;
+      if (!from || !to) return setMsg('cal-msg', 'Please select both dates.', false);
+
+      const fetchBtn = document.querySelector('#tab-calendar button[onclick="fetchCalendarEvents()"]');
+      fetchBtn.disabled = true;
+      fetchBtn.textContent = 'Fetching...';
+      setMsg('cal-msg', '', true);
+      setMsg('cal-log-msg', '', true);
+      document.getElementById('cal-table-wrap').style.display = 'none';
+
+      try {
+        const res = await fetch('/api/calendar/events?start=' + encodeURIComponent(from) + '&end=' + encodeURIComponent(to));
+        const data = await res.json();
+        if (!res.ok) {
+          setMsg('cal-msg', data.error || 'Failed to fetch events.', false);
+          return;
+        }
+        calEvents = data.events || [];
+        calProjects = data.projects || [];
+
+        if (calEvents.length === 0) {
+          setMsg('cal-msg', 'No calendar events found for this date range.', false);
+          return;
+        }
+
+        setMsg('cal-msg', 'Found ' + calEvents.length + ' event(s).', true);
+        renderCalendarTable();
+        document.getElementById('cal-table-wrap').style.display = 'block';
+      } catch {
+        setMsg('cal-msg', 'Request failed.', false);
+      }
+      fetchBtn.disabled = false;
+      fetchBtn.textContent = 'Fetch Events';
+    }
+
+    function renderCalendarTable() {
+      const cards = document.getElementById('cal-cards');
+      cards.innerHTML = calEvents.map(function(ev, i) {
+        const startTime = new Date(ev.start).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+        const endTime = new Date(ev.end).toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' });
+        const sd = new Date(ev.start);
+        const startDay = sd.getFullYear() + '/' + String(sd.getMonth() + 1).padStart(2, '0') + '/' + String(sd.getDate()).padStart(2, '0');
+        const durationMs = new Date(ev.end).getTime() - new Date(ev.start).getTime();
+
+        const logged = ev.alreadyLogged;
+        const selDisabled = logged ? ' disabled' : '';
+        const badge = logged ? ' <span class="cal-card-badge">(logged)</span>' : '';
+
+        const projectOptions = '<option value="skip">Skip</option>' +
+          calProjects.map(function(p) {
+            const selected = (ev.savedProjectId && ev.savedProjectId === p.id) ? ' selected' : '';
+            return '<option value="' + p.id + '"' + selected + '>' + escapeHtml(p.name) + '</option>';
+          }).join('');
+
+        return '<div class="cal-event-card' + (logged ? ' logged' : '') + '">' +
+          '<div class="cal-card-name">' + escapeHtml(ev.summary || 'Untitled') + badge + '</div>' +
+          '<div class="cal-card-time">' + startDay + ' ' + startTime + ' — ' + endTime + ' (' + formatDuration(durationMs) + ')</div>' +
+          '<select class="cal-project-sel" data-index="' + i + '"' + selDisabled + '>' + projectOptions + '</select>' +
+        '</div>';
+      }).join('');
+
+      document.querySelectorAll('.cal-project-sel').forEach(function(sel) {
+        sel.addEventListener('change', function() {
+          const idx = parseInt(sel.dataset.index);
+          calEvents[idx].savedProjectId = sel.value || null;
+        });
+      });
+    }
+
+    async function logCalendarEvents() {
+      const entries = [];
+      document.querySelectorAll('.cal-project-sel').forEach(function(sel) {
+        if (sel.disabled) return;
+        if (sel.value === 'skip' || !sel.value) return;
+        const idx = parseInt(sel.dataset.index);
+        const ev = calEvents[idx];
+        entries.push({ projectId: sel.value, summary: ev.summary, start: ev.start, end: ev.end });
+      });
+
+      if (entries.length === 0) {
+        return setMsg('cal-log-msg', 'No events to log. Assign projects to events you want to log.', false);
+      }
+
+      const btn = document.getElementById('cal-log-btn');
+      btn.disabled = true;
+      btn.textContent = 'Logging...';
+      setMsg('cal-log-msg', '', true);
+
+      try {
+        const res = await fetch('/api/calendar/log', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ entries: entries }),
+        });
+        const data = await res.json();
+        if (data.ok) {
+          const loggedCount = Array.isArray(data.logged) ? data.logged.length : data.logged;
+          const failedCount = Array.isArray(data.failed) ? data.failed.length : data.failed;
+          let msg = loggedCount + ' event(s) logged to Clockify.';
+          if (failedCount > 0) msg += ' ' + failedCount + ' failed.';
+          setMsg('cal-log-msg', msg, failedCount === 0);
+          fetchCalendarEvents();
+        } else {
+          setMsg('cal-log-msg', data.error || 'Failed to log events.', false);
+        }
+      } catch {
+        setMsg('cal-log-msg', 'Request failed.', false);
+      }
+      btn.disabled = false;
+      btn.textContent = 'Log to Clockify';
+    }
+
+    // Set default calendar dates to today
+    (function setCalendarDefaults() {
+      const today = new Date().toISOString().split('T')[0];
+      document.getElementById('cal-from').value = today;
+      document.getElementById('cal-to').value = today;
+    })();
+
     // --- Init ---
     fetchStatus();
     loadProjects();

package/dist/lib/db.js

@@ -105,7 +105,7 @@ export function getLatestToken() {
 }
 export function logSessionStart(id, projectId, description, startedAt, jiraTicket) {
     const db = getDb();
-    const stmt = db.prepare('INSERT INTO sessions (id, projectId, description, startedAt, isAutoCompleted, jiraTicket) VALUES (?, ?, ?, ?, ?, ?)');
+    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);
 }
 export function completeLatestSession(completedAt, isAutoCompleted = false) {
@@ -130,6 +130,14 @@ export function getSessionCount() {
     const row = stmt.get();
     return row.count;
 }
+export function getOpenSession() {
+    const db = getDb();
+    const stmt = db.prepare('SELECT * FROM sessions WHERE completedAt IS NULL ORDER BY startedAt DESC LIMIT 1');
+    const row = stmt.get();
+    if (!row)
+        return null;
+    return SessionSchema.parse(row);
+}
 export function getLatestSession() {
     const db = getDb();
     const stmt = db.prepare(`

package/dist/lib/google.js

@@ -44,7 +44,8 @@ export async function getRefreshedToken(token) {
         const client = getAuthenticatedClient();
         client.setCredentials(token);
         const refreshedToken = await client.refreshAccessToken();
-        return refreshedToken.credentials;
+        // Preserve refresh_token — Google doesn't return it on refresh
+        return { ...token, ...refreshedToken.credentials, refresh_token: token.refresh_token };
     }
     // Use proxy for refresh
     if (!token.refresh_token)
@@ -53,5 +54,6 @@ export async function getRefreshedToken(token) {
         grant_type: 'refresh_token',
         refresh_token: token.refresh_token,
     });
-    return res.data;
+    // Preserve refresh_token — proxy doesn't return it on refresh
+    return { ...token, ...res.data, refresh_token: token.refresh_token };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clocktopus",
-  "version": "1.1.6",
+  "version": "1.2.1",
   "type": "module",
   "main": "dist/index.js",
   "bin": {