clocktopus 1.8.1 → 1.10.0

package/README.md

@@ -49,18 +49,44 @@ That's it. Start/stop timers from the Home tab.
 
 ### Commands
 
-| Command                   | Description                             |
-| ------------------------- | --------------------------------------- |
-| `clocktopus dash`         | Start dashboard (foreground)            |
-| `clocktopus serve`        | Start dashboard as background daemon    |
-| `clocktopus serve:stop`   | Stop the dashboard daemon               |
-| `clocktopus serve:logs`   | View dashboard daemon logs              |
-| `clocktopus start`        | Start a timer (interactive)             |
-| `clocktopus stop`         | Stop the current timer                  |
-| `clocktopus status`       | Check timer status                      |
-| `clocktopus monitor`      | Start idle monitor as background daemon |
-| `clocktopus monitor:stop` | Stop the idle monitor                   |
-| `clocktopus monitor:logs` | View idle monitor logs                  |
+| Command                         | Description                                |
+| ------------------------------- | ------------------------------------------ |
+| `clocktopus dash`               | Start dashboard (foreground)               |
+| `clocktopus serve`              | Start dashboard as background daemon       |
+| `clocktopus serve:stop`         | Stop the dashboard daemon                  |
+| `clocktopus serve:logs`         | View dashboard daemon logs                 |
+| `clocktopus start`              | Start a timer (interactive)                |
+| `clocktopus stop`               | Stop the current timer                     |
+| `clocktopus status`             | Check timer status                         |
+| `clocktopus monitor`            | Start idle monitor as background daemon    |
+| `clocktopus monitor:stop`       | Stop the idle monitor                      |
+| `clocktopus monitor:logs`       | View idle monitor logs                     |
+| `clocktopus hook:install`       | Install global git post-checkout hook      |
+| `clocktopus hook:uninstall`     | Remove the global git post-checkout hook   |
+| `clocktopus hook:install-husky` | Add `.husky/post-checkout` in current repo |
+
+### Git post-checkout hook
+
+Auto-prompt to start a timer when you `git checkout` a branch. Extracts Jira tickets from branch names (e.g. `feature/RST-100-login` → `RST-100`), fetches the ticket summary from Jira as the default description, and maps to a Clockify project.
+
+```bash
+clocktopus hook:install
+```
+
+Installs a global hook at `~/.clocktopus/hooks/post-checkout` and sets `git config --global core.hooksPath` + `init.templateDir`.
+
+**Opt out per repo:** `touch .clocktopus-ignore` at the repo root.
+**Opt out per session:** `export CLOCKTOPUS_HOOK_DISABLE=1`.
+
+#### Husky users
+
+Husky sets a **local** `core.hooksPath`, which overrides the global one — so the hook won't fire in husky repos by default. Inside each husky-enabled repo, run:
+
+```bash
+clocktopus hook:install-husky
+```
+
+This writes `.husky/post-checkout` that chains to the global hook. Commit it so teammates get it too.
 
 ### Desktop App (macOS)
 

package/dist/index.js

@@ -1,8 +1,6 @@
 #!/usr/bin/env bun
 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';
@@ -10,14 +8,25 @@ import { createRequire } from 'module';
 import { execSync } from 'child_process';
 import { completeLatestSession, getLatestSession, setSessionJiraWorklogId } from './lib/db.js';
 import { isClockifyEnabled } from './lib/credentials.js';
-import { stopJiraTimer } from './lib/jira.js';
-import { startDashboard } from './dashboard/server.js';
 import { ensureNativeAddons } from './lib/ensure-native-addons.js';
 import { DASHBOARD_PORT, DASHBOARD_URL } from './lib/constants.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const program = new Command();
