clocktopus 1.0.0

package/dist/lib/jira.js

@@ -0,0 +1,82 @@
+import axios from 'axios';
+import { resolveCredential } from './credentials.js';
+import { getValidAccessToken } from './atlassian.js';
+async function jiraApiRequest(endpoint, method, body) {
+    // Try OAuth first
+    const oauthToken = await getValidAccessToken();
+    if (oauthToken) {
+        const baseUrl = `https://api.atlassian.com/ex/jira/${oauthToken.cloud_id}/rest/api/3`;
+        const url = `${baseUrl}${endpoint}`;
+        try {
+            const response = await axios({
+                method,
+                url,
+                data: body,
+                headers: {
+                    Authorization: `Bearer ${oauthToken.access_token}`,
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error('Error making Jira API request (OAuth):', error.message);
+            }
+            return null;
+        }
+    }
+    // Fall back to Basic Auth
+    const jiraApiUrl = resolveCredential('ATLASSIAN_URL');
+    const jiraApiToken = resolveCredential('ATLASSIAN_API_TOKEN');
+    const jiraUserEmail = resolveCredential('ATLASSIAN_EMAIL');
+    if (!jiraApiUrl || !jiraApiToken || !jiraUserEmail) {
+        console.error('Jira credentials are not configured. Use the dashboard to connect Atlassian or set env vars.');
+        return null;
+    }
+    try {
+        const response = await axios({
+            method,
+            url: `${jiraApiUrl}${endpoint}`,
+            data: body,
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${jiraUserEmail}:${jiraApiToken}`).toString('base64')}`,
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('Error making Jira API request:', error.message);
+        }
+        return null;
+    }
+}
+export async function stopJiraTimer(ticketId, timeSpentSeconds) {
+    const body = {
+        timeSpentSeconds,
+        comment: {
+            type: 'doc',
+            version: 1,
+            content: [
+                {
+                    type: 'paragraph',
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Timer stopped from Clocktopus',
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+    console.log('Jira request body:', JSON.stringify(body, null, 2));
+    return await jiraApiRequest(`/issue/${ticketId}/worklog`, 'POST', body);
+}
+export async function getJiraTicket(ticketId) {
+    return await jiraApiRequest(`/issue/${ticketId}`, 'GET');
+}

package/dist/lib/monitors/display-monitor-factory.js

@@ -0,0 +1,10 @@
+import { MacOSDisplayMonitor } from './display-monitor-macos.js';
+import chalk from 'chalk';
+export function createDisplayMonitor() {
+  if (process.platform === 'darwin') {
+    return new MacOSDisplayMonitor();
+  }
+  // Future: Add Linux and Windows implementations
+  console.log(chalk.yellow(`Display monitoring not yet supported on ${process.platform}. Using idle detection only.`));
+  return null;
+}

package/dist/lib/monitors/display-monitor-macos.js

@@ -0,0 +1,67 @@
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+export class MacOSDisplayMonitor {
+  constructor() {
+    this.logProc = null;
+    this.buffer = '';
+    this.currentDisplayState = true; // Assume display is on at start
+  }
+  start(callback) {
+    const predicate = `
+      (subsystem == "com.apple.powermanagement" OR
+       category CONTAINS[c] "Display" OR
+       eventMessage CONTAINS[c] "Display" OR
+       eventMessage CONTAINS[c] "Screen" OR
+       eventMessage CONTAINS[c] "DarkWake" OR
+       eventMessage CONTAINS[c] "Wake from Sleep" OR
+       eventMessage CONTAINS[c] "wake reason")
+    `.replace(/\s+/g, ' ');
+    this.logProc = spawn('log', ['stream', '--style', 'syslog', '--info', '--debug', '--predicate', predicate]);
+    this.logProc.stdout?.setEncoding('utf8');
+    this.logProc.stdout?.on('data', (chunk) => {
+      this.buffer += chunk;
+      let idx;
+      while ((idx = this.buffer.indexOf('\n')) >= 0) {
+        const line = this.buffer.slice(0, idx);
+        this.buffer = this.buffer.slice(idx + 1);
+        const isOff = this.lineMatches(line, [
+          /\bdisplay is turned off\b/i,
+          /\bcom\.apple\.powermanagement\b.*\bDisplay\b.*\bOff\b/i,
+          /\bdisplay sleep\b/i,
+        ]);
+        const isOn = this.lineMatches(line, [
+          /\bdisplay is turned on\b/i,
+          /\bcom\.apple\.powermanagement\b.*\bDisplay\b.*\bOn\b/i,
+          /\bdisplay wake\b/i,
+          /\bwake from sleep\b/i,
+          /\bFullWake\b/i,
+          /\bShowing Display\b/i,
+        ]);
+        // Only trigger callback if state changed
+        if (isOff && this.currentDisplayState) {
+          this.currentDisplayState = false;
+          callback(false);
+        } else if (isOn && !this.currentDisplayState) {
+          this.currentDisplayState = true;
+          callback(true);
+        }
+      }
+    });
+    this.logProc.stderr?.on('data', (d) => {
+      console.error(`log stderr: ${d}`);
+    });
+    this.logProc.on('close', (code) => {
+      console.log(chalk.gray(`log stream exited with code ${code}`));
+    });
+  }
+  stop() {
+    if (this.logProc && !this.logProc.killed) {
+      this.logProc.kill('SIGTERM');
+      this.logProc = null;
+    }
+  }
+  lineMatches(haystack, needles) {
+    const s = haystack.toLowerCase();
+    return needles.some((n) => (typeof n === 'string' ? s.includes(n.toLowerCase()) : n.test(haystack)));
+  }
+}

package/dist/lib/monitors/idle-monitor.js

@@ -0,0 +1,33 @@
+export class IdleMonitor {
+  constructor(thresholdSeconds = 300) {
+    this.thresholdSeconds = thresholdSeconds;
+    this.interval = null;
+    this.lastIdle = false;
+  }
+  async start(callback) {
+    this.interval = setInterval(async () => {
+      try {
+        const idleModule = await import('desktop-idle');
+        const idleTime = idleModule.default.getIdleTime();
+        const isCurrentlyIdle = idleTime >= this.thresholdSeconds;
+        if (isCurrentlyIdle && !this.lastIdle) {
+          // Transitioned to idle
+          callback(true);
+          this.lastIdle = true;
+        } else if (!isCurrentlyIdle && this.lastIdle) {
+          // Transitioned to active
+          callback(false);
+          this.lastIdle = false;
+        }
+      } catch (e) {
+        // Swallow errors; desktop-idle can occasionally throw on wake races
+      }
+    }, 5000);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+}

package/dist/lib/platform-events.js

@@ -0,0 +1,37 @@
+import { platform } from 'os';
+import { exec } from 'child_process';
+import chalk from 'chalk';
+export function setupPlatformEventListeners(onLock, onUnlock) {
+  const osType = platform();
+  if (osType === 'darwin') {
+    const listenerPath = '/Users/admin/Projects/Personal/clockify-tracker/macos-screen-listener';
+    console.log(`Attempting to start macOS screen listener from: ${listenerPath}`);
+    // IMPORTANT: Ensure the script is executable by running: chmod +x ${listenerPath}
+    const childProcess = exec(listenerPath);
+    childProcess.on('error', (err) => {
+      console.error(chalk.red.bold('Failed to start macOS screen listener process:'), err);
+    });
+    childProcess.stdout?.on('data', (data) => {
+      const message = data.toString().trim();
+      console.log(chalk.yellow('macOS screen listener stdout:'), message);
+      try {
+        const msg = JSON.parse(message);
+        if (msg.event === 'sleep' || msg.event === 'lock') {
+          onLock();
+        } else if (msg.event === 'wake' || msg.event === 'unlock') {
+          onUnlock();
+        }
+      } catch (e) {
+        console.error('Error parsing JSON from macOS screen listener:', e);
+      }
+    });
+    childProcess.stderr?.on('data', (data) => {
+      console.error(chalk.red.bold('macOS screen listener stderr:'), data.toString());
+    });
+    childProcess.on('close', (code) => {
+      console.log(`macOS screen listener exited with code ${code}`);
+    });
+  } else {
+    // ... other OS logic
+  }
+}

package/dist/lib/timer-controller.js

@@ -0,0 +1,56 @@
+import { completeLatestSession, getLatestSession } from './db.js';
+import { stopJiraTimer } from './jira.js';
+import chalk from 'chalk';
+export class TimerController {
+  constructor(clockify, workspaceId, userId) {
+    this.clockify = clockify;
+    this.workspaceId = workspaceId;
+    this.userId = userId;
+    this.lastResumeAt = 0;
+    this.RESUME_COOLDOWN_MS = 10000;
+  }
+  async stopTimer(reason) {
+    const activeEntry = await this.clockify.getActiveTimer(this.workspaceId, this.userId);
+    if (!activeEntry) return false;
+    console.log(chalk.yellow(reason));
+    const completedAt = new Date().toISOString();
+    const latestSession = getLatestSession();
+    const stoppedEntry = await this.clockify.stopTimer(this.workspaceId, this.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;
+  }
+  async safeRestartTimer() {
+    const now = Date.now();
+    if (now - this.lastResumeAt < this.RESUME_COOLDOWN_MS) return;
+    // Small delay lets services settle after wake/activity
+    await this.sleep(800);
+    const latestSession = getLatestSession();
+    if (!latestSession) return;
+    const activeEntry = await this.clockify.getActiveTimer(this.workspaceId, this.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 this.clockify.startTimer(this.workspaceId, latestSession.projectId, latestSession.description);
+    console.log(chalk.green('Timer restarted for the last used project.'));
+    this.lastResumeAt = Date.now();
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/dist/proxy/src/index.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ATLASSIAN_TOKEN_URL = 'https://auth.atlassian.com/oauth/token';
+const GOOGLE_TOKEN_URL = 'https://oauth2.googleapis.com/token';
+const CORS_HEADERS = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type',
+};
+exports.default = {
+    async fetch(request, env) {
+        if (request.method === 'OPTIONS') {
+            return new Response(null, { headers: CORS_HEADERS });
+        }
+        const url = new URL(request.url);
+        // --- Atlassian ---
+        if (url.pathname === '/atlassian/auth-url' && request.method === 'GET') {
+            const redirectUri = url.searchParams.get('redirect_uri');
+            if (!redirectUri) {
+                return Response.json({ error: 'redirect_uri required' }, { status: 400, headers: CORS_HEADERS });
+            }
+            const params = new URLSearchParams({
+                audience: 'api.atlassian.com',
+                client_id: env.ATLASSIAN_CLIENT_ID,
+                scope: 'read:jira-work write:jira-work read:jira-user read:me offline_access',
+                redirect_uri: redirectUri,
+                response_type: 'code',
+                prompt: 'consent',
+            });
+            return Response.json({ url: `https://auth.atlassian.com/authorize?${params.toString()}` }, { headers: CORS_HEADERS });
+        }
+        if (url.pathname === '/atlassian/token' && request.method === 'POST') {
+            const body = (await request.json());
+            const payload = {
+                client_id: env.ATLASSIAN_CLIENT_ID,
+                client_secret: env.ATLASSIAN_CLIENT_SECRET,
+                grant_type: body.grant_type,
+            };
+            if (body.grant_type === 'authorization_code') {
+                if (!body.code || !body.redirect_uri) {
+                    return Response.json({ error: 'code and redirect_uri required' }, { status: 400, headers: CORS_HEADERS });
+                }
+                payload.code = body.code;
+                payload.redirect_uri = body.redirect_uri;
+            }
+            else if (body.grant_type === 'refresh_token') {
+                if (!body.refresh_token) {
+                    return Response.json({ error: 'refresh_token required' }, { status: 400, headers: CORS_HEADERS });
+                }
+                payload.refresh_token = body.refresh_token;
+            }
+            else {
+                return Response.json({ error: 'unsupported grant_type' }, { status: 400, headers: CORS_HEADERS });
+            }
+            const tokenRes = await fetch(ATLASSIAN_TOKEN_URL, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+            });
+            const data = await tokenRes.text();
+            return new Response(data, {
+                status: tokenRes.status,
+                headers: { ...CORS_HEADERS, 'Content-Type': 'application/json' },
+            });
+        }
+        // --- Google ---
+        if (url.pathname === '/google/auth-url' && request.method === 'GET') {
+            const redirectUri = url.searchParams.get('redirect_uri');
+            const scope = url.searchParams.get('scope');
+            if (!redirectUri || !scope) {
+                return Response.json({ error: 'redirect_uri and scope required' }, { status: 400, headers: CORS_HEADERS });
+            }
+            const params = new URLSearchParams({
+                client_id: env.GOOGLE_CLIENT_ID,
+                redirect_uri: redirectUri,
+                response_type: 'code',
+                scope,
+                access_type: 'offline',
+                prompt: 'consent',
+            });
+            return Response.json({ url: `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}` }, { headers: CORS_HEADERS });
+        }
+        if (url.pathname === '/google/token' && request.method === 'POST') {
+            const body = (await request.json());
+            const formData = new URLSearchParams();
+            formData.set('client_id', env.GOOGLE_CLIENT_ID);
+            formData.set('client_secret', env.GOOGLE_CLIENT_SECRET);
+            formData.set('grant_type', body.grant_type);
+            if (body.grant_type === 'authorization_code') {
+                if (!body.code || !body.redirect_uri) {
+                    return Response.json({ error: 'code and redirect_uri required' }, { status: 400, headers: CORS_HEADERS });
+                }
+                formData.set('code', body.code);
+                formData.set('redirect_uri', body.redirect_uri);
+            }
+            else if (body.grant_type === 'refresh_token') {
+                if (!body.refresh_token) {
+                    return Response.json({ error: 'refresh_token required' }, { status: 400, headers: CORS_HEADERS });
+                }
+                formData.set('refresh_token', body.refresh_token);
+            }
+            else {
+                return Response.json({ error: 'unsupported grant_type' }, { status: 400, headers: CORS_HEADERS });
+            }
+            const tokenRes = await fetch(GOOGLE_TOKEN_URL, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: formData.toString(),
+            });
+            const data = await tokenRes.text();
+            return new Response(data, {
+                status: tokenRes.status,
+                headers: { ...CORS_HEADERS, 'Content-Type': 'application/json' },
+            });
+        }
+        return Response.json({ error: 'not found' }, { status: 404, headers: CORS_HEADERS });
+    },
+};

package/dist/scripts/db-cleanup.js

@@ -0,0 +1,4 @@
+import { deleteOldSessions } from '../lib/db.js';
+const days = process.argv[2] ? parseInt(process.argv[2], 10) : 5;
+deleteOldSessions(days);
+console.log(`Deleted sessions older than ${days} days.`);

package/dist/scripts/google-auth.js

@@ -0,0 +1,31 @@
+import { getAuthenticatedClient } from '../lib/google.js';
+import * as http from 'http';
+import * as url from 'url';
+import { storeToken } from '../lib/db.js';
+const oAuth2Client = getAuthenticatedClient();
+const SCOPES = ['https://www.googleapis.com/auth/calendar.readonly'];
+const server = http.createServer(async (req, res) => {
+    if (req.url && req.url.startsWith('/oauth2callback')) {
+        const qs = new url.URL(req.url, 'http://localhost:3005').searchParams;
+        const code = qs.get('code');
+        if (code) {
+            const { tokens } = await oAuth2Client.getToken(code);
+            oAuth2Client.setCredentials(tokens);
+            storeToken(tokens);
+            res.end('Authentication successful! You can close this window.');
+            server.close();
+            process.exit(0);
+        }
+    }
+    else {
+        const authorizeUrl = oAuth2Client.generateAuthUrl({
+            access_type: 'offline',
+            scope: SCOPES,
+        });
+        res.writeHead(302, { Location: authorizeUrl });
+        res.end();
+    }
+});
+server.listen(3005, () => {
+    console.log('Please visit http://localhost:3005 to authorize the application.');
+});

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

@@ -0,0 +1,141 @@
+import * as dotenv from 'dotenv';
+dotenv.config();
+import chalk from 'chalk';
+import { google } from 'googleapis';
+import { getAuthenticatedClient, getRefreshedToken } from '../lib/google.js';
+import { getEventProject, setEventProject, getLatestToken, storeToken } from '../lib/db.js';
+import { Clockify } from '../clockify.js';
+import { program } from 'commander';
+import inquirer from 'inquirer';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+async function getLocalProjects() {
+    const dataDir = path.join(__dirname, '../../data');
+    const localProjectsPath = path.join(dataDir, 'local-projects.json');
+    try {
+        await fs.promises.mkdir(dataDir, { recursive: true });
+        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 [];
+    }
+}
+program
+    .option('-s, --start-date <startDate>', 'Start date for fetching calendar events')
+    .option('-e, --end-date <endDate>', 'End date for fetching calendar events')
+    .option('-t, --today', 'Log time for today')
+    .option('-p, --project-id <projectId>', 'Clockify project ID')
+    .parse(process.argv);
+const opts = program.opts();
+const { projectId, today } = opts;
+let { startDate, endDate } = opts;
+if (today) {
+    const todayDate = new Date();
+    startDate = todayDate.toISOString().split('T')[0];
+    endDate = startDate;
+}
+if (!startDate || !endDate) {
+    console.error('Please provide both a start and end date, or use the -t flag for today.');
+    process.exit(1);
+}
+async function main() {
+    const clockify = new Clockify();
+    const user = await clockify.getUser();
+    if (!user) {
+        console.error('Could not get Clockify user. Please check your API key.');
+        return;
+    }
+    const projects = await (async () => {
+        if (projectId) {
+            return [];
+        }
+        const allProjects = await clockify.getProjects(user.activeWorkspace);
+        const localProjects = await getLocalProjects();
+        if (localProjects.length > 0) {
+            const localProjectIds = localProjects.map((p) => p.id);
+            return allProjects.filter((p) => localProjectIds.includes(p.id));
+        }
+        return allProjects;
+    })();
+    let token = await getLatestToken();
+    if (!token) {
+        console.error('Please authenticate with Google first.');
+        return;
+    }
+    const oAuth2Client = getAuthenticatedClient();
+    oAuth2Client.setCredentials(token);
+    if (new Date(token.expiry_date) < new Date()) {
+        console.log('Token expired, refreshing...');
+        token = await getRefreshedToken(token);
+        storeToken(token);
+        oAuth2Client.setCredentials(token);
+    }
+    const calendar = google.calendar({ version: 'v3', auth: oAuth2Client });
+    try {
+        const timeMin = new Date(startDate).toISOString();
+        const endOfDay = new Date(endDate);
+        endOfDay.setDate(endOfDay.getDate() + 1);
+        const timeMax = endOfDay.toISOString();
+        const res = await calendar.events.list({
+            calendarId: 'primary',
+            timeMin: timeMin,
+            timeMax: timeMax,
+            singleEvents: true,
+            orderBy: 'startTime',
+        });
+        const events = res.data.items;
+        console.log(`Checking for events between ${startDate} and ${endDate}...`);
+        if (events && events.length) {
+            for (const event of events) {
+                if (event.start && event.start.date) {
+                    console.log(`Skipping all-day event: "${event.summary}" on ${event.start.date}`);
+                    continue;
+                }
+                if (event.summary && event.start && event.start.dateTime && event.end && event.end.dateTime) {
+                    let eventProjectId = projectId || getEventProject(event.summary);
+                    if (eventProjectId === null) {
+                        console.log(`Skipping "${event.summary}" as per your previous choice.`);
+                        continue;
+                    }
+                    if (!eventProjectId) {
+                        const { selectedProjectId } = await inquirer.prompt([
+                            {
+                                type: 'list',
+                                name: 'selectedProjectId',
+                                message: `Which project for event "${event.summary}"?`,
+                                choices: [
+                                    { name: chalk.yellow('Skip'), value: null },
+                                    ...projects.map((p) => ({ name: p.name, value: p.id })),
+                                ],
+                            },
+                        ]);
+                        eventProjectId = selectedProjectId;
+                        setEventProject(event.summary, eventProjectId);
+                    }
+                    if (eventProjectId) {
+                        console.log(`Logging "${event.summary}" to Clockify...`);
+                        await clockify.logTime(user.activeWorkspace, eventProjectId, event.start.dateTime, event.end.dateTime, event.summary);
+                    }
+                }
+            }
+            console.log('Done!');
+        }
+        else {
+            console.log('No upcoming events found for the specified date range.');
+        }
+    }
+    catch (error) {
+        console.error('The API returned an error: ' + error);
+    }
+}
+main();

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "clocktopus",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "clocktopus": "dist/index.js"
+  },
+  "license": "MIT",
+  "files": [
+    "dist",
+    "data/.gitkeep",
+    "!dist/desktop"
+  ],
+  "scripts": {
+    "build": "bunx tsc",
+    "prepublishOnly": "bunx tsc",
+    "lint": "eslint . --ext .ts",
+    "clock": "bun dist/index.js",
+    "clockd": "bunx pm2 start dist/index.js --name clocktopus --",
+    "monitor": "bun run clockd monitor",
+    "monitor:restart": "bunx pm2 restart clocktopus",
+    "monitor:stop": "bunx pm2 stop clocktopus",
+    "monitor:logs": "bunx pm2 logs clocktopus",
+    "monitor:status": "bunx pm2 status clocktopus",
+    "prepare": "husky",
+    "dashboard": "bun -e \"import('./dist/dashboard/server.js').then(m => m.startDashboard())\"",
+    "db:cleanup": "bun dist/scripts/db-cleanup.js",
+    "google-auth": "bunx tsc && bun dist/scripts/google-auth.js",
+    "log-calendar": "bunx tsc && bun -r dotenv/config dist/scripts/log-calendar-events.js"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.9",
+    "axios": "^1.10.0",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.0",
+    "desktop-idle": "^1.3.0",
+    "dotenv": "^17.0.1",
+    "googleapis": "^153.0.0",
+    "hono": "^4.12.3",
+    "inquirer": "^8.2.4",
+    "macos-notification-state": "^3.0.0",
+    "node-notifier": "^10.0.1",
+    "uuid": "^11.1.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11",
+    "@types/inquirer": "^9.0.8",
+    "@types/node": "^24.0.10",
+    "@types/node-notifier": "^8.0.5",
+    "@typescript-eslint/eslint-plugin": "^8.36.0",
+    "@typescript-eslint/parser": "^8.36.0",
+    "eslint": "^9.30.1",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.5.1",
+    "husky": "^9.1.7",
+    "pm2": "^6.0.8",
+    "prettier": "^3.6.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.36.0"
+  }
+}