clocktopus 1.0.0

package/dist/index.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+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 { completeLatestSession, getLatestSession } from './lib/db.js';
+import { stopJiraTimer } from './lib/jira.js';
+import { startDashboard } from './dashboard/server.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const program = new Command();
+const clockify = new Clockify();
+async function getLocalProjects() {
+    const dataDir = path.join(__dirname, '../data');
+    const localProjectsPath = path.join(dataDir, 'local-projects.json');
+    try {
+        // Ensure the data directory exists
+        await fs.promises.mkdir(dataDir, { recursive: true });
+        // If the file does not exist, create it with an empty array
+        try {
+            await fs.promises.access(localProjectsPath, fs.constants.F_OK);
+        }
+        catch {
+            await fs.promises.writeFile(localProjectsPath, '[]', 'utf8');
+        }
+        const data = await fs.promises.readFile(localProjectsPath, 'utf8');
+        return JSON.parse(data);
+    }
+    catch (_error) {
+        return [];
+    }
+}
+async function getWorkspaceAndUser() {
+    const user = await clockify.getUser();
+    if (!user) {
+        console.log(chalk.red('[index] Could not connect to Clockify. Please check your API key.'));
+        process.exit(1);
+    }
+    const workspaceId = user.defaultWorkspace;
+    const userId = user.id;
+    return {
+        workspaceId,
+        userId,
+    };
+}
+program.name('clocktopus').description('CLI time-tracking automation for Clockify').version('1.0.0');
+program
+    .command('start')
+    .description('Start a new time entry. Select a project interactively.')
+    .argument('[message]', 'Description for the time entry')
+    .option('-j, --jira <ticket>', 'Jira ticket number')
+    .action(async (message, options) => {
+    const { workspaceId } = await getWorkspaceAndUser();
+    let projects = await clockify.getProjects(workspaceId);
+    let localProjects = await getLocalProjects();
+    if (localProjects.length === 0) {
+        // If local-projects.json is empty or doesn't exist, populate it with all project IDs and names
+        const allProjects = projects.map((p) => ({ id: p.id, name: p.name }));
+        const localProjectsPath = path.join(__dirname, '../data/local-projects.json');
+        fs.writeFileSync(localProjectsPath, JSON.stringify(allProjects, null, 2), 'utf8');
+        console.log(chalk.green('All projects have been saved to data/local-projects.json. Please edit this file to select your preferred projects.'));
+        localProjects = allProjects;
+    }
+    if (localProjects.length > 0) {
+        const localProjectIds = localProjects.map((p) => p.id);
+        projects = projects.filter((p) => localProjectIds.includes(p.id));
+    }
+    if (!projects || projects.length === 0) {
+        console.log(chalk.yellow('No projects found in your workspace.'));
+        return;
+    }
+    const { selectedProjectId } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedProjectId',
+            message: 'Which project do you want to work on?',
+            choices: projects.map((p) => ({ name: p.name, value: p.id })),
+        },
+    ]);
+    const entry = await clockify.startTimer(workspaceId, selectedProjectId, message, options.jira);
+    if (entry) {
+        const projectName = projects.find((p) => p.id === selectedProjectId)?.name;
+        console.log(chalk.green(`Timer started for project: ${chalk.bold(projectName)}`));
+    }
+});
+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 {
+                    await stopJiraTimer(latestSession.jiraTicket, timeSpentSeconds);
+                }
+                catch (error) {
+                    console.error('Error stopping Jira timer:', error);
+                }
+            }
+        }
+        console.log(chalk.red('Timer stopped.'));
+    }
+    else {
+        console.log(chalk.yellow('No timer was running.'));
+    }
+});
+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`);
+    }
+    else {
+        console.log(chalk.yellow('No timer is currently running.'));
+    }
+});
+function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+}
+program
+    .command('monitor')
+    .description('Monitor system idle time and screen state, and stop the Clockify timer if idle or screen is off.')
+    .action(async () => {
+    const { workspaceId, userId } = await getWorkspaceAndUser();
+    async function stopTimerAndLog(reason) {
+        const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+        if (!activeEntry)
+            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;
+        completeLatestSession(completedAt, true);
+        if (latestSession?.jiraTicket) {
+            const timeSpentSeconds = Math.round((new Date(completedAt).getTime() - new Date(latestSession.startedAt).getTime()) / 1000);
+            if (timeSpentSeconds >= 60) {
+                try {
+                    await stopJiraTimer(latestSession.jiraTicket, timeSpentSeconds);
+                }
+                catch (err) {
+                    console.error('Error stopping Jira timer:', err);
+                }
+            }
+        }
+        console.log(chalk.red('Timer stopped.'));
+        return true;
+    }
+    // Safer restart w/ cooldown; only resume a recent auto-completed session
+    let lastResumeAt = 0;
+    const RESUME_COOLDOWN_MS = 10000;
+    async function safeRestartTimerIfNeeded() {
+        const now = Date.now();
+        if (now - lastResumeAt < RESUME_COOLDOWN_MS)
+            return;
+        // Small delay lets services settle after wake/activity
+        await sleep(800);
+        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)
+            return;
+        await clockify.startTimer(workspaceId, latestSession.projectId, latestSession.description);
+        console.log(chalk.green('Timer restarted for the last used project.'));
+        lastResumeAt = Date.now();
+    }
+    console.log(chalk.blue('Monitoring display events (Unified Log) and idle time...'));
+    let isLocked = false;
+    let pollInterval = null;
+    console.log(chalk.blue('Monitoring display/lock state (macos-notification-state) and idle time...'));
+    try {
+        if (process.platform === 'darwin') {
+            const nsModule = await import('macos-notification-state');
+            const getSessionState = nsModule.default?.getSessionState || nsModule.getSessionState;
+            if (!getSessionState) {
+                throw new Error('getSessionState not found in module');
+            }
+            pollInterval = setInterval(async () => {
+                try {
+                    const state = getSessionState();
+                    const locked = state === 'SESSION_SCREEN_IS_LOCKED';
+                    if (locked && !isLocked) {
+                        isLocked = true;
+                        await stopTimerAndLog('Screen is locked/off. Stopping timer...');
+                    }
+                    else if (!locked && isLocked) {
+                        console.log(chalk.green('Screen is unlocked/on. Attempting to restart timer...'));
+                        await safeRestartTimerIfNeeded();
+                        isLocked = false;
+                    }
+                }
+                catch (error) {
+                    console.error('Error polling session state:', error);
+                }
+            }, 3000);
+        }
+        else {
+            console.log(chalk.yellow('Display monitoring (lock state) is only supported on macOS. Skipping.'));
+        }
+    }
+    catch (err) {
+        console.error(chalk.red('Failed to load macos-notification-state. Display monitoring will be disabled.'));
+        console.error(err);
+    }
+    const IDLE_THRESHOLD_SECONDS = 300; // 5 minutes
+    let lastIdle = false;
+    const idleInterval = setInterval(async () => {
+        try {
+            const idleModule = await import('desktop-idle');
+            const idleTime = idleModule.default.getIdleTime();
+            if (idleTime >= IDLE_THRESHOLD_SECONDS) {
+                const stopped = await stopTimerAndLog(`System idle for ${Math.floor(idleTime)} seconds. Stopping timer...`);
+                if (stopped)
+                    lastIdle = true;
+            }
+            else {
+                // User active again → resume even if display log events were missed
+                if (lastIdle) {
+                    await safeRestartTimerIfNeeded();
+                }
+                lastIdle = false;
+            }
+        }
+        catch (e) {
+            // swallow; desktop-idle can occasionally throw on wake races
+        }
+    }, 5000);
+    function cleanupAndExit(code = 0) {
+        try {
+            clearInterval(idleInterval);
+        }
+        catch { }
+        try {
+            if (pollInterval)
+                clearInterval(pollInterval);
+        }
+        catch { }
+        process.exit(code);
+    }
+    process.on('SIGINT', () => {
+        console.log(chalk.gray('\nStopping monitor...'));
+        cleanupAndExit(0);
+    });
+    process.on('SIGTERM', () => cleanupAndExit(0));
+});
+program
+    .command('dash')
+    .description('Start the Clocktopus web dashboard on localhost:4001.')
+    .action(() => {
+    startDashboard();
+});
+program.parse(process.argv);

package/dist/lib/atlassian.js

@@ -0,0 +1,93 @@
+import axios from 'axios';
+import { resolveCredential } from './credentials.js';
+import { getAtlassianToken, updateAtlassianAccessToken } from './db.js';
+// Cloudflare Worker proxy that holds the client secret
+const AUTH_PROXY_URL = 'https://clocktopus-auth.clocktopus.workers.dev/';
+// Fallback: direct Atlassian API (when user provides their own credentials)
+const ATLASSIAN_TOKEN_URL = 'https://auth.atlassian.com/oauth/token';
+const ATLASSIAN_RESOURCES_URL = 'https://api.atlassian.com/oauth/token/accessible-resources';
+const REDIRECT_URI = 'http://localhost:4001/api/jira/callback';
+function hasLocalCredentials() {
+    return !!(resolveCredential('ATLASSIAN_CLIENT_ID') && resolveCredential('ATLASSIAN_CLIENT_SECRET'));
+}
+export async function getAtlassianAuthUrl() {
+    if (hasLocalCredentials()) {
+        const clientId = resolveCredential('ATLASSIAN_CLIENT_ID');
+        const params = new URLSearchParams({
+            audience: 'api.atlassian.com',
+            client_id: clientId,
+            scope: 'read:jira-work write:jira-work read:jira-user read:me offline_access',
+            redirect_uri: REDIRECT_URI,
+            response_type: 'code',
+            prompt: 'consent',
+        });
+        return `https://auth.atlassian.com/authorize?${params.toString()}`;
+    }
+    // Use proxy to get auth URL
+    const res = await axios.get(`${AUTH_PROXY_URL}/atlassian/auth-url`, {
+        params: { redirect_uri: REDIRECT_URI },
+    });
+    return res.data.url;
+}
+export async function exchangeCodeForTokens(code) {
+    if (hasLocalCredentials()) {
+        const res = await axios.post(ATLASSIAN_TOKEN_URL, {
+            grant_type: 'authorization_code',
+            client_id: resolveCredential('ATLASSIAN_CLIENT_ID'),
+            client_secret: resolveCredential('ATLASSIAN_CLIENT_SECRET'),
+            code,
+            redirect_uri: REDIRECT_URI,
+        });
+        return res.data;
+    }
+    // Use proxy
+    const res = await axios.post(`${AUTH_PROXY_URL}/atlassian/token`, {
+        grant_type: 'authorization_code',
+        code,
+        redirect_uri: REDIRECT_URI,
+    });
+    return res.data;
+}
+export async function refreshAccessToken(refreshToken) {
+    if (hasLocalCredentials()) {
+        const res = await axios.post(ATLASSIAN_TOKEN_URL, {
+            grant_type: 'refresh_token',
+            client_id: resolveCredential('ATLASSIAN_CLIENT_ID'),
+            client_secret: resolveCredential('ATLASSIAN_CLIENT_SECRET'),
+            refresh_token: refreshToken,
+        });
+        return res.data;
+    }
+    // Use proxy
+    const res = await axios.post(`${AUTH_PROXY_URL}/atlassian/token`, {
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+    });
+    return res.data;
+}
+export async function getAccessibleResources(accessToken) {
+    const res = await axios.get(ATLASSIAN_RESOURCES_URL, {
+        headers: { Authorization: `Bearer ${accessToken}`, Accept: 'application/json' },
+    });
+    return res.data;
+}
+export async function getValidAccessToken() {
+    const token = getAtlassianToken();
+    if (!token)
+        return null;
+    const expiresAt = new Date(token.expires_at).getTime();
+    const bufferMs = 5 * 60 * 1000;
+    if (Date.now() < expiresAt - bufferMs) {
+        return { access_token: token.access_token, cloud_id: token.cloud_id };
+    }
+    try {
+        const refreshed = await refreshAccessToken(token.refresh_token);
+        const newExpiresAt = new Date(Date.now() + refreshed.expires_in * 1000).toISOString();
+        updateAtlassianAccessToken(refreshed.access_token, newExpiresAt);
+        return { access_token: refreshed.access_token, cloud_id: token.cloud_id };
+    }
+    catch (error) {
+        console.error('Failed to refresh Atlassian token:', error instanceof Error ? error.message : error);
+        return null;
+    }
+}