-const clockify = new Clockify();
+// Clockify + Jira pull in axios (via follow-redirects), which in Bun triggers
+// a tty WriteStream crash when loaded from a git hook context. Defer.
+let _clockify = null;
+async function clockify() {
+    if (!_clockify) {
+        const { Clockify } = await import('./clockify.js');
+        _clockify = new Clockify();
+    }
+    return _clockify;
+}
+async function stopJiraTimer(...args) {
+    const { stopJiraTimer: fn } = await import('./lib/jira.js');
+    return fn(...args);
+}
 async function getLocalProjects() {
     const dataDir = path.join(__dirname, '../data');
     const localProjectsPath = path.join(dataDir, 'local-projects.json');
@@ -39,7 +48,7 @@ async function getLocalProjects() {
     }
 }
 async function getWorkspaceAndUser() {
-    const user = await clockify.getUser();
+    const user = await (await clockify()).getUser();
     if (!user) {
         console.log(chalk.red('[index] Could not connect to Clockify. Please check your API key.'));
         process.exit(1);
@@ -60,25 +69,21 @@ program
     .option('-j, --jira <ticket>', 'Jira ticket number')
     .option('--no-billable', 'Mark the time entry as non-billable')
     .action(async (message, options) => {
+    const { startTimer } = await import('./lib/start-timer.js');
     if (!isClockifyEnabled()) {
         if (!options.jira) {
             console.error(chalk.red('Jira-only mode requires --jira <ticket>.'));
             process.exit(1);
         }
-        const { v4: uuidv4 } = await import('uuid');
-        const { logSessionStart } = await import('./lib/db.js');
-        const sessionId = uuidv4();
-        const startedAt = new Date().toISOString();
         const description = (message && String(message).trim()) || options.jira;
-        logSessionStart(sessionId, null, description, startedAt, options.jira);
+        await startTimer({ description, ticket: options.jira, projectId: null, billable: options.billable });
         console.log(chalk.green(`Timer started for ${chalk.bold(options.jira)} (Jira-only mode).`));
         return;
     }
     const { workspaceId } = await getWorkspaceAndUser();
-    let projects = await clockify.getProjects(workspaceId);
+    let projects = await (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');
@@ -93,6 +98,7 @@ program
         console.log(chalk.yellow('No projects found in your workspace.'));
         return;
     }
+    const inquirer = (await import('inquirer')).default;
     const { selectedProjectId } = await inquirer.prompt([
         {
             type: 'list',
@@ -101,11 +107,14 @@ program
             choices: projects.map((p) => ({ name: p.name, value: p.id })),
         },
     ]);
-    const entry = await clockify.startTimer(workspaceId, selectedProjectId, message, options.jira, options.billable);
-    if (entry) {
-        const projectName = projects.find((p) => p.id === selectedProjectId)?.name;
-        console.log(chalk.green(`Timer started for project: ${chalk.bold(projectName)}`));
-    }
+    await startTimer({
+        description: message || options.jira || '',
+        ticket: options.jira ?? null,
+        projectId: selectedProjectId,
+        billable: options.billable,
+    });
+    const projectName = projects.find((p) => p.id === selectedProjectId)?.name;
+    console.log(chalk.green(`Timer started for project: ${chalk.bold(projectName)}`));
 });
 program
     .command('stop')
@@ -114,7 +123,7 @@ program
     const latestSession = getLatestSession();
     if (isClockifyEnabled()) {
         const { workspaceId, userId } = await getWorkspaceAndUser();
-        const stoppedEntry = await clockify.stopTimer(workspaceId, userId);
+        const stoppedEntry = await (await clockify()).stopTimer(workspaceId, userId);
         if (!stoppedEntry) {
             console.log(chalk.yellow('No timer was running.'));
             return;
@@ -149,7 +158,7 @@ program
     .action(async () => {
     if (isClockifyEnabled()) {
         const { workspaceId, userId } = await getWorkspaceAndUser();
-        const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+        const activeEntry = await (await clockify()).getActiveTimer(workspaceId, userId);
         if (activeEntry) {
             const startTime = new Date(activeEntry.timeInterval.start);
             const duration = (new Date().getTime() - startTime.getTime()) / 1000;
@@ -193,7 +202,7 @@ program
         const clockifyOn = isClockifyEnabled();
         const latestSession = getLatestSession();
         if (clockifyOn) {
-            const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+            const activeEntry = await (await clockify()).getActiveTimer(workspaceId, userId);
             if (!activeEntry)
                 return false;
         }
@@ -204,7 +213,7 @@ program
         console.log(chalk.yellow(reason));
         const completedAt = new Date().toISOString();
         if (clockifyOn) {
-            const stoppedEntry = await clockify.stopTimer(workspaceId, userId);
+            const stoppedEntry = await (await clockify()).stopTimer(workspaceId, userId);
             if (!stoppedEntry)
                 return false;
         }
@@ -244,10 +253,10 @@ program
         if (isClockifyEnabled()) {
             if (!latestSession.projectId)
                 return;
-            const activeEntry = await clockify.getActiveTimer(workspaceId, userId);
+            const activeEntry = await (await clockify()).getActiveTimer(workspaceId, userId);
             if (activeEntry)
                 return;
-            await clockify.startTimer(workspaceId, latestSession.projectId, latestSession.description, latestSession.jiraTicket ?? undefined);
+            await (await clockify()).startTimer(workspaceId, latestSession.projectId, latestSession.description, latestSession.jiraTicket ?? undefined);
             console.log(chalk.green('Timer restarted for the last used project.'));
             lastResumeAt = Date.now();
             return;
@@ -353,7 +362,8 @@ program
 program
     .command('dash')
     .description(`Start the Clocktopus web dashboard on localhost:${DASHBOARD_PORT}.`)
-    .action(() => {
+    .action(async () => {
+    const { startDashboard } = await import('./dashboard/server.js');
     startDashboard();
 });
 const isDev = __dirname.includes('/Projects/') || __dirname.includes('/src/');
@@ -464,4 +474,58 @@ program
         console.log(chalk.yellow('Dashboard is not running.'));
     }
 });
+program
+    .command('hook:install')
+    .description('Install global git post-checkout hook (prompts to start timer on branch switch).')
+    .action(async () => {
+    const { installHook } = await import('./lib/hook-install.js');
+    await installHook();
+    console.log(chalk.green('Clocktopus post-checkout hook installed globally.'));
+    console.log(chalk.gray('  Disable per-repo: touch .clocktopus-ignore'));
+    console.log(chalk.gray('  Disable per-session: export CLOCKTOPUS_HOOK_DISABLE=1'));
+    console.log(chalk.gray('  Uninstall: clocktopus hook:uninstall'));
+    console.log();
+    console.log(chalk.yellow('Husky users: local core.hooksPath overrides global.'));
+    console.log(chalk.gray('  Inside each husky repo, run: clocktopus hook:install-husky'));
+});
+program
+    .command('hook:uninstall')
+    .description('Remove the global git post-checkout hook.')
+    .action(async () => {
+    const { uninstallHook } = await import('./lib/hook-install.js');
+    await uninstallHook();
+    console.log(chalk.green('Clocktopus post-checkout hook removed.'));
+});
+program
+    .command('hook:install-husky')
+    .description('Write a .husky/post-checkout in the current repo that chains to the global hook.')
+    .action(async () => {
+    const { installHuskyHook } = await import('./lib/husky-install.js');
+    const result = installHuskyHook(process.cwd());
+    if (result.installed) {
+        const verb = result.overwritten ? 'Overwrote' : 'Installed';
+        console.log(chalk.green(`${verb} husky post-checkout at ${result.path}.`));
+        console.log(chalk.gray('  Commit it so teammates using husky get it too.'));
+        return;
+    }
+    if (result.reason === 'no-husky-dir') {
+        console.error(chalk.red('No .husky/ directory found. Run from the root of a husky-enabled repo.'));
+        process.exit(1);
+    }
+});
+program
+    .command('hook:prompt <branch>')
+    .description('(internal) Prompt to start a timer after git checkout.')
+    .action(async (branch) => {
+    const { runHookPrompt } = await import('./lib/hook-prompt.js');
+    try {
+        await runHookPrompt(branch, { cwd: process.cwd() });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.error(chalk.red(`Hook prompt failed: ${msg}`));
+    }
+    // Force exit — /dev/tty fs streams and the sqlite handle keep the event loop alive.
+    process.exit(0);
+});
 program.parse(process.argv);

package/dist/lib/branch-parser.js

@@ -0,0 +1,7 @@
+const TICKET_REGEX = /([A-Za-z][A-Za-z0-9]+-\d+)/;
+export function extractTicket(branch) {
+    if (!branch)
+        return null;
+    const match = branch.match(TICKET_REGEX);
+    return match ? match[1].toUpperCase() : null;
+}

package/dist/lib/hook-ignore.js

@@ -0,0 +1,16 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const MARKER_FILE = '.clocktopus-ignore';
+export function isRepoIgnored(cwd) {
+    if (process.env.CLOCKTOPUS_HOOK_DISABLE === '1')
+        return true;
+    let dir = path.resolve(cwd);
+    while (true) {
+        if (fs.existsSync(path.join(dir, MARKER_FILE)))
+            return true;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return false;
+        dir = parent;
+    }
+}

package/dist/lib/hook-install.js

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { getHookPaths } from './hook-paths.js';
+import { POST_CHECKOUT_SCRIPT } from './hook-script.js';
+function writeHookScript(target) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, POST_CHECKOUT_SCRIPT, { mode: 0o755 });
+}
+export async function installHook() {
+    const p = getHookPaths();
+    writeHookScript(p.hookScript);
+    writeHookScript(p.templateHookScript);
+    execSync(`git config --global core.hooksPath "${p.hooksDir}"`, { stdio: 'ignore' });
+    execSync(`git config --global init.templateDir "${p.templateDir}"`, { stdio: 'ignore' });
+}
+export async function uninstallHook() {
+    const p = getHookPaths();
+    try {
+        fs.rmSync(p.hookScript, { force: true });
+    }
+    catch { }
+    try {
+        fs.rmSync(p.templateHookScript, { force: true });
+    }
+    catch { }
+    try {
+        execSync('git config --global --unset core.hooksPath', { stdio: 'ignore' });
+    }
+    catch { }
+    try {
+        execSync('git config --global --unset init.templateDir', { stdio: 'ignore' });
+    }
+    catch { }
+}

package/dist/lib/hook-paths.js

@@ -0,0 +1,14 @@
+import * as os from 'os';
+import * as path from 'path';
+export function getHookPaths() {
+    const rootDir = path.join(os.homedir(), '.clocktopus');
+    const hooksDir = path.join(rootDir, 'hooks');
+    const templateDir = path.join(rootDir, 'git-template');
+    return {
+        rootDir,
+        hooksDir,
+        hookScript: path.join(hooksDir, 'post-checkout'),
+        templateDir,
+        templateHookScript: path.join(templateDir, 'hooks', 'post-checkout'),
+    };
+}

package/dist/lib/hook-prompt.js

@@ -0,0 +1,96 @@
+import chalk from 'chalk';
+import { extractTicket } from './branch-parser.js';
+import { isRepoIgnored as realIsRepoIgnored } from './hook-ignore.js';
+import { isClockifyEnabled as realIsClockifyEnabled } from './credentials.js';
+import { getJiraSummary as realGetJiraSummary } from './jira-summary.js';
+import { getOpenSession as realGetOpenSession, getActiveProjects } from './db.js';
+import { matchProjectByTicket } from './project-matcher.js';
+import { simplePrompt } from './simple-prompt.js';
+import { startTimer as realStartTimer } from './start-timer.js';
+function defaultReadProjects() {
+    try {
+        return getActiveProjects().map((p) => ({ id: p.id, name: p.name }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function runHookPrompt(branch, opts) {
+    const d = opts.deps ?? {};
+    const isRepoIgnored = d.isRepoIgnored ?? realIsRepoIgnored;
+    const isClockifyEnabled = d.isClockifyEnabled ?? realIsClockifyEnabled;
+    const getJiraSummary = d.getJiraSummary ?? realGetJiraSummary;
+    const getOpenSession = d.getOpenSession ?? realGetOpenSession;
+    const readProjects = d.readProjects ?? defaultReadProjects;
+    const prompt = d.prompt ?? simplePrompt;
+    const startTimer = d.startTimer ?? realStartTimer;
+    if (isRepoIgnored(opts.cwd)) {
+        return { started: false, ticket: null, projectId: null, description: null, reason: 'ignored' };
+    }
+    let ticket = extractTicket(branch);
+    const openSession = getOpenSession();
+    if (openSession) {
+        const answer = await prompt([
+            {
+                type: 'confirm',
+                name: 'continueAnyway',
+                message: `A timer is already running. Stop it manually first, then re-checkout. Continue anyway?`,
+                default: false,
+            },
+        ]);
+        if (!answer.continueAnyway) {
+            return { started: false, ticket, projectId: null, description: null, reason: 'declined' };
+        }
+    }
+    const promptMsg = ticket
+        ? `Start timer for ${chalk.bold(ticket)} (branch: ${branch})?`
+        : `Start timer for branch ${chalk.bold(branch)}?`;
+    const confirmAnswer = await prompt([{ type: 'confirm', name: 'confirmStart', message: promptMsg, default: false }]);
+    if (!confirmAnswer.confirmStart) {
+        return { started: false, ticket, projectId: null, description: null, reason: 'declined' };
+    }
+    if (!ticket) {
+        const ticketAnswer = await prompt([{ type: 'input', name: 'ticket', message: 'Enter ticket (empty to skip):' }]);
+        const entered = typeof ticketAnswer.ticket === 'string' ? ticketAnswer.ticket : '';
+        ticket = entered.trim() ? entered.trim().toUpperCase() : null;
+    }
+    let defaultDescription = branch;
+    if (ticket) {
+        const summary = await getJiraSummary(ticket);
+        if (summary)
+            defaultDescription = summary;
+        else
+            defaultDescription = ticket;
+    }
+    const descAnswer = await prompt([
+        { type: 'input', name: 'description', message: 'Description:', default: defaultDescription },
+    ]);
+    const description = String(descAnswer.description);
+    let projectId = null;
+    if (isClockifyEnabled()) {
+        const projects = readProjects();
+        const matched = matchProjectByTicket(ticket, projects);
+        if (matched) {
+            projectId = matched.id;
+            console.log(chalk.gray(`  Auto-selected project: ${matched.name}`));
+        }
+        else if (projects.length > 0) {
+            const picked = await prompt([
+                {
+                    type: 'list',
+                    name: 'projectId',
+                    message: 'Which project?',
+                    choices: projects.map((p) => ({ name: p.name, value: p.id })),
+                },
+            ]);
+            projectId = String(picked.projectId);
+        }
+        else {
+            console.log(chalk.yellow('No local projects configured. Run `clocktopus start` once to populate.'));
+            return { started: false, ticket, projectId: null, description, reason: 'no-ticket' };
+        }
+    }
+    await startTimer({ description, ticket, projectId, billable: true });
+    console.log(chalk.green(`Timer started${ticket ? ` for ${chalk.bold(ticket)}` : ''}.`));
+    return { started: true, ticket, projectId, description };
+}

package/dist/lib/hook-script.js

@@ -0,0 +1,30 @@
+export const POST_CHECKOUT_SCRIPT = `#!/bin/sh
+# Clocktopus post-checkout hook — auto-installed by \`clocktopus hook:install\`
+# Fires only on branch checkout (flag "1"), not on file checkout.
+
+if [ "$3" != "1" ]; then
+  exit 0
+fi
+
+# Require a tty on stdout; otherwise the prompt has nowhere to render.
+# Git commonly redirects hook stdin, so we only check stdout here.
+if ! [ -t 1 ]; then
+  exit 0
+fi
+
+# Respect user opt-out.
+if [ "$CLOCKTOPUS_HOOK_DISABLE" = "1" ]; then
+  exit 0
+fi
+
+branch=$(git symbolic-ref --short HEAD 2>/dev/null) || exit 0
+[ -z "$branch" ] && exit 0
+
+# Resolve clocktopus binary; silently skip if not installed globally.
+if ! command -v clocktopus >/dev/null 2>&1; then
+  exit 0
+fi
+
+NO_COLOR=1 FORCE_COLOR=0 clocktopus hook:prompt "$branch" </dev/tty || true
+exit 0
+`;

package/dist/lib/husky-install.js

@@ -0,0 +1,19 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { getHookPaths } from './hook-paths.js';
+export function huskyHookBody() {
+    const { hookScript } = getHookPaths();
+    return `#!/bin/sh
+exec ${hookScript} "$@"
+`;
+}
+export function installHuskyHook(cwd) {
+    const huskyDir = path.join(cwd, '.husky');
+    if (!fs.existsSync(huskyDir) || !fs.statSync(huskyDir).isDirectory()) {
+        return { installed: false, reason: 'no-husky-dir' };
+    }
+    const target = path.join(huskyDir, 'post-checkout');
+    const overwritten = fs.existsSync(target);
+    fs.writeFileSync(target, huskyHookBody(), { mode: 0o755 });
+    return { installed: true, path: target, overwritten };
+}

package/dist/lib/jira-summary.js

@@ -0,0 +1,11 @@
+import { getJiraTicket } from './jira.js';
+export async function getJiraSummary(key) {
+    try {
+        const issue = (await getJiraTicket(key));
+        const summary = issue?.fields?.summary;
+        return summary && summary.trim() ? summary.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/project-matcher.js

@@ -0,0 +1,14 @@
+export function matchProjectByTicket(ticket, projects) {
+    if (!ticket)
+        return null;
+    const prefix = ticket.split('-')[0]?.toUpperCase();
+    if (!prefix)
+        return null;
+    for (const p of projects) {
+        if (!p.ticketPrefixes)
+            continue;
+        if (p.ticketPrefixes.some((tp) => tp.toUpperCase() === prefix))
+            return p;
+    }
+    return null;
+}

package/dist/lib/simple-prompt.js

@@ -0,0 +1,72 @@
+import * as fs from 'fs';
+function readLineSync(fd) {
+    const buf = Buffer.alloc(1);
+    let line = '';
+    while (true) {
+        const n = fs.readSync(fd, buf, 0, 1, null);
+        if (n === 0)
+            return line;
+        const ch = buf.toString('utf8');
+        if (ch === '\n')
+            return line;
+        if (ch === '\r')
+            continue;
+        line += ch;
+    }
+}
+export async function simplePrompt(qs) {
+    let inFd;
+    let outFd;
+    try {
+        inFd = fs.openSync('/dev/tty', 'r');
+        outFd = fs.openSync('/dev/tty', 'w');
+    }
+    catch {
+        throw new Error('simplePrompt: cannot open /dev/tty');
+    }
+    const write = (s) => fs.writeSync(outFd, s);
+    const out = {};
+    try {
+        for (const raw of qs) {
+            const q = raw;
+            const label = q.message.replace(/:\s*$/, '');
+            if (q.type === 'confirm') {
+                const def = q.default !== false;
+                write(`${label} ${def ? '[Y/n]' : '[y/N]'}: `);
+                const answer = readLineSync(inFd).trim().toLowerCase();
+                out[q.name] = answer === '' ? def : answer === 'y' || answer === 'yes';
+            }
+            else if (q.type === 'input') {
+                const def = typeof q.default === 'string' ? q.default : '';
+                write(def ? `${label} [${def}]: ` : `${label}: `);
+                const answer = readLineSync(inFd).trim();
+                out[q.name] = answer || def;
+            }
+            else if (q.type === 'list') {
+                write(`${label}\n`);
+                const choices = q.choices ?? [];
+                choices.forEach((c, i) => write(`  ${i + 1}) ${c.name}\n`));
+                while (true) {
+                    write(`Pick 1-${choices.length}: `);
+                    const answer = readLineSync(inFd).trim();
+                    const n = Number.parseInt(answer, 10);
+                    if (Number.isFinite(n) && n >= 1 && n <= choices.length) {
+                        out[q.name] = choices[n - 1].value;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    finally {
+        try {
+            fs.closeSync(inFd);
+        }
+        catch { }
+        try {
+            fs.closeSync(outFd);
+        }
+        catch { }
+    }
+    return out;
+}

package/dist/lib/start-timer.js

@@ -0,0 +1,30 @@
+import { isClockifyEnabled } from './credentials.js';
+export async function startTimer(input) {
+    if (!isClockifyEnabled()) {
+        if (!input.ticket) {
+            throw new Error('Jira-only mode: ticket required');
+        }
+        const { v4: uuidv4 } = await import('uuid');
+        const { logSessionStart } = await import('./db.js');
+        const sessionId = uuidv4();
+        const startedAt = new Date().toISOString();
+        const description = input.description?.trim() || input.ticket;
+        logSessionStart(sessionId, null, description, startedAt, input.ticket);
+        return { mode: 'jira-only', ticket: input.ticket, projectId: null, description };
+    }
+    if (!input.projectId) {
+        throw new Error('Clockify mode: projectId required');
+    }
+    const { Clockify } = await import('../clockify.js');
+    const clockify = new Clockify();
+    const user = await clockify.getUser();
+    if (!user)
+        throw new Error('Clockify auth failed');
+    await clockify.startTimer(user.defaultWorkspace, input.projectId, input.description, input.ticket ?? undefined, input.billable);
+    return {
+        mode: 'clockify',
+        ticket: input.ticket,
+        projectId: input.projectId,
+        description: input.description,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clocktopus",
-  "version": "1.8.1",
+  "version": "1.10.0",
   "description": "Time-tracking automation for Clockify with idle monitoring, Jira integration, Google Calendar sync, CLI, web dashboard, and desktop app.",
   "type": "module",
   "main": "dist/index.js",