clocktopus 1.0.0

package/dist/dashboard/routes/jira.js

@@ -0,0 +1,81 @@
+import { Hono } from 'hono';
+import axios from 'axios';
+import { saveCredential } from '../../lib/credentials.js';
+import { storeAtlassianToken } from '../../lib/db.js';
+import { getAtlassianAuthUrl, exchangeCodeForTokens, getAccessibleResources } from '../../lib/atlassian.js';
+const jiraRoutes = new Hono();
+// OAuth: redirect to Atlassian authorization (browser fallback)
+jiraRoutes.get('/jira/connect', async (c) => {
+    try {
+        const authUrl = await getAtlassianAuthUrl();
+        return c.redirect(authUrl);
+    }
+    catch (error) {
+        return c.json({ ok: false, error: error instanceof Error ? error.message : 'Failed to generate auth URL.' }, 500);
+    }
+});
+// OAuth: return auth URL as JSON (for desktop app)
+jiraRoutes.get('/jira/auth-url', async (c) => {
+    try {
+        const url = await getAtlassianAuthUrl();
+        return c.json({ url });
+    }
+    catch (error) {
+        return c.json({ ok: false, error: error instanceof Error ? error.message : 'Failed to generate auth URL.' }, 500);
+    }
+});
+// OAuth: handle callback from Atlassian
+jiraRoutes.get('/jira/callback', async (c) => {
+    const code = c.req.query('code');
+    if (!code) {
+        return c.redirect('/?jira=error&reason=no_code');
+    }
+    try {
+        const tokens = await exchangeCodeForTokens(code);
+        const resources = await getAccessibleResources(tokens.access_token);
+        if (resources.length === 0) {
+            return c.redirect('/?jira=error&reason=no_sites');
+        }
+        const site = resources[0];
+        const expiresAt = new Date(Date.now() + tokens.expires_in * 1000).toISOString();
+        storeAtlassianToken({
+            access_token: tokens.access_token,
+            refresh_token: tokens.refresh_token,
+            expires_at: expiresAt,
+            cloud_id: site.id,
+            site_url: site.url,
+        });
+        return c.redirect(`/?jira=connected&site=${encodeURIComponent(site.name)}`);
+    }
+    catch (error) {
+        console.error('Atlassian OAuth callback error:', error instanceof Error ? error.message : error);
+        return c.redirect('/?jira=error&reason=token_exchange_failed');
+    }
+});
+// Basic Auth: manual API token setup (kept as fallback)
+jiraRoutes.post('/jira', async (c) => {
+    const { url, email, token } = await c.req.json();
+    if (!url || !email || !token) {
+        return c.json({ ok: false, error: 'All fields are required.' }, 400);
+    }
+    try {
+        const res = await axios.get(`${url}/myself`, {
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${email}:${token}`).toString('base64')}`,
+                Accept: 'application/json',
+            },
+            timeout: 5000,
+        });
+        if (res.status === 200) {
+            saveCredential('ATLASSIAN_URL', url);
+            saveCredential('ATLASSIAN_EMAIL', email);
+            saveCredential('ATLASSIAN_API_TOKEN', token);
+            return c.json({ ok: true, user: res.data.displayName });
+        }
+        return c.json({ ok: false, error: 'Invalid credentials.' });
+    }
+    catch {
+        return c.json({ ok: false, error: 'Could not validate credentials with Jira.' });
+    }
+});
+export default jiraRoutes;

package/dist/dashboard/routes/monitor.js