package/dist/lib/credentials.js

@@ -0,0 +1,10 @@
+import { getCredential, setCredential } from './db.js';
+export function resolveCredential(key) {
+    const dbValue = getCredential(key);
+    if (dbValue)
+        return dbValue;
+    return process.env[key];
+}
+export function saveCredential(key, value) {
+    setCredential(key, value);
+}

package/dist/lib/db.js

@@ -0,0 +1,189 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Database } from 'bun:sqlite';
+import { z } from 'zod';
+const DB_DIR = path.join(process.cwd(), 'data/db');
+const DB_PATH = path.join(DB_DIR, 'sessions.db');
+if (!fs.existsSync(DB_DIR)) {
+    fs.mkdirSync(DB_DIR, { recursive: true });
+}
+const SessionSchema = z.object({
+    id: z.string(),
+    projectId: z.string(),
+    description: z.string(),
+    startedAt: z.string(),
+    completedAt: z.string().nullable(),
+    isAutoCompleted: z.number(),
+    jiraTicket: z.string().nullable(),
+});
+let dbInstance = null;
+function getDb() {
+    if (!dbInstance) {
+        dbInstance = new Database(DB_PATH);
+        dbInstance.exec('PRAGMA journal_mode = WAL');
+        dbInstance.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        projectId TEXT NOT NULL,
+        description TEXT NOT NULL,
+        startedAt TEXT NOT NULL,
+        completedAt TEXT,
+        isAutoCompleted INTEGER DEFAULT 0,
+        jiraTicket TEXT
+      )
+    `);
+        dbInstance.exec(`
+      CREATE TABLE IF NOT EXISTS google_tokens (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        token TEXT NOT NULL,
+        createdAt TEXT NOT NULL
+      )
+    `);
+        dbInstance.exec(`
+      CREATE TABLE IF NOT EXISTS event_projects (
+        eventName TEXT PRIMARY KEY,
+        projectId TEXT
+      )
+    `);
+        dbInstance.exec(`
+      CREATE TABLE IF NOT EXISTS credentials (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      )
+    `);
+        dbInstance.exec(`
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        active INTEGER DEFAULT 1
+      )
+    `);
+        dbInstance.exec(`
+      CREATE TABLE IF NOT EXISTS atlassian_tokens (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        access_token TEXT NOT NULL,
+        refresh_token TEXT NOT NULL,
+        expires_at TEXT NOT NULL,
+        cloud_id TEXT NOT NULL,
+        site_url TEXT,
+        createdAt TEXT NOT NULL
+      )
+    `);
+    }
+    return dbInstance;
+}
+export function getEventProject(eventName) {
+    const db = getDb();
+    const stmt = db.prepare('SELECT projectId FROM event_projects WHERE eventName = ?');
+    const row = stmt.get(eventName);
+    return row ? row.projectId : undefined;
+}
+export function setEventProject(eventName, projectId) {
+    const db = getDb();
+    const stmt = db.prepare('INSERT OR REPLACE INTO event_projects (eventName, projectId) VALUES (?, ?)');
+    stmt.run(eventName, projectId);
+}
+export function storeToken(token) {
+    const db = getDb();
+    const stmt = db.prepare('INSERT INTO google_tokens (token, createdAt) VALUES (?, ?)');
+    stmt.run(JSON.stringify(token), new Date().toISOString());
+}
+export function getLatestToken() {
+    const db = getDb();
+    const stmt = db.prepare('SELECT * FROM google_tokens ORDER BY createdAt DESC LIMIT 1');
+    const row = stmt.get();
+    return row ? JSON.parse(row.token) : null;
+}
+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 (?, ?, ?, ?, ?, ?)');
+    stmt.run(id, projectId, description, startedAt, 0, jiraTicket ?? null);
+}
+export function completeLatestSession(completedAt, isAutoCompleted = false) {
+    const db = getDb();
+    const stmt = db.prepare(`
+    UPDATE sessions
+    SET completedAt = ?, isAutoCompleted = ?
+    WHERE id = (
+      SELECT id FROM sessions WHERE completedAt IS NULL ORDER BY startedAt DESC LIMIT 1
+    )
+  `);
+    stmt.run(completedAt, isAutoCompleted ? 1 : 0);
+}
+export function getRecentSessions(limit = 10, offset = 0) {
+    const db = getDb();
+    const stmt = db.prepare('SELECT * FROM sessions ORDER BY startedAt DESC LIMIT ? OFFSET ?');
+    return stmt.all(limit, offset);
+}
+export function getSessionCount() {
+    const db = getDb();
+    const stmt = db.prepare('SELECT COUNT(*) as count FROM sessions');
+    const row = stmt.get();
+    return row.count;
+}
+export function getLatestSession() {
+    const db = getDb();
+    const stmt = db.prepare(`
+    SELECT * FROM sessions ORDER BY startedAt DESC LIMIT 1
+  `);
+    return SessionSchema.parse(stmt.get());
+}
+export function deleteOldSessions(days) {
+    const db = getDb();
+    const date = new Date();
+    date.setDate(date.getDate() - days);
+    const stmt = db.prepare('DELETE FROM sessions WHERE startedAt < ?');
+    stmt.run(date.toISOString());
+}
+export function getCredential(key) {
+    const db = getDb();
+    const stmt = db.prepare('SELECT value FROM credentials WHERE key = ?');
+    const row = stmt.get(key);
+    return row ? row.value : null;
+}
+export function setCredential(key, value) {
+    const db = getDb();
+    const stmt = db.prepare('INSERT OR REPLACE INTO credentials (key, value, updatedAt) VALUES (?, ?, ?)');
+    stmt.run(key, value, new Date().toISOString());
+}
+export function deleteCredential(key) {
+    const db = getDb();
+    const stmt = db.prepare('DELETE FROM credentials WHERE key = ?');
+    stmt.run(key);
+}
+export function storeAtlassianToken(token) {
+    const db = getDb();
+    const stmt = db.prepare('INSERT OR REPLACE INTO atlassian_tokens (id, access_token, refresh_token, expires_at, cloud_id, site_url, createdAt) VALUES (1, ?, ?, ?, ?, ?, ?)');
+    stmt.run(token.access_token, token.refresh_token, token.expires_at, token.cloud_id, token.site_url ?? null, new Date().toISOString());
+}
+export function getAtlassianToken() {
+    const db = getDb();
+    const stmt = db.prepare('SELECT access_token, refresh_token, expires_at, cloud_id, site_url FROM atlassian_tokens WHERE id = 1');
+    const row = stmt.get();
+    return row ?? null;
+}
+export function updateAtlassianAccessToken(access_token, expires_at) {
+    const db = getDb();
+    const stmt = db.prepare('UPDATE atlassian_tokens SET access_token = ?, expires_at = ? WHERE id = 1');
+    stmt.run(access_token, expires_at);
+}
+export function upsertProjects(projects) {
+    const db = getDb();
+    const stmt = db.prepare('INSERT INTO projects (id, name, active) VALUES (?, ?, 1) ON CONFLICT(id) DO UPDATE SET name = ?');
+    for (const p of projects) {
+        stmt.run(p.id, p.name, p.name);
+    }
+}
+export function getAllProjects() {
+    const db = getDb();
+    return db.prepare('SELECT * FROM projects ORDER BY name').all();
+}
+export function getActiveProjects() {
+    const db = getDb();
+    return db.prepare('SELECT * FROM projects WHERE active = 1 ORDER BY name').all();
+}
+export function toggleProjectActive(id, active) {
+    const db = getDb();
+    db.prepare('UPDATE projects SET active = ? WHERE id = ?').run(active ? 1 : 0, id);
+}

package/dist/lib/google.js

@@ -0,0 +1,57 @@
+import { google } from 'googleapis';
+import { resolveCredential } from './credentials.js';
+import axios from 'axios';
+const REDIRECT_URI = 'http://localhost:3005/oauth2callback';
+const AUTH_PROXY_URL = 'https://clocktopus-auth.clocktopus.workers.dev';
+function hasLocalCredentials() {
+    return !!(resolveCredential('GOOGLE_CLIENT_ID') && resolveCredential('GOOGLE_CLIENT_SECRET'));
+}
+export function getAuthenticatedClient(redirectUri) {
+    if (hasLocalCredentials()) {
+        return new google.auth.OAuth2(resolveCredential('GOOGLE_CLIENT_ID'), resolveCredential('GOOGLE_CLIENT_SECRET'), redirectUri ?? REDIRECT_URI);
+    }
+    // When using proxy, create client with placeholder — token exchange goes through proxy
+    return new google.auth.OAuth2('proxy', 'proxy', redirectUri ?? REDIRECT_URI);
+}
+export async function getAuthUrl(redirectUri, scopes) {
+    const scope = (scopes || ['https://www.googleapis.com/auth/calendar.readonly']).join(' ');
+    if (hasLocalCredentials()) {
+        const client = getAuthenticatedClient(redirectUri);
+        return client.generateAuthUrl({ access_type: 'offline', scope, prompt: 'consent' });
+    }
+    // Use proxy
+    const res = await axios.get(`${AUTH_PROXY_URL}/google/auth-url`, {
+        params: { redirect_uri: redirectUri ?? REDIRECT_URI, scope },
+    });
+    return res.data.url;
+}
+export async function exchangeGoogleCode(code, redirectUri) {
+    if (hasLocalCredentials()) {
+        const client = getAuthenticatedClient(redirectUri);
+        const { tokens } = await client.getToken(code);
+        return tokens;
+    }
+    // Use proxy
+    const res = await axios.post(`${AUTH_PROXY_URL}/google/token`, {
+        grant_type: 'authorization_code',
+        code,
+        redirect_uri: redirectUri ?? REDIRECT_URI,
+    });
+    return res.data;
+}
+export async function getRefreshedToken(token) {
+    if (hasLocalCredentials()) {
+        const client = getAuthenticatedClient();
+        client.setCredentials(token);
+        const refreshedToken = await client.refreshAccessToken();
+        return refreshedToken.credentials;
+    }
+    // Use proxy for refresh
+    if (!token.refresh_token)
+        throw new Error('No refresh token available');
+    const res = await axios.post(`${AUTH_PROXY_URL}/google/token`, {
+        grant_type: 'refresh_token',
+        refresh_token: token.refresh_token,
+    });
+    return res.data;
+}

package/dist/lib/http-client.js

@@ -0,0 +1,20 @@
+import axios from 'axios';
+import clockifyConfig from '../config/clockify.js';
+export class HttpClient {
+    constructor() {
+        this.client = axios.create({
+            baseURL: clockifyConfig.baseUrl,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+        });
+        this.client.interceptors.request.use((config) => {
+            config.headers['X-Api-Key'] = clockifyConfig.apiKey;
+            return config;
+        });
+    }
+    getClient() {
+        return this.client;
+    }
+}