@blastin-dev/clocktopus-cli 0.1.0

package/README.md

@@ -0,0 +1,61 @@
+# Clocktopus CLI
+
+Command-line interface for [Clocktopus](https://clocktopus.app) time tracking.
+
+## Installation
+
+```bash
+npm install -g @blastin-dev/clocktopus-cli
+```
+
+Or run directly with npx:
+
+```bash
+npx @blastin-dev/clocktopus-cli <command>
+```
+
+## Getting Started
+
+Authenticate with your Clocktopus account:
+
+```bash
+clocktopus login
+```
+
+This will open a browser window where you authorize the CLI. Once complete, your session is stored locally.
+
+## Commands
+
+### `clocktopus login`
+
+Authenticate using the device authorization flow. Opens a URL in your browser to approve access.
+
+### `clocktopus logout`
+
+Clear stored credentials.
+
+### `clocktopus whoami`
+
+Display the current authenticated user.
+
+### `clocktopus clock in`
+
+Record a clock-in signal.
+
+### `clocktopus clock out`
+
+Record a clock-out signal.
+
+### `clocktopus clock status`
+
+Show signals for a given date.
+
+## Token Storage
+
+Credentials are stored in a platform-specific config directory:
+
+- **macOS**: `~/Library/Preferences/clocktopus-cli-nodejs/config.json`
+- **Linux**: `~/.config/clocktopus-cli-nodejs/config.json`
+- **Windows**: `%APPDATA%/clocktopus-cli-nodejs/config.json`
+
+Run `clocktopus logout` to clear stored credentials.

package/dist/bin/clocktopus.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=clocktopus.d.ts.map

package/dist/bin/clocktopus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clocktopus.d.ts","sourceRoot":"","sources":["../../bin/clocktopus.ts"],"names":[],"mappings":""}

package/dist/bin/clocktopus.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { run } from "../src/index.js";
+run();

package/dist/src/commands/clock.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Record a clock-in signal for today
+ */
+export declare function clockInCommand(): Promise<void>;
+/**
+ * Record a clock-out signal for today
+ */
+export declare function clockOutCommand(): Promise<void>;
+/**
+ * Show clock signals status for a given date (default: today)
+ */
+export declare function clockStatusCommand(options: {
+    date?: string;
+}): Promise<void>;
+//# sourceMappingURL=clock.d.ts.map

package/dist/src/commands/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../../src/commands/clock.ts"],"names":[],"mappings":"AAuDA;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAqCpD;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAuCrD;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,IAAI,CAAC,CAiDhB"}

package/dist/src/commands/clock.js

@@ -0,0 +1,172 @@
+import { format } from "date-fns";
+import { z } from "zod";
+import { ApiError, get, post } from "../lib/api.js";
+import { isLoggedIn } from "../lib/config.js";
+/**
+ * Schema for clock signal response
+ */
+const ClockSignalResponseSchema = z.object({
+    success: z.boolean(),
+    signal: z.object({
+        id: z.string(),
+        signalType: z.enum(["clock_in", "clock_out"]),
+        workDate: z.string(),
+        effectiveTime: z.string(),
+        timezone: z.string(),
+        signalTimestamp: z.string(),
+        alreadyExists: z.boolean(),
+        blockedReason: z.enum(["already_clocked_in", "not_clocked_in"]).nullable(),
+    }),
+});
+/**
+ * Schema for clock signals list response
+ */
+const ClockSignalsListSchema = z.object({
+    signals: z.array(z.object({
+        id: z.string(),
+        userId: z.string(),
+        signalType: z.enum(["clock_in", "clock_out"]),
+        signalTimestamp: z.string(),
+        workDate: z.string(),
+        timezone: z.string(),
+        effectiveTime: z.string(),
+        createdAt: z.string(),
+    })),
+});
+function checkAuth() {
+    if (!isLoggedIn()) {
+        console.error("You are not logged in. Use 'clocktopus login' to authenticate first.");
+        return false;
+    }
+    return true;
+}
+function formatSignalType(type) {
+    return type === "clock_in" ? "Clock In" : "Clock Out";
+}
+/**
+ * Record a clock-in signal for today
+ */
+export async function clockInCommand() {
+    if (!checkAuth()) {
+        process.exit(1);
+    }
+    try {
+        const data = await post("/api/clock-signal", { signalType: "clock_in" });
+        const response = ClockSignalResponseSchema.parse(data);
+        if (response.signal.alreadyExists) {
+            console.log(`\nAlready clocked in - must clock out first.`);
+            console.log(`  Current clock-in:`);
+            console.log(`    Date: ${response.signal.workDate}`);
+            console.log(`    Time: ${response.signal.effectiveTime}`);
+            console.log(`    Timezone: ${response.signal.timezone}`);
+        }
+        else {
+            console.log(`\nClock In recorded!`);
+            console.log(`  Date: ${response.signal.workDate}`);
+            console.log(`  Time: ${response.signal.effectiveTime}`);
+            console.log(`  Timezone: ${response.signal.timezone}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ApiError) {
+            if (error.status === 401) {
+                console.error("Session expired. Use 'clocktopus login' to authenticate again.");
+            }
+            else {
+                console.error(`Failed to record clock-in: ${error.message}`);
+            }
+        }
+        else {
+            console.error(`Failed to record clock-in: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Record a clock-out signal for today
+ */
+export async function clockOutCommand() {
+    if (!checkAuth()) {
+        process.exit(1);
+    }
+    try {
+        const data = await post("/api/clock-signal", { signalType: "clock_out" });
+        const response = ClockSignalResponseSchema.parse(data);
+        if (response.signal.alreadyExists) {
+            console.log(`\nNot clocked in - must clock in first.`);
+            if (response.signal.id) {
+                console.log(`  Last signal:`);
+                console.log(`    Date: ${response.signal.workDate}`);
+                console.log(`    Time: ${response.signal.effectiveTime}`);
+                console.log(`    Timezone: ${response.signal.timezone}`);
+            }
+        }
+        else {
+            console.log(`\nClock Out recorded!`);
+            console.log(`  Date: ${response.signal.workDate}`);
+            console.log(`  Time: ${response.signal.effectiveTime}`);
+            console.log(`  Timezone: ${response.signal.timezone}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ApiError) {
+            if (error.status === 401) {
+                console.error("Session expired. Use 'clocktopus login' to authenticate again.");
+            }
+            else {
+                console.error(`Failed to record clock-out: ${error.message}`);
+            }
+        }
+        else {
+            console.error(`Failed to record clock-out: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Show clock signals status for a given date (default: today)
+ */
+export async function clockStatusCommand(options) {
+    if (!checkAuth()) {
+        process.exit(1);
+    }
+    // Use provided date or default to today (local time)
+    const date = options.date ?? format(new Date(), "yyyy-MM-dd");
+    // Validate date format
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+        console.error("Invalid date format. Use YYYY-MM-DD.");
+        process.exit(1);
+    }
+    try {
+        const data = await get(`/api/clock-signal?date=${date}`);
+        const response = ClockSignalsListSchema.parse(data);
+        console.log(`\nClock signals for ${date}:`);
+        if (response.signals.length === 0) {
+            console.log("  No clock signals recorded for this date.");
+            console.log("  (Default work hours from your preferences will be used)");
+        }
+        else {
+            // Show all signals in chronological order
+            for (let i = 0; i < response.signals.length; i++) {
+                const signal = response.signals[i];
+                if (!signal)
+                    continue;
+                console.log(`  ${i + 1}. ${formatSignalType(signal.signalType)} at ${signal.effectiveTime} (${signal.timezone})`);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof ApiError) {
+            if (error.status === 401) {
+                console.error("Session expired. Use 'clocktopus login' to authenticate again.");
+            }
+            else {
+                console.error(`Failed to fetch clock status: ${error.message}`);
+            }
+        }
+        else {
+            console.error(`Failed to fetch clock status: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/src/commands/login.d.ts

@@ -0,0 +1,2 @@
+export declare function loginCommand(): Promise<void>;
+//# sourceMappingURL=login.d.ts.map

package/dist/src/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../src/commands/login.ts"],"names":[],"mappings":"AAKA,wBAAsB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAsFlD"}

package/dist/src/commands/login.js

@@ -0,0 +1,72 @@
+import { get } from "../lib/api.js";
+import { pollForToken, requestDeviceCode, sleep } from "../lib/auth.js";
+import { isLoggedIn, setToken } from "../lib/config.js";
+import { UserSchema } from "../lib/validators.js";
+export async function loginCommand() {
+    if (isLoggedIn()) {
+        console.log("You are already logged in. Use 'clocktopus logout' to log out first.");
+        return;
+    }
+    console.log("Starting device authorization...\n");
+    try {
+        const deviceCode = await requestDeviceCode();
+        const formattedCode = `${deviceCode.userCode.slice(0, 4)}-${deviceCode.userCode.slice(4)}`;
+        // Build URL with code pre-filled
+        const fullUrl = `${deviceCode.verificationUri}?user_code=${deviceCode.userCode}`;
+        console.log(`Open this link to authorize:\n`);
+        console.log(`  ${fullUrl}\n`);
+        console.log(`Or visit ${deviceCode.verificationUri} and enter code: ${formattedCode}\n`);
+        console.log("Waiting for authorization...");
+        let interval = deviceCode.interval;
+        const startTime = Date.now();
+        const timeoutMs = deviceCode.expiresIn * 1000;
+        while (Date.now() - startTime < timeoutMs) {
+            await sleep(interval * 1000);
+            const result = await pollForToken(deviceCode.deviceCode, interval);
+            switch (result.status) {
+                case "success":
+                    setToken(result.accessToken);
+                    // Fetch user info to display
+                    try {
+                        const data = await get("/api/auth/me");
+                        const response = UserSchema.parse(data);
+                        console.log(`\nLogged in as ${response.user.name} (${response.user.email})`);
+                    }
+                    catch {
+                        console.log("\nLogin successful!");
+                    }
+                    return;
+                case "pending":
+                    // Continue polling
+                    process.stdout.write(".");
+                    break;
+                case "slow_down":
+                    interval = result.newInterval;
+                    break;
+                case "denied":
+                    console.log(`\nAuthorization denied: ${result.message}`);
+                    process.exit(1);
+                    break;
+                case "expired":
+                    console.log(`\nAuthorization expired: ${result.message}`);
+                    process.exit(1);
+                    break;
+                case "error":
+                    console.log(`\nError: ${result.message}`);
+                    process.exit(1);
+                    break;
+            }
+        }
+        console.log("\nAuthorization timed out. Please try again.");
+        process.exit(1);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`\nLogin failed: ${error.message}`);
+        }
+        else {
+            console.error("\nLogin failed: Unknown error");
+        }
+        process.exit(1);
+    }
+}

package/dist/src/commands/logout.d.ts

@@ -0,0 +1,2 @@
+export declare function logoutCommand(): void;
+//# sourceMappingURL=logout.d.ts.map

package/dist/src/commands/logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../../src/commands/logout.ts"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,IAAI,IAAI,CAQpC"}

package/dist/src/commands/logout.js

@@ -0,0 +1,9 @@
+import { clearToken, isLoggedIn } from "../lib/config.js";
+export function logoutCommand() {
+    if (!isLoggedIn()) {
+        console.log("You are not logged in.");
+        return;
+    }
+    clearToken();
+    console.log("Logged out successfully.");
+}

package/dist/src/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+export declare function whoamiCommand(): Promise<void>;
+//# sourceMappingURL=whoami.d.ts.map

package/dist/src/commands/whoami.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whoami.d.ts","sourceRoot":"","sources":["../../../src/commands/whoami.ts"],"names":[],"mappings":"AAIA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAoBnD"}

package/dist/src/commands/whoami.js

@@ -0,0 +1,26 @@
+import { ApiError, get } from "../lib/api.js";
+import { isLoggedIn } from "../lib/config.js";
+import { UserSchema } from "../lib/validators.js";
+export async function whoamiCommand() {
+    if (!isLoggedIn()) {
+        console.log("Not logged in. Use 'clocktopus login' to authenticate.");
+        return;
+    }
+    try {
+        const data = await get("/api/auth/me");
+        const response = UserSchema.parse(data);
+        console.log(`Logged in as ${response.user.name} (${response.user.email})`);
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 401) {
+            console.log("Session expired. Please run 'clocktopus login' again.");
+        }
+        else if (error instanceof Error) {
+            console.error(`Failed to fetch user info: ${error.message}`);
+        }
+        else {
+            console.error("Failed to fetch user info: Unknown error");
+        }
+        process.exit(1);
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export declare function run(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAqEA,wBAAgB,GAAG,IAAI,IAAI,CAE1B"}

package/dist/src/index.js

@@ -0,0 +1,54 @@
+import { Command } from "commander";
+import { clockInCommand, clockOutCommand, clockStatusCommand, } from "./commands/clock.js";
+import { loginCommand } from "./commands/login.js";
+import { logoutCommand } from "./commands/logout.js";
+import { whoamiCommand } from "./commands/whoami.js";
+import { ENVIRONMENTS, setRuntimeEnvironment, } from "./lib/config.js";
+const program = new Command();
+program
+    .name("clocktopus")
+    .description("CLI for Clocktopus time tracking")
+    .version("0.1.0")
+    .option("-e, --env <environment>", "Use environment (dev or prod)")
+    .hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.env) {
+        if (!(opts.env in ENVIRONMENTS)) {
+            console.error(`Invalid environment: ${opts.env}. Use 'dev' or 'prod'.`);
+            process.exit(1);
+        }
+        setRuntimeEnvironment(opts.env);
+    }
+});
+program
+    .command("login")
+    .description("Authenticate with Clocktopus using device authorization")
+    .action(loginCommand);
+program
+    .command("logout")
+    .description("Log out and clear stored credentials")
+    .action(logoutCommand);
+program
+    .command("whoami")
+    .description("Display the currently logged in user")
+    .action(whoamiCommand);
+// Clock commands (subcommands)
+const clock = program
+    .command("clock")
+    .description("Record clock-in and clock-out signals");
+clock
+    .command("in")
+    .description("Record clock-in for today")
+    .action(clockInCommand);
+clock
+    .command("out")
+    .description("Record clock-out for today")
+    .action(clockOutCommand);
+clock
+    .command("status")
+    .description("Show clock signals for a specific date")
+    .option("-d, --date <date>", "Date in YYYY-MM-DD format (default: today)")
+    .action(clockStatusCommand);
+export function run() {
+    program.parse();
+}

package/dist/src/lib/api.d.ts

@@ -0,0 +1,16 @@
+type RequestOptions = {
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    body?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    authenticated?: boolean;
+};
+export declare class ApiError extends Error {
+    status: number;
+    statusText: string;
+    constructor(status: number, statusText: string, message?: string);
+}
+export declare function request<T>(path: string, options?: RequestOptions): Promise<T>;
+export declare function get<T>(path: string, authenticated?: boolean): Promise<T>;
+export declare function post<T>(path: string, body: Record<string, unknown>, authenticated?: boolean): Promise<T>;
+export {};
+//# sourceMappingURL=api.d.ts.map

package/dist/src/lib/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/lib/api.ts"],"names":[],"mappings":"AAEA,KAAK,cAAc,GAAG;IACpB,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,CAAC;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,qBAAa,QAAS,SAAQ,KAAK;IAExB,MAAM,EAAE,MAAM;IACd,UAAU,EAAE,MAAM;gBADlB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EACzB,OAAO,CAAC,EAAE,MAAM;CAKnB;AAED,wBAAsB,OAAO,CAAC,CAAC,EAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,CAAC,CAAC,CA6BZ;AAED,wBAAsB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,UAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAE3E;AAED,wBAAsB,IAAI,CAAC,CAAC,EAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,aAAa,UAAO,GACnB,OAAO,CAAC,CAAC,CAAC,CAEZ"}

package/dist/src/lib/api.js

@@ -0,0 +1,41 @@
+import { getApiUrl, getToken } from "./config.js";
+export class ApiError extends Error {
+    status;
+    statusText;
+    constructor(status, statusText, message) {
+        super(message || `API Error: ${status} ${statusText}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.name = "ApiError";
+    }
+}
+export async function request(path, options = {}) {
+    const { method = "GET", body, headers = {}, authenticated = true } = options;
+    const url = `${getApiUrl()}${path}`;
+    const requestHeaders = {
+        "Content-Type": "application/json",
+        ...headers,
+    };
+    if (authenticated) {
+        const token = getToken();
+        if (token) {
+            requestHeaders["Authorization"] = `Bearer ${token}`;
+        }
+    }
+    const response = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new ApiError(response.status, response.statusText, errorText);
+    }
+    return response.json();
+}
+export async function get(path, authenticated = true) {
+    return request(path, { method: "GET", authenticated });
+}
+export async function post(path, body, authenticated = true) {
+    return request(path, { method: "POST", body, authenticated });
+}

package/dist/src/lib/auth.d.ts

@@ -0,0 +1,30 @@
+export type DeviceCodeResult = {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete?: string;
+    expiresIn: number;
+    interval: number;
+};
+export declare function requestDeviceCode(): Promise<DeviceCodeResult>;
+export type PollResult = {
+    status: "success";
+    accessToken: string;
+} | {
+    status: "pending";
+} | {
+    status: "slow_down";
+    newInterval: number;
+} | {
+    status: "denied";
+    message: string;
+} | {
+    status: "expired";
+    message: string;
+} | {
+    status: "error";
+    message: string;
+};
+export declare function pollForToken(deviceCode: string, interval: number): Promise<PollResult>;
+export declare function sleep(ms: number): Promise<void>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/src/lib/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/lib/auth.ts"],"names":[],"mappings":"AA6BA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,gBAAgB,CAAC,CA4BnE;AAED,MAAM,MAAM,UAAU,GAClB;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAC5C;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACrC;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACtC;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC,wBAAsB,YAAY,CAChC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,CAAC,CA8CrB;AAED,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C"}

package/dist/src/lib/auth.js

@@ -0,0 +1,72 @@
+import { getApiUrl } from "./config.js";
+const CLIENT_ID = "clocktopus-cli";
+export async function requestDeviceCode() {
+    const url = `${getApiUrl()}/api/auth/device/code`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            client_id: CLIENT_ID,
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to request device code: ${errorText}`);
+    }
+    const data = (await response.json());
+    return {
+        deviceCode: data.device_code,
+        userCode: data.user_code,
+        verificationUri: data.verification_uri,
+        verificationUriComplete: data.verification_uri_complete,
+        expiresIn: data.expires_in,
+        interval: data.interval,
+    };
+}
+export async function pollForToken(deviceCode, interval) {
+    const url = `${getApiUrl()}/api/auth/device/token`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            client_id: CLIENT_ID,
+            device_code: deviceCode,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        }),
+    });
+    const data = (await response.json());
+    if ("access_token" in data) {
+        return { status: "success", accessToken: data.access_token };
+    }
+    if ("error" in data) {
+        switch (data.error) {
+            case "authorization_pending":
+                return { status: "pending" };
+            case "slow_down":
+                return { status: "slow_down", newInterval: interval + 5 };
+            case "access_denied":
+                return {
+                    status: "denied",
+                    message: data.error_description || "Access denied by user",
+                };
+            case "expired_token":
+                return {
+                    status: "expired",
+                    message: data.error_description || "Device code expired",
+                };
+            default:
+                return {
+                    status: "error",
+                    message: data.error_description || "Unknown error",
+                };
+        }
+    }
+    return { status: "error", message: "Unexpected response" };
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/src/lib/config.d.ts

@@ -0,0 +1,13 @@
+export declare const ENVIRONMENTS: {
+    readonly prod: "https://clocktopus.app";
+    readonly dev: "http://localhost:3000";
+};
+export type Environment = keyof typeof ENVIRONMENTS;
+export declare function setRuntimeEnvironment(env: Environment): void;
+export declare function getEnvironment(): Environment;
+export declare function getApiUrl(): string;
+export declare function getToken(): string | undefined;
+export declare function setToken(token: string): void;
+export declare function clearToken(): void;
+export declare function isLoggedIn(): boolean;
+//# sourceMappingURL=config.d.ts.map

package/dist/src/lib/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/lib/config.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;CAGf,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,YAAY,CAAC;AAapD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CAE5D;AAED,wBAAgB,cAAc,IAAI,WAAW,CAO5C;AAED,wBAAgB,SAAS,IAAI,MAAM,CASlC;AAED,wBAAgB,QAAQ,IAAI,MAAM,GAAG,SAAS,CAE7C;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE5C;AAED,wBAAgB,UAAU,IAAI,IAAI,CAEjC;AAED,wBAAgB,UAAU,IAAI,OAAO,CAEpC"}

package/dist/src/lib/config.js

@@ -0,0 +1,42 @@
+import Conf from "conf";
+export const ENVIRONMENTS = {
+    prod: "https://clocktopus.app",
+    dev: "http://localhost:3000",
+};
+const config = new Conf({
+    projectName: "clocktopus-cli",
+});
+// Runtime override from --env flag
+let runtimeEnv;
+export function setRuntimeEnvironment(env) {
+    runtimeEnv = env;
+}
+export function getEnvironment() {
+    // Check runtime flag
+    if (runtimeEnv) {
+        return runtimeEnv;
+    }
+    // Default to prod
+    return "prod";
+}
+export function getApiUrl() {
+    // 1. Check environment variable (highest priority)
+    if (process.env.CLOCKTOPUS_API_URL) {
+        return process.env.CLOCKTOPUS_API_URL;
+    }
+    // 2. Check runtime flag, then default to prod
+    const env = getEnvironment();
+    return ENVIRONMENTS[env];
+}
+export function getToken() {
+    return config.get("accessToken");
+}
+export function setToken(token) {
+    config.set("accessToken", token);
+}
+export function clearToken() {
+    config.delete("accessToken");
+}
+export function isLoggedIn() {
+    return !!getToken();
+}

package/dist/src/lib/validators.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const UserSchema: z.ZodObject<{
+    user: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodString;
+        avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type UserResponse = z.infer<typeof UserSchema>;
+export declare const DeviceCodeResponseSchema: z.ZodObject<{
+    device_code: z.ZodString;
+    user_code: z.ZodString;
+    verification_uri: z.ZodString;
+    verification_uri_complete: z.ZodOptional<z.ZodString>;
+    expires_in: z.ZodNumber;
+    interval: z.ZodNumber;
+}, z.core.$strip>;
+export type DeviceCodeResponse = z.infer<typeof DeviceCodeResponseSchema>;
+export declare const TokenResponseSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    token_type: z.ZodString;
+    expires_in: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const TokenErrorResponseSchema: z.ZodObject<{
+    error: z.ZodEnum<{
+        authorization_pending: "authorization_pending";
+        slow_down: "slow_down";
+        access_denied: "access_denied";
+        expired_token: "expired_token";
+        invalid_request: "invalid_request";
+    }>;
+    error_description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TokenResponse = z.infer<typeof TokenResponseSchema>;
+export type TokenErrorResponse = z.infer<typeof TokenErrorResponseSchema>;
+//# sourceMappingURL=validators.d.ts.map

package/dist/src/lib/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../src/lib/validators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;;;;;;;iBASrB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEtD,eAAO,MAAM,wBAAwB;;;;;;;iBAOnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,mBAAmB;;;;iBAI9B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;iBASnC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/src/lib/validators.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+export const UserSchema = z.object({
+    user: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string().email(),
+        avatarUrl: z.string().nullable().optional(),
+        createdAt: z.string().optional(),
+        updatedAt: z.string().optional(),
+    }),
+});
+export const DeviceCodeResponseSchema = z.object({
+    device_code: z.string(),
+    user_code: z.string(),
+    verification_uri: z.string(),
+    verification_uri_complete: z.string().optional(),
+    expires_in: z.number(),
+    interval: z.number(),
+});
+export const TokenResponseSchema = z.object({
+    access_token: z.string(),
+    token_type: z.string(),
+    expires_in: z.number().optional(),
+});
+export const TokenErrorResponseSchema = z.object({
+    error: z.enum([
+        "authorization_pending",
+        "slow_down",
+        "access_denied",
+        "expired_token",
+        "invalid_request",
+    ]),
+    error_description: z.string().optional(),
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@blastin-dev/clocktopus-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "clocktopus": "./dist/bin/clocktopus.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^13.0.0",
+    "conf": "^13.0.0",
+    "zod": "4.1.12"
+  },
+  "devDependencies": {
+    "@types/node": "22.15.3",
+    "eslint": "^9.28.0",
+    "typescript": "5.9.2",
+    "@repo/eslint-config": "0.0.0",
+    "@repo/typescript-config": "0.0.0",
+    "@repo/prettier-config": "0.1.0"
+  },
+  "prettier": "@repo/prettier-config",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "check-types": "tsc --noEmit",
+    "lint": "eslint",
+    "format": "prettier --check . --ignore-path ../../.gitignore",
+    "format:fix": "prettier --write . --ignore-path ../../.gitignore"
+  }
+}