@@ -0,0 +1,45 @@
+import { Hono } from 'hono';
+import { execSync } from 'child_process';
+const monitorRoutes = new Hono();
+function pm2Exec(command) {
+    try {
+        const output = execSync(command, { encoding: 'utf-8', timeout: 10000 });
+        return { ok: true, output: output.trim() };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : 'Unknown error';
+        return { ok: false, output: msg };
+    }
+}
+monitorRoutes.get('/monitor/status', (c) => {
+    try {
+        const output = execSync('bunx pm2 jlist', { encoding: 'utf-8', timeout: 10000 });
+        const processes = JSON.parse(output);
+        const clocktopus = processes.find((p) => p.name === 'clocktopus');
+        if (!clocktopus) {
+            return c.json({ running: false, status: 'not found' });
+        }
+        return c.json({
+            running: clocktopus.pm2_env.status === 'online',
+            status: clocktopus.pm2_env.status,
+            uptime: clocktopus.pm2_env.pm_uptime,
+            restarts: clocktopus.pm2_env.restart_time,
+        });
+    }
+    catch {
+        return c.json({ running: false, status: 'pm2 not available' });
+    }
+});
+monitorRoutes.post('/monitor/start', (c) => {
+    const result = pm2Exec('bunx pm2 start dist/index.js --name clocktopus -- monitor');
+    return c.json(result);
+});
+monitorRoutes.post('/monitor/stop', (c) => {
+    const result = pm2Exec('bunx pm2 stop clocktopus');
+    return c.json(result);
+});
+monitorRoutes.post('/monitor/restart', (c) => {
+    const result = pm2Exec('bunx pm2 restart clocktopus');
+    return c.json(result);
+});
+export default monitorRoutes;

package/dist/dashboard/routes/status.js

@@ -0,0 +1,84 @@
+import { Hono } from 'hono';
+import axios from 'axios';
+import { 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,
+        google: false,
+        jira: 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;
+        }
+        catch { }
+    }
+    // Check Google — token exists in DB
+    const token = getLatestToken();
+    results.google = !!token;
+    if (token) {
+        const googleEmail = resolveCredential('GOOGLE_ACCOUNT_EMAIL');
+        if (googleEmail)
+            results.googleEmail = googleEmail;
+    }
+    // Check Jira — OAuth first, then Basic Auth
+    const storedAtlassianToken = getAtlassianToken();
+    if (storedAtlassianToken) {
+        results.jiraOAuth = 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);
+            }
+            else {
+                console.error('Jira OAuth status check failed:', error);
+            }
+            results.jira = false;
+        }
+    }
+    else {
+        const jiraUrl = resolveCredential('ATLASSIAN_URL');
+        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;
+            }
+            catch { }
+        }
+    }
+    return c.json(results);
+});
+export default statusRoutes;

package/dist/dashboard/routes/timer.js

@@ -0,0 +1,60 @@
+import { Hono } from 'hono';
+import { Clockify } from '../../clockify.js';
+import { completeLatestSession } from '../../lib/db.js';
+const timerRoutes = new Hono();
+timerRoutes.get('/timer/active', async (c) => {
+    try {
+        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)
+            return c.json({ active: false });
+        return c.json({
+            active: true,
+            description: timer.description,
+            projectId: timer.projectId,
+            start: timer.timeInterval.start,
+        });
+    }
+    catch {
+        return c.json({ active: false });
+    }
+});
+timerRoutes.post('/timer/start', async (c) => {
+    const { projectId, description, jiraTicket } = await c.req.json();
+    if (!projectId || !description) {
+        return c.json({ ok: false, error: 'Project and description are 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 result = await clockify.startTimer(user.defaultWorkspace, projectId, description, jiraTicket);
+        if (!result)
+            return c.json({ ok: false, error: 'Failed to start timer.' }, 500);
+        return c.json({ ok: true });
+    }
+    catch {
+        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 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);
+        return c.json({ ok: true });
+    }
+    catch {
+        return c.json({ ok: false, error: 'Failed to stop timer.' }, 500);
+    }
+});
+export default timerRoutes;

package/dist/dashboard/server.js

@@ -0,0 +1,24 @@
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { indexPage } from './views.js';
+import statusRoutes from './routes/status.js';
+import clockifyRoutes from './routes/clockify.js';
+import jiraRoutes from './routes/jira.js';
+import googleRoutes from './routes/google.js';
+import timerRoutes from './routes/timer.js';
+import dataRoutes from './routes/data.js';
+import monitorRoutes from './routes/monitor.js';
+const app = new Hono();
+app.get('/', (c) => c.html(indexPage()));
+app.route('/api', statusRoutes);
+app.route('/api', clockifyRoutes);
+app.route('/api', jiraRoutes);
+app.route('/api', googleRoutes);
+app.route('/api', timerRoutes);
+app.route('/api', dataRoutes);
+app.route('/api', monitorRoutes);
+export function startDashboard() {
+    const port = 4001;
+    console.log(`Clocktopus dashboard running at http://localhost:${port}`);
+    serve({ fetch: app.fetch, port });
+}