@liebig-technology/clockodo-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1535 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command, CommanderError } from "commander";
+
+// src/commands/absences.ts
+import { styleText as styleText3 } from "util";
+import * as p from "@clack/prompts";
+import { AbsenceStatus, AbsenceType } from "clockodo";
+
+// src/lib/client.ts
+import { Clockodo } from "clockodo";
+
+// src/lib/config.ts
+import { chmodSync } from "fs";
+import Conf from "conf";
+
+// src/lib/errors.ts
+import { styleText } from "util";
+var ExitCode = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  INVALID_ARGS: 2,
+  EMPTY_RESULTS: 3,
+  AUTH_FAILURE: 4,
+  NOT_FOUND: 5,
+  FORBIDDEN: 6,
+  RATE_LIMITED: 7,
+  SERVER_ERROR: 8,
+  CONFIG_ERROR: 10
+};
+var CliError = class extends Error {
+  exitCode;
+  suggestion;
+  constructor(message, exitCode = ExitCode.GENERAL_ERROR, suggestion) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+    this.suggestion = suggestion;
+  }
+};
+function mapHttpError(statusCode) {
+  switch (true) {
+    case statusCode === 401:
+      return ExitCode.AUTH_FAILURE;
+    case statusCode === 403:
+      return ExitCode.FORBIDDEN;
+    case statusCode === 404:
+      return ExitCode.NOT_FOUND;
+    case statusCode === 429:
+      return ExitCode.RATE_LIMITED;
+    case statusCode >= 500:
+      return ExitCode.SERVER_ERROR;
+    default:
+      return ExitCode.GENERAL_ERROR;
+  }
+}
+function sanitize(input) {
+  return input.replace(
+    /([a-zA-Z]*(?:key|token|secret|password|auth|credential)[a-zA-Z]*)\s*[:=]\s*["']?[^\s"',}]+/gi,
+    "$1=***"
+  ).slice(0, 500);
+}
+function sanitizeStack(stack) {
+  return stack.split("\n").filter((line) => !/apiKey|authorization|Bearer|password|secret/i.test(line)).join("\n");
+}
+function extractApiError(error) {
+  if (typeof error === "object" && error !== null && "response" in error && typeof error.response === "object") {
+    const response = error.response;
+    const status = response.status ?? 0;
+    const data = response.data;
+    let detail;
+    if (typeof data === "object" && data !== null) {
+      const d = data;
+      if (typeof d.error === "object" && d.error !== null) {
+        const errObj = d.error;
+        detail = String(errObj.message ?? errObj.description ?? JSON.stringify(errObj));
+      } else if (d.message) {
+        detail = String(d.message);
+      } else {
+        detail = JSON.stringify(data);
+      }
+    } else if (typeof data === "string") {
+      detail = data;
+    }
+    return {
+      statusCode: status,
+      message: `API error (HTTP ${status})`,
+      detail: detail ? sanitize(detail) : void 0
+    };
+  }
+  return null;
+}
+function handleError(error, options) {
+  if (error instanceof CliError) {
+    if (options?.json) {
+      console.error(
+        JSON.stringify({
+          success: false,
+          error: {
+            code: error.exitCode,
+            message: error.message,
+            suggestion: error.suggestion
+          }
+        })
+      );
+    } else {
+      console.error(styleText("red", `Error: ${error.message}`));
+      if (error.suggestion) {
+        console.error(styleText("yellow", `Hint: ${error.suggestion}`));
+      }
+    }
+    process.exit(error.exitCode);
+  }
+  const apiError = extractApiError(error);
+  if (apiError) {
+    const exitCode = mapHttpError(apiError.statusCode);
+    if (options?.json) {
+      console.error(
+        JSON.stringify({
+          success: false,
+          error: {
+            code: exitCode,
+            httpStatus: apiError.statusCode,
+            message: apiError.message,
+            detail: apiError.detail
+          }
+        })
+      );
+    } else {
+      console.error(styleText("red", `Error: ${apiError.message}`));
+      if (apiError.detail) {
+        console.error(styleText("yellow", `Detail: ${apiError.detail}`));
+      }
+      if (options?.verbose && error instanceof Error && error.stack) {
+        console.error(styleText("dim", sanitizeStack(error.stack)));
+      }
+    }
+    process.exit(exitCode);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (options?.json) {
+    console.error(JSON.stringify({ success: false, error: { code: 1, message } }));
+  } else {
+    console.error(styleText("red", `Unexpected error: ${message}`));
+    if (options?.verbose && error instanceof Error && error.stack) {
+      console.error(styleText("dim", error.stack));
+    }
+  }
+  process.exit(ExitCode.GENERAL_ERROR);
+}
+
+// src/lib/config.ts
+var schema = {
+  email: { type: "string" },
+  apiKey: { type: "string" },
+  defaultCustomerId: { type: "number" },
+  defaultServiceId: { type: "number" },
+  defaultProjectId: { type: "number" },
+  timezone: { type: "string", default: "Europe/Berlin" }
+};
+var configInstance = null;
+function getStore() {
+  if (!configInstance) {
+    configInstance = new Conf({
+      projectName: "clockodo-cli",
+      schema
+    });
+    try {
+      chmodSync(configInstance.path, 384);
+    } catch {
+    }
+  }
+  return configInstance;
+}
+function getConfig() {
+  return getStore().store;
+}
+function getConfigValue(key) {
+  return getStore().get(key);
+}
+function setConfigValue(key, value) {
+  getStore().set(key, value);
+}
+function getConfigPath() {
+  return getStore().path;
+}
+function requireAuth() {
+  const email = getConfigValue("email") ?? process.env.CLOCKODO_EMAIL;
+  const apiKey = getConfigValue("apiKey") ?? process.env.CLOCKODO_API_KEY;
+  if (!email || !apiKey) {
+    throw new CliError(
+      "Authentication not configured.",
+      ExitCode.CONFIG_ERROR,
+      'Run "clockodo config set" to configure your API credentials, or set CLOCKODO_EMAIL and CLOCKODO_API_KEY environment variables.'
+    );
+  }
+  return { email, apiKey };
+}
+function maskSecret(secret) {
+  if (secret.length <= 4) return "****";
+  return `****${secret.slice(-4)}`;
+}
+
+// src/lib/client.ts
+var clientInstance = null;
+function getClient() {
+  if (!clientInstance) {
+    const { email, apiKey } = requireAuth();
+    clientInstance = new Clockodo({
+      client: {
+        name: "clockodo-cli",
+        email
+      },
+      authentication: {
+        user: email,
+        apiKey
+      }
+    });
+  }
+  return clientInstance;
+}
+
+// src/lib/output.ts
+import { styleText as styleText2 } from "util";
+import Table from "cli-table3";
+function resolveOutputMode(options) {
+  if (options.json) return "json";
+  if (options.plain) return "plain";
+  if (!process.stdout.isTTY && process.env.CLOCKODO_AUTO_JSON !== "0") {
+    return "json";
+  }
+  return "human";
+}
+function printResult(result, options) {
+  const mode = resolveOutputMode(options);
+  switch (mode) {
+    case "json":
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    case "plain":
+      console.log(JSON.stringify(result.data));
+      break;
+    case "human":
+      console.log(result.data);
+      break;
+  }
+}
+function printTable(headers, rows, options) {
+  const mode = resolveOutputMode(options ?? {});
+  if (mode === "json" || mode === "plain") {
+    const data = rows.map((row) => {
+      const obj = {};
+      for (let i = 0; i < headers.length; i++) {
+        const key = headers[i] ?? `col${i}`;
+        obj[key] = row[i] ?? "";
+      }
+      return obj;
+    });
+    console.log(JSON.stringify(mode === "json" ? { data } : data, null, mode === "json" ? 2 : 0));
+    return;
+  }
+  const table = new Table({
+    head: headers.map((h) => styleText2("bold", h)),
+    style: { head: [], border: [] }
+  });
+  for (const row of rows) {
+    table.push(row);
+  }
+  console.log(table.toString());
+}
+function printDetail(entries, options) {
+  const mode = resolveOutputMode(options ?? {});
+  if (mode === "json" || mode === "plain") {
+    const obj = {};
+    for (const [key, value] of entries) {
+      obj[key] = value;
+    }
+    console.log(
+      JSON.stringify(mode === "json" ? { data: obj } : obj, null, mode === "json" ? 2 : 0)
+    );
+    return;
+  }
+  const maxKeyLen = Math.max(...entries.map(([k]) => k.length));
+  for (const [key, value] of entries) {
+    const label = styleText2("bold", key.padEnd(maxKeyLen));
+    console.log(`  ${label}  ${value ?? styleText2("dim", "\u2014")}`);
+  }
+}
+function printSuccess(message) {
+  console.error(styleText2("green", `\u2713 ${message}`));
+}
+
+// src/lib/validate.ts
+function parseId(input, label = "ID") {
+  const num = Number(input);
+  if (!Number.isInteger(num) || num <= 0) {
+    throw new CliError(
+      `Invalid ${label}: "${input}". Must be a positive integer.`,
+      ExitCode.INVALID_ARGS
+    );
+  }
+  return num;
+}
+function parseIntStrict(value) {
+  const num = Number(value);
+  if (!Number.isInteger(num) || num <= 0) {
+    throw new CliError(`"${value}" is not a valid positive integer.`, ExitCode.INVALID_ARGS);
+  }
+  return num;
+}
+
+// src/commands/absences.ts
+function formatEnumLabel(name) {
+  return name.replace(/([A-Z])/g, " $1").trim();
+}
+function formatAbsenceType(type) {
+  if (type == null) return styleText3("dim", "\u2014");
+  const name = AbsenceType[type];
+  return name ? formatEnumLabel(name) : String(type);
+}
+function formatAbsenceStatus(status) {
+  const name = AbsenceStatus[status];
+  return name ? formatEnumLabel(name) : String(status);
+}
+function formatDaysOrHours(absence) {
+  if ("countHours" in absence && absence.countHours != null) {
+    return `${absence.countHours}h`;
+  }
+  if ("countDays" in absence && absence.countDays != null) {
+    return `${absence.countDays}d`;
+  }
+  return "\u2014";
+}
+function registerAbsencesCommands(program2) {
+  const absences = program2.command("absences").description("Manage absences");
+  absences.command("list", { isDefault: true }).description("List absences").option("--year <year>", "Filter by year (default: current year)", parseIntStrict).option("--user <id>", "Filter by user ID", parseIntStrict).option("--type <type>", "Filter by absence type", parseIntStrict).option("--status <status>", "Filter by absence status", parseIntStrict).action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const year = cmdOpts.year ?? (/* @__PURE__ */ new Date()).getFullYear();
+    const filter = { year: [year] };
+    if (cmdOpts.user) filter.usersId = [cmdOpts.user];
+    if (cmdOpts.type != null) filter.type = [cmdOpts.type];
+    if (cmdOpts.status != null) filter.status = [cmdOpts.status];
+    const result = await client.getAbsences({ filter });
+    const absenceList = result.data ?? [];
+    const mode = resolveOutputMode(opts);
+    if (absenceList.length === 0) {
+      if (mode !== "human") {
+        printResult({ data: [], meta: { count: 0 } }, opts);
+      } else {
+        console.log(styleText3("dim", "  No absences found."));
+      }
+      return;
+    }
+    if (mode !== "human") {
+      printResult({ data: absenceList, meta: { count: absenceList.length } }, opts);
+      return;
+    }
+    const rows = absenceList.map((a) => [
+      String(a.id),
+      String(a.usersId),
+      a.dateSince,
+      a.dateUntil,
+      formatAbsenceType(a.type),
+      formatAbsenceStatus(a.status),
+      formatDaysOrHours(a)
+    ]);
+    printTable(["ID", "User", "Since", "Until", "Type", "Status", "Days/Hours"], rows, opts);
+  });
+  absences.command("get <id>").description("Get details of a specific absence").action(async (id) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const result = await client.getAbsence({ id: parseId(id) });
+    const absence = result.data;
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: absence }, opts);
+      return;
+    }
+    printDetail(
+      [
+        ["ID", absence.id],
+        ["User ID", absence.usersId],
+        ["Since", absence.dateSince],
+        ["Until", absence.dateUntil],
+        ["Type", formatAbsenceType(absence.type)],
+        ["Status", formatAbsenceStatus(absence.status)],
+        ["Days/Hours", formatDaysOrHours(absence)],
+        ["Note", absence.note ?? null],
+        ["Public Note", absence.publicNote ?? null],
+        ["Date Enquired", absence.dateEnquired ?? null],
+        ["Date Approved", absence.dateApproved ?? null]
+      ],
+      opts
+    );
+  });
+  absences.command("create").description("Create an absence").requiredOption("--since <date>", "Start date (YYYY-MM-DD)").requiredOption("--type <type>", "Absence type (number)", parseIntStrict).option("--until <date>", "End date (YYYY-MM-DD)").option("--half-day", "Half-day absence").option("--sick-note", "Has sick note").option("--note <text>", "Private note").option("--public-note <text>", "Public note").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const params = {
+      dateSince: cmdOpts.since,
+      type: cmdOpts.type,
+      ...cmdOpts.until && { dateUntil: cmdOpts.until },
+      ...cmdOpts.halfDay && { halfDay: true },
+      ...cmdOpts.sickNote && { sickNote: true },
+      ...cmdOpts.note != null && { note: cmdOpts.note },
+      ...cmdOpts.publicNote != null && { publicNote: cmdOpts.publicNote }
+    };
+    const result = await client.addAbsence(params);
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: result.data }, opts);
+      return;
+    }
+    printSuccess(`Absence created (ID: ${result.data.id})`);
+    console.log(
+      `  ${result.data.dateSince} \u2014 ${result.data.dateUntil ?? result.data.dateSince} (${formatAbsenceType(result.data.type)})`
+    );
+  });
+  absences.command("update <id>").description("Update an absence").option("--since <date>", "New start date (YYYY-MM-DD)").option("--until <date>", "New end date (YYYY-MM-DD)").option("--type <type>", "New absence type (number)", parseIntStrict).option("--half-day", "Half-day absence").option("--no-half-day", "Not half-day").option("--sick-note", "Has sick note").option("--no-sick-note", "No sick note").option("--note <text>", "New private note").option("--public-note <text>", "New public note").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const params = { id: parseId(id) };
+    if (cmdOpts.since) params.dateSince = cmdOpts.since;
+    if (cmdOpts.until) params.dateUntil = cmdOpts.until;
+    if (cmdOpts.type != null) params.type = cmdOpts.type;
+    if (cmdOpts.halfDay !== void 0) params.halfDay = cmdOpts.halfDay;
+    if (cmdOpts.sickNote !== void 0) params.sickNote = cmdOpts.sickNote;
+    if (cmdOpts.note != null) params.note = cmdOpts.note;
+    if (cmdOpts.publicNote != null) params.publicNote = cmdOpts.publicNote;
+    const result = await client.editAbsence(params);
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: result.data }, opts);
+      return;
+    }
+    printSuccess(`Absence ${id} updated`);
+  });
+  absences.command("delete <id>").description("Delete an absence").option("-f, --force", "Skip confirmation").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    if (!cmdOpts.force && process.stdout.isTTY) {
+      const confirm3 = await p.confirm({
+        message: `Delete absence ${id}?`
+      });
+      if (!confirm3 || p.isCancel(confirm3)) return;
+    }
+    const absenceId = parseId(id);
+    await client.deleteAbsence({ id: absenceId });
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: { success: true, id: absenceId } }, opts);
+      return;
+    }
+    printSuccess(`Absence ${id} deleted`);
+  });
+}
+
+// src/commands/clock.ts
+import { Billability } from "clockodo";
+
+// src/lib/prompts.ts
+import * as p2 from "@clack/prompts";
+function shouldPrompt(opts, mode) {
+  if (opts.noInput) return false;
+  if (mode !== "human") return false;
+  if (!process.stdout.isTTY) return false;
+  return true;
+}
+async function selectCustomerProjectService() {
+  const client = getClient();
+  const customersResult = await client.getCustomers({ filter: { active: true } });
+  const customers = customersResult.data ?? [];
+  const defaultCustomerId = getConfigValue("defaultCustomerId");
+  const customersId = await p2.select({
+    message: "Select a customer",
+    options: customers.map((c) => ({ value: c.id, label: c.name })),
+    ...defaultCustomerId && { initialValue: defaultCustomerId }
+  });
+  if (p2.isCancel(customersId)) {
+    return null;
+  }
+  const projectsResult = await client.getProjects({
+    filter: { customersId, active: true }
+  });
+  const projects = projectsResult.data ?? [];
+  const defaultProjectId = getConfigValue("defaultProjectId");
+  const projectOptions = [
+    { value: 0, label: "(no project)" },
+    ...projects.map((proj) => ({ value: proj.id, label: proj.name }))
+  ];
+  const projectsId = await p2.select({
+    message: "Select a project",
+    options: projectOptions,
+    ...defaultProjectId && { initialValue: defaultProjectId }
+  });
+  if (p2.isCancel(projectsId)) {
+    return null;
+  }
+  const servicesResult = await client.getServices({ filter: { active: true } });
+  const services = servicesResult.data ?? [];
+  const defaultServiceId = getConfigValue("defaultServiceId");
+  const servicesId = await p2.select({
+    message: "Select a service",
+    options: services.map((s) => ({ value: s.id, label: s.name })),
+    ...defaultServiceId && { initialValue: defaultServiceId }
+  });
+  if (p2.isCancel(servicesId)) {
+    return null;
+  }
+  return {
+    customersId,
+    ...projectsId !== 0 && { projectsId },
+    servicesId
+  };
+}
+
+// src/lib/time.ts
+import {
+  addDays as _addDays,
+  endOfDay as _endOfDay,
+  endOfMonth as _endOfMonth,
+  endOfWeek as _endOfWeek,
+  startOfDay as _startOfDay,
+  startOfMonth as _startOfMonth,
+  startOfWeek as _startOfWeek,
+  differenceInSeconds,
+  format
+} from "date-fns";
+var startOfDay = _startOfDay;
+var endOfDay = _endOfDay;
+var startOfMonth = _startOfMonth;
+var endOfMonth = _endOfMonth;
+var addDays = _addDays;
+function startOfWeek(date) {
+  return _startOfWeek(date, { weekStartsOn: 1 });
+}
+function endOfWeek(date) {
+  return _endOfWeek(date, { weekStartsOn: 1 });
+}
+function formatDate(date) {
+  return format(date, "yyyy-MM-dd");
+}
+function formatTime(date) {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return format(d, "HH:mm");
+}
+function elapsedSince(isoString) {
+  return differenceInSeconds(/* @__PURE__ */ new Date(), new Date(isoString));
+}
+function formatDuration(seconds) {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  if (hours === 0) return `${minutes}m`;
+  if (minutes === 0) return `${hours}h`;
+  return `${hours}h ${minutes}m`;
+}
+function formatDecimalHours(seconds) {
+  return `${(seconds / 3600).toFixed(1)}h`;
+}
+function toClockodoDateTime(date) {
+  return date.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function parseDateTime(input) {
+  const now = /* @__PURE__ */ new Date();
+  switch (input.toLowerCase()) {
+    case "today":
+      return toClockodoDateTime(startOfDay(now));
+    case "yesterday":
+      return toClockodoDateTime(startOfDay(addDays(now, -1)));
+    case "tomorrow":
+      return toClockodoDateTime(startOfDay(addDays(now, 1)));
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(input)) {
+    return toClockodoDateTime(/* @__PURE__ */ new Date(`${input}T00:00:00`));
+  }
+  if (/^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}$/.test(input)) {
+    return toClockodoDateTime(/* @__PURE__ */ new Date(`${input.replace(" ", "T")}:00`));
+  }
+  if (/^\d{2}:\d{2}$/.test(input)) {
+    const parts = input.split(":").map(Number);
+    const hours = parts[0] ?? 0;
+    const minutes = parts[1] ?? 0;
+    const date = /* @__PURE__ */ new Date();
+    date.setHours(hours, minutes, 0, 0);
+    return toClockodoDateTime(date);
+  }
+  const parsed = new Date(input);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error(`Cannot parse date: "${input}"`);
+  }
+  return toClockodoDateTime(parsed);
+}
+
+// src/commands/clock.ts
+function registerClockCommands(program2) {
+  program2.command("start").description("Start time tracking").option("-c, --customer <id>", "Customer ID", parseIntStrict).option("-p, --project <id>", "Project ID", parseIntStrict).option("-s, --service <id>", "Service ID", parseIntStrict).option("-t, --text <description>", "Entry description").option("-b, --billable", "Mark as billable").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const mode = resolveOutputMode(opts);
+    const client = getClient();
+    let customersId = cmdOpts.customer ?? getConfigValue("defaultCustomerId");
+    let servicesId = cmdOpts.service ?? getConfigValue("defaultServiceId");
+    let projectsId = cmdOpts.project ?? getConfigValue("defaultProjectId");
+    if ((!customersId || !servicesId) && shouldPrompt(opts, mode)) {
+      const selection = await selectCustomerProjectService();
+      if (!selection) return;
+      customersId ??= selection.customersId;
+      servicesId ??= selection.servicesId;
+      projectsId ??= selection.projectsId;
+    }
+    if (!customersId || !servicesId) {
+      throw new CliError(
+        "Customer ID and Service ID are required to start tracking.",
+        ExitCode.INVALID_ARGS,
+        "Use --customer and --service flags, or set defaults with: clockodo config set"
+      );
+    }
+    const result = await client.startClock({
+      customersId,
+      servicesId,
+      ...projectsId && { projectsId },
+      ...cmdOpts.text && { text: cmdOpts.text },
+      ...cmdOpts.billable && { billable: Billability.Billable }
+    });
+    if (mode !== "human") {
+      printResult({ data: result.running }, opts);
+      return;
+    }
+    printSuccess("Clock started");
+    if (result.running.text) {
+      console.log(`  Description: ${result.running.text}`);
+    }
+    console.log(`  Started at: ${formatTime(result.running.timeSince)}`);
+  });
+  program2.command("stop").description("Stop time tracking").action(async () => {
+    const opts = program2.opts();
+    const client = getClient();
+    const clock = await client.getClock();
+    if (!clock.running) {
+      throw new CliError("No clock is currently running.", ExitCode.EMPTY_RESULTS);
+    }
+    const result = await client.stopClock({ entriesId: clock.running.id });
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: result.stopped }, opts);
+      return;
+    }
+    const duration = result.stopped.duration ?? elapsedSince(result.stopped.timeSince);
+    printSuccess(`Clock stopped (${formatDuration(duration)})`);
+    if (result.stopped.text) {
+      console.log(`  Description: ${result.stopped.text}`);
+    }
+  });
+}
+
+// src/commands/config.ts
+import * as p3 from "@clack/prompts";
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("Manage CLI configuration");
+  config.command("set").description("Configure API credentials interactively").action(async () => {
+    p3.intro("Clockodo CLI Configuration");
+    const email = await p3.text({
+      message: "Clockodo email address:",
+      placeholder: "you@example.com",
+      initialValue: getConfigValue("email") ?? "",
+      validate: (v) => !v || !v.includes("@") ? "Must be a valid email" : void 0
+    });
+    if (p3.isCancel(email)) return process.exit(0);
+    const apiKey = await p3.password({
+      message: "Clockodo API key:",
+      validate: (v) => !v || v.length < 5 ? "API key seems too short" : void 0
+    });
+    if (p3.isCancel(apiKey)) return process.exit(0);
+    const timezone = await p3.text({
+      message: "Default timezone:",
+      placeholder: "Europe/Berlin",
+      initialValue: getConfigValue("timezone") ?? "Europe/Berlin"
+    });
+    if (p3.isCancel(timezone)) return process.exit(0);
+    setConfigValue("email", email);
+    setConfigValue("apiKey", apiKey);
+    setConfigValue("timezone", timezone);
+    p3.outro(`Configuration saved to ${getConfigPath()}`);
+  });
+  config.command("show").description("Show current configuration (secrets masked)").action(() => {
+    const opts = program2.opts();
+    const cfg = getConfig();
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      const safeCfg = { ...cfg };
+      if (safeCfg.apiKey) safeCfg.apiKey = maskSecret(safeCfg.apiKey);
+      printResult({ data: safeCfg }, opts);
+      return;
+    }
+    printDetail(
+      [
+        ["Email", cfg.email ?? null],
+        ["API Key", cfg.apiKey ? maskSecret(cfg.apiKey) : null],
+        ["Timezone", cfg.timezone ?? null],
+        ["Default Customer ID", cfg.defaultCustomerId ?? null],
+        ["Default Service ID", cfg.defaultServiceId ?? null],
+        ["Default Project ID", cfg.defaultProjectId ?? null],
+        ["Config Path", getConfigPath()]
+      ],
+      opts
+    );
+  });
+  config.command("path").description("Print config file path").action(() => {
+    console.log(getConfigPath());
+  });
+}
+
+// src/commands/customers.ts
+function registerCustomersCommands(program2) {
+  const customers = program2.command("customers").description("Manage customers");
+  customers.command("list", { isDefault: true }).description("List customers").option("--active", "Show only active customers").option("--search <text>", "Search by name").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const filter = {};
+    if (cmdOpts.active) filter.active = true;
+    if (cmdOpts.search) filter.fulltext = cmdOpts.search;
+    const result = await client.getCustomers(
+      Object.keys(filter).length > 0 ? { filter } : void 0
+    );
+    const items = result.data ?? [];
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: items, meta: { count: items.length } }, opts);
+      return;
+    }
+    const rows = items.map((c) => [
+      String(c.id),
+      c.name,
+      c.number ?? "\u2014",
+      c.active ? "Yes" : "No"
+    ]);
+    printTable(["ID", "Name", "Number", "Active"], rows, opts);
+  });
+  customers.command("get <id>").description("Get customer details").action(async (id) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const result = await client.getCustomer({ id: parseId(id) });
+    const c = result.data;
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: c }, opts);
+      return;
+    }
+    printDetail(
+      [
+        ["ID", c.id],
+        ["Name", c.name],
+        ["Number", c.number ?? null],
+        ["Active", c.active],
+        ["Billable Default", c.billableDefault],
+        ["Note", c.note ?? null]
+      ],
+      opts
+    );
+  });
+}
+
+// src/commands/entries.ts
+import { styleText as styleText4 } from "util";
+import * as p4 from "@clack/prompts";
+import { getEntryDurationUntilNow, isTimeEntry } from "clockodo";
+function registerEntriesCommands(program2) {
+  const entries = program2.command("entries").description("Manage time entries");
+  entries.command("list", { isDefault: true }).description("List time entries").option("--since <date>", "Start date (default: today)", "today").option("--until <date>", "End date (default: today)").option("--customer <id>", "Filter by customer ID", parseIntStrict).option("--project <id>", "Filter by project ID", parseIntStrict).option("--service <id>", "Filter by service ID", parseIntStrict).option("--text <search>", "Filter by description text").option(
+    "-g, --group <field>",
+    "Group by: customer, project, service, text (shows summary table instead)"
+  ).action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const since = parseDateTime(cmdOpts.since);
+    const until = cmdOpts.until ? parseDateTime(cmdOpts.until) : toClockodoDateTime(endOfDay(/* @__PURE__ */ new Date()));
+    const filter = {};
+    if (cmdOpts.customer) filter.customersId = cmdOpts.customer;
+    if (cmdOpts.project) filter.projectsId = cmdOpts.project;
+    if (cmdOpts.service) filter.servicesId = cmdOpts.service;
+    if (cmdOpts.text) filter.text = cmdOpts.text;
+    const result = await client.getEntries({
+      timeSince: since,
+      timeUntil: until,
+      ...Object.keys(filter).length > 0 && { filter }
+    });
+    const entryList = result.entries ?? [];
+    const mode = resolveOutputMode(opts);
+    if (entryList.length === 0) {
+      if (mode !== "human") {
+        printResult({ data: [], meta: { count: 0, totalSeconds: 0 } }, opts);
+      } else {
+        console.log(styleText4("dim", "  No entries found for the given period."));
+      }
+      return;
+    }
+    const totalSeconds = entryList.reduce((sum, e) => sum + getEntryDurationUntilNow(e), 0);
+    if (cmdOpts.group) {
+      const groupKey = resolveGroupKey(cmdOpts.group);
+      const groups = groupEntries(entryList, groupKey);
+      if (mode !== "human") {
+        printResult(
+          {
+            data: {
+              groups,
+              total: { seconds: totalSeconds, formatted: formatDuration(totalSeconds) }
+            },
+            meta: { count: entryList.length }
+          },
+          opts
+        );
+        return;
+      }
+      const rows2 = groups.map((g) => [
+        g.key,
+        String(g.count),
+        formatDuration(g.seconds),
+        formatDecimalHours(g.seconds)
+      ]);
+      printTable(["Group", "Entries", "Duration", "Hours"], rows2, opts);
+      console.log();
+      console.log(
+        `  ${styleText4("bold", "Total")}: ${formatDuration(totalSeconds)} (${formatDecimalHours(totalSeconds)}) across ${entryList.length} entries`
+      );
+      console.log();
+      return;
+    }
+    if (mode !== "human") {
+      printResult(
+        {
+          data: entryList,
+          meta: { count: entryList.length, totalSeconds }
+        },
+        opts
+      );
+      return;
+    }
+    const rows = entryList.map((e) => [
+      String(e.id),
+      formatDate(new Date(e.timeSince)),
+      formatTime(e.timeSince),
+      isTimeEntry(e) && !e.timeUntil ? styleText4("green", "running") : formatTime(e.timeUntil ?? e.timeSince),
+      formatDuration(getEntryDurationUntilNow(e)),
+      e.text || styleText4("dim", "\u2014")
+    ]);
+    printTable(["ID", "Date", "Start", "End", "Duration", "Description"], rows, opts);
+    console.log();
+    console.log(
+      `  ${styleText4("bold", "Total")}: ${formatDuration(totalSeconds)} (${formatDecimalHours(totalSeconds)}) across ${entryList.length} entries`
+    );
+    console.log();
+  });
+  entries.command("get <id>").description("Get details of a specific entry").action(async (id) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const result = await client.getEntry({ id: parseId(id) });
+    const e = result.entry;
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: e }, opts);
+      return;
+    }
+    const timeUntilDisplay = isTimeEntry(e) && !e.timeUntil ? "running" : formatTime(e.timeUntil ?? e.timeSince);
+    const duration = getEntryDurationUntilNow(e);
+    printDetail(
+      [
+        ["ID", e.id],
+        ["Date", formatDate(new Date(e.timeSince))],
+        ["Start", formatTime(e.timeSince)],
+        ["End", timeUntilDisplay],
+        ["Duration", formatDuration(duration)],
+        ["Description", e.text ?? null],
+        ["Customer ID", e.customersId],
+        ["Project ID", e.projectsId ?? null],
+        ["Service ID", isTimeEntry(e) ? e.servicesId : null],
+        ["Billable", e.billable === 1 ? "Yes" : e.billable === 2 ? "Billed" : "No"]
+      ],
+      opts
+    );
+  });
+  entries.command("create").description("Create a time entry").requiredOption("--from <datetime>", "Start time (e.g., '2024-01-15 09:00' or '09:00')").requiredOption("--to <datetime>", "End time (e.g., '2024-01-15 17:00' or '17:00')").option("-c, --customer <id>", "Customer ID", parseIntStrict).option("-p, --project <id>", "Project ID", parseIntStrict).option("-s, --service <id>", "Service ID", parseIntStrict).option("-t, --text <description>", "Entry description").option("-b, --billable", "Mark as billable").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const mode = resolveOutputMode(opts);
+    const client = getClient();
+    let customersId = cmdOpts.customer ?? getConfigValue("defaultCustomerId");
+    let servicesId = cmdOpts.service ?? getConfigValue("defaultServiceId");
+    let projectsId = cmdOpts.project ?? getConfigValue("defaultProjectId");
+    if ((!customersId || !servicesId) && shouldPrompt(opts, mode)) {
+      const selection = await selectCustomerProjectService();
+      if (!selection) return;
+      customersId ??= selection.customersId;
+      servicesId ??= selection.servicesId;
+      projectsId ??= selection.projectsId;
+    }
+    if (!customersId || !servicesId) {
+      throw new CliError(
+        "Customer ID and Service ID are required.",
+        ExitCode.INVALID_ARGS,
+        "Use --customer and --service flags, or set defaults via: clockodo config set"
+      );
+    }
+    const result = await client.addEntry({
+      customersId,
+      servicesId,
+      billable: cmdOpts.billable ? 1 : 0,
+      timeSince: parseDateTime(cmdOpts.from),
+      timeUntil: parseDateTime(cmdOpts.to),
+      ...projectsId && { projectsId },
+      ...cmdOpts.text && { text: cmdOpts.text }
+    });
+    if (mode !== "human") {
+      printResult({ data: result.entry }, opts);
+      return;
+    }
+    const entry = result.entry;
+    const duration = getEntryDurationUntilNow(entry);
+    printSuccess(`Entry created (ID: ${entry.id})`);
+    console.log(
+      `  ${formatTime(entry.timeSince)} \u2014 ${entry.timeUntil ? formatTime(entry.timeUntil) : "?"} (${formatDuration(duration)})`
+    );
+  });
+  entries.command("update <id>").description("Update a time entry").option("--from <datetime>", "New start time").option("--to <datetime>", "New end time").option("-t, --text <description>", "New description").option("-b, --billable", "Mark as billable").option("--no-billable", "Mark as not billable").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const updates = { id: parseId(id) };
+    if (cmdOpts.from) updates.timeSince = parseDateTime(cmdOpts.from);
+    if (cmdOpts.to) updates.timeUntil = parseDateTime(cmdOpts.to);
+    if (cmdOpts.text !== void 0) updates.text = cmdOpts.text;
+    if (cmdOpts.billable !== void 0) updates.billable = cmdOpts.billable ? 1 : 0;
+    const result = await client.editEntry(updates);
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: result.entry }, opts);
+      return;
+    }
+    printSuccess(`Entry ${id} updated`);
+  });
+  entries.command("delete <id>").description("Delete a time entry").option("-f, --force", "Skip confirmation").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    if (!cmdOpts.force && process.stdout.isTTY) {
+      const confirm3 = await p4.confirm({
+        message: `Delete entry ${id}?`
+      });
+      if (!confirm3 || p4.isCancel(confirm3)) return;
+    }
+    const entryId = parseId(id);
+    await client.deleteEntry({ id: entryId });
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: { success: true, id: entryId } }, opts);
+      return;
+    }
+    printSuccess(`Entry ${id} deleted`);
+  });
+}
+function resolveGroupKey(input) {
+  const aliases = {
+    customer: "customersId",
+    customers: "customersId",
+    customers_id: "customersId",
+    project: "projectsId",
+    projects: "projectsId",
+    projects_id: "projectsId",
+    service: "servicesId",
+    services: "servicesId",
+    services_id: "servicesId",
+    text: "text",
+    description: "text"
+  };
+  const resolved = aliases[input.toLowerCase()];
+  if (!resolved) {
+    throw new CliError(
+      `Unknown group field: "${input}". Valid options: customer, project, service, text`,
+      ExitCode.INVALID_ARGS
+    );
+  }
+  return resolved;
+}
+function groupEntries(entries, key) {
+  const map = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    let groupValue;
+    if (key === "text") {
+      groupValue = e.text || "(no description)";
+    } else {
+      const val = e[key];
+      groupValue = val != null ? String(val) : "(none)";
+    }
+    const existing = map.get(groupValue);
+    const duration = getEntryDurationUntilNow(e);
+    if (existing) {
+      existing.count++;
+      existing.seconds += duration;
+    } else {
+      map.set(groupValue, { count: 1, seconds: duration });
+    }
+  }
+  return [...map.entries()].map(([k, v]) => ({ key: k, ...v })).sort((a, b) => b.seconds - a.seconds);
+}
+
+// src/commands/projects.ts
+function registerProjectsCommands(program2) {
+  const projects = program2.command("projects").description("Manage projects");
+  projects.command("list", { isDefault: true }).description("List projects").option("--customer <id>", "Filter by customer ID", parseIntStrict).option("--active", "Show only active projects").option("--search <text>", "Search by name").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const filter = {};
+    if (cmdOpts.customer) filter.customersId = cmdOpts.customer;
+    if (cmdOpts.active) filter.active = true;
+    if (cmdOpts.search) filter.fulltext = cmdOpts.search;
+    const result = await client.getProjects(
+      Object.keys(filter).length > 0 ? { filter } : void 0
+    );
+    const items = result.data ?? [];
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: items, meta: { count: items.length } }, opts);
+      return;
+    }
+    const rows = items.map((p5) => [
+      String(p5.id),
+      p5.name,
+      p5.number ?? "\u2014",
+      String(p5.customersId),
+      p5.active ? "Yes" : "No",
+      p5.completed ? "Yes" : "No"
+    ]);
+    printTable(["ID", "Name", "Number", "Customer", "Active", "Completed"], rows, opts);
+  });
+  projects.command("get <id>").description("Get project details").action(async (id) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const result = await client.getProject({ id: parseId(id) });
+    const p5 = result.data;
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: p5 }, opts);
+      return;
+    }
+    printDetail(
+      [
+        ["ID", p5.id],
+        ["Name", p5.name],
+        ["Number", p5.number ?? null],
+        ["Customer ID", p5.customersId],
+        ["Active", p5.active],
+        ["Completed", p5.completed],
+        ["Budget", p5.budget?.amount ?? null],
+        ["Budget Type", p5.budget?.monetary ? "Money" : "Hours"],
+        ["Note", p5.note ?? null]
+      ],
+      opts
+    );
+  });
+}
+
+// src/commands/report.ts
+import { styleText as styleText5 } from "util";
+async function runReport(program2, since, until, cmdOpts) {
+  const opts = program2.opts();
+  const client = getClient();
+  const grouping = [cmdOpts.group ?? "projects_id"];
+  const result = await client.getEntryGroups({
+    timeSince: toClockodoDateTime(since),
+    timeUntil: toClockodoDateTime(until),
+    grouping
+  });
+  const groups = result.groups ?? [];
+  const totalSeconds = groups.reduce((sum, g) => sum + (g.duration ?? 0), 0);
+  const mode = resolveOutputMode(opts);
+  if (mode !== "human") {
+    printResult(
+      {
+        data: {
+          period: { since: formatDate(since), until: formatDate(until) },
+          groups,
+          total: { seconds: totalSeconds, formatted: formatDuration(totalSeconds) }
+        }
+      },
+      opts
+    );
+    return;
+  }
+  console.log();
+  console.log(`  ${styleText5("bold", "Report")}: ${formatDate(since)} \u2014 ${formatDate(until)}`);
+  console.log();
+  if (groups.length === 0) {
+    console.log(styleText5("dim", "  No entries found for this period."));
+    return;
+  }
+  const rows = groups.map((g) => [
+    g.name || g.group || "Unknown",
+    formatDuration(g.duration ?? 0),
+    formatDecimalHours(g.duration ?? 0)
+  ]);
+  printTable(["Name", "Duration", "Hours"], rows, opts);
+  console.log();
+  console.log(
+    `  ${styleText5("bold", "Total")}: ${formatDuration(totalSeconds)} (${formatDecimalHours(totalSeconds)})`
+  );
+  console.log();
+}
+function registerReportCommands(program2) {
+  const report = program2.command("report").description("Aggregated time reports");
+  report.command("today", { isDefault: true }).description("Today's summary").option(
+    "-g, --group <field>",
+    "Group by: projects_id, customers_id, services_id",
+    "projects_id"
+  ).action(async (cmdOpts) => {
+    const now = /* @__PURE__ */ new Date();
+    await runReport(program2, startOfDay(now), endOfDay(now), cmdOpts);
+  });
+  report.command("week").description("This week's summary (Mon-Sun)").option("-g, --group <field>", "Group by field", "projects_id").action(async (cmdOpts) => {
+    const now = /* @__PURE__ */ new Date();
+    await runReport(program2, startOfWeek(now), endOfWeek(now), cmdOpts);
+  });
+  report.command("month").description("This month's summary").option("-g, --group <field>", "Group by field", "projects_id").action(async (cmdOpts) => {
+    const now = /* @__PURE__ */ new Date();
+    await runReport(program2, startOfMonth(now), endOfMonth(now), cmdOpts);
+  });
+  report.command("custom").description("Custom date range report").requiredOption("--since <date>", "Start date").requiredOption("--until <date>", "End date").option("-g, --group <field>", "Group by field", "projects_id").action(async (cmdOpts) => {
+    const since = new Date(parseDateTime(cmdOpts.since));
+    const until = new Date(parseDateTime(cmdOpts.until));
+    await runReport(program2, since, until, cmdOpts);
+  });
+}
+
+// src/commands/schema.ts
+function commandToSchema(cmd) {
+  const node = {
+    name: cmd.name(),
+    description: cmd.description()
+  };
+  const options = cmd.options.map((opt) => ({
+    flags: opt.flags,
+    description: opt.description,
+    required: opt.required,
+    ...opt.defaultValue !== void 0 && { defaultValue: opt.defaultValue }
+  }));
+  if (options.length > 0) {
+    node.options = options;
+  }
+  const subcommands = cmd.commands.map(commandToSchema);
+  if (subcommands.length > 0) {
+    node.subcommands = subcommands;
+  }
+  return node;
+}
+function registerSchemaCommand(program2) {
+  program2.command("schema").description("Output machine-readable CLI structure (for AI agents)").action(() => {
+    const schema2 = {
+      schemaVersion: 1,
+      cli: commandToSchema(program2)
+    };
+    console.log(JSON.stringify(schema2, null, 2));
+  });
+}
+
+// src/commands/services.ts
+function registerServicesCommands(program2) {
+  const services = program2.command("services").description("Manage services");
+  services.command("list", { isDefault: true }).description("List services").option("--active", "Show only active services").option("--search <text>", "Search by name").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const filter = {};
+    if (cmdOpts.active) filter.active = true;
+    if (cmdOpts.search) filter.fulltext = cmdOpts.search;
+    const result = await client.getServices(
+      Object.keys(filter).length > 0 ? { filter } : void 0
+    );
+    const items = result.data ?? [];
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: items, meta: { count: items.length } }, opts);
+      return;
+    }
+    const rows = items.map((s) => [
+      String(s.id),
+      s.name,
+      s.number ?? "\u2014",
+      s.active ? "Yes" : "No"
+    ]);
+    printTable(["ID", "Name", "Number", "Active"], rows, opts);
+  });
+  services.command("get <id>").description("Get service details").action(async (id) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const result = await client.getService({ id: parseId(id) });
+    const s = result.data;
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: s }, opts);
+      return;
+    }
+    printDetail(
+      [
+        ["ID", s.id],
+        ["Name", s.name],
+        ["Number", s.number ?? null],
+        ["Active", s.active],
+        ["Note", s.note ?? null]
+      ],
+      opts
+    );
+  });
+}
+
+// src/commands/status.ts
+import { styleText as styleText6 } from "util";
+import { isTimeEntry as isTimeEntry2 } from "clockodo";
+function registerStatusCommand(program2) {
+  program2.command("status").description("Show running clock and today's summary").action(async () => {
+    const opts = program2.opts();
+    const client = getClient();
+    const mode = resolveOutputMode(opts);
+    const now = /* @__PURE__ */ new Date();
+    const [clockResult, entriesResult] = await Promise.all([
+      client.getClock(),
+      client.getEntries({
+        timeSince: toClockodoDateTime(startOfDay(now)),
+        timeUntil: toClockodoDateTime(endOfDay(now))
+      })
+    ]);
+    const running = clockResult.running;
+    const entries = entriesResult.entries ?? [];
+    const totalSeconds = entries.reduce(
+      (sum, e) => sum + (isTimeEntry2(e) ? e.duration ?? 0 : 0),
+      0
+    );
+    const runningSeconds = running ? elapsedSince(running.timeSince) : 0;
+    if (mode !== "human") {
+      printResult(
+        {
+          data: {
+            running: running ? {
+              id: running.id,
+              text: running.text,
+              customersId: running.customersId,
+              projectsId: running.projectsId,
+              servicesId: running.servicesId,
+              timeSince: running.timeSince,
+              elapsed: runningSeconds
+            } : null,
+            today: {
+              entries: entries.length,
+              totalSeconds: totalSeconds + runningSeconds,
+              totalFormatted: formatDuration(totalSeconds + runningSeconds)
+            }
+          }
+        },
+        opts
+      );
+      return;
+    }
+    console.log();
+    if (running) {
+      const elapsed = formatDuration(runningSeconds);
+      const desc = running.text || styleText6("dim", "(no description)");
+      console.log(
+        `  ${styleText6("green", "\u25CF")} Running: ${styleText6("bold", desc)} (${elapsed})`
+      );
+      console.log(`    Started at ${formatTime(running.timeSince)}`);
+    } else {
+      console.log(`  ${styleText6("dim", "\u25CB")} No clock running`);
+    }
+    console.log();
+    console.log(
+      `  Today: ${styleText6("bold", formatDuration(totalSeconds + runningSeconds))} tracked across ${entries.length} entries`
+    );
+    console.log();
+  });
+}
+
+// src/commands/userreports.ts
+import { styleText as styleText7 } from "util";
+import { UserReportType } from "clockodo";
+var DETAIL_TYPE_MAP = {
+  months: UserReportType.YearAndMonths,
+  weeks: UserReportType.YearMonthsAndWeeks,
+  days: UserReportType.YearMonthsWeeksAndDays
+};
+function registerUserReportCommands(program2) {
+  program2.command("userreport").description("Show user report (overtime, holidays, absences) for a year").option("-u, --user <id>", "User ID (defaults to current user)", parseIntStrict).option("-y, --year <year>", "Year to report on (defaults to current year)", parseIntStrict).option("-d, --detail <level>", "Detail level: months, weeks, or days").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const usersId = cmdOpts.user ?? (await client.getMe()).data.id;
+    const year = cmdOpts.year ?? (/* @__PURE__ */ new Date()).getFullYear();
+    let type;
+    if (cmdOpts.detail) {
+      type = DETAIL_TYPE_MAP[cmdOpts.detail];
+      if (type === void 0) {
+        throw new CliError(
+          `Unknown detail level: "${cmdOpts.detail}". Valid options: months, weeks, days`,
+          ExitCode.INVALID_ARGS
+        );
+      }
+    }
+    const result = await client.getUserReport({
+      usersId,
+      year,
+      ...type !== void 0 && { type }
+    });
+    const report = result.userreport;
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: report }, opts);
+      return;
+    }
+    const sumTarget = report.sumTarget ?? 0;
+    const holidaysRemaining = report.holidaysQuota + report.holidaysCarry - report.sumAbsence.regularHolidays;
+    console.log();
+    console.log(`  ${styleText7("bold", "User Report")}: ${report.usersName} (${year})`);
+    console.log();
+    printDetail(
+      [
+        ["Name", report.usersName],
+        ["Year", year],
+        ["Target hours", formatDuration(sumTarget)],
+        ["Worked hours", formatDuration(report.sumHours)],
+        ["Overtime", formatDuration(report.diff)],
+        [
+          "Holidays",
+          `${holidaysRemaining} remaining (${report.holidaysQuota} quota + ${report.holidaysCarry} carry - ${report.sumAbsence.regularHolidays} used)`
+        ],
+        ["Sick days", report.sumAbsence.sickSelf],
+        ["Home office days", report.sumAbsence.homeOffice]
+      ],
+      opts
+    );
+    console.log();
+  });
+  program2.command("userreports").description("Show user reports for all users in a year").option("-y, --year <year>", "Year to report on (defaults to current year)", parseIntStrict).action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const year = cmdOpts.year ?? (/* @__PURE__ */ new Date()).getFullYear();
+    const result = await client.getUserReports({ year });
+    const reports = result.userreports ?? [];
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: reports, meta: { count: reports.length } }, opts);
+      return;
+    }
+    console.log();
+    console.log(`  ${styleText7("bold", "User Reports")} (${year}): ${reports.length} users`);
+    console.log();
+    if (reports.length === 0) {
+      console.log(styleText7("dim", "  No reports found."));
+      return;
+    }
+    const rows = reports.map((r) => {
+      const sumTarget = r.sumTarget ?? 0;
+      const holidaysRemaining = r.holidaysQuota + r.holidaysCarry - r.sumAbsence.regularHolidays;
+      return [
+        r.usersName,
+        formatDuration(sumTarget),
+        formatDuration(r.sumHours),
+        formatDuration(r.diff),
+        String(holidaysRemaining),
+        String(r.sumAbsence.sickSelf)
+      ];
+    });
+    printTable(
+      ["Name", "Target", "Worked", "Overtime", "Holidays Remaining", "Sick Days"],
+      rows,
+      opts
+    );
+    console.log();
+  });
+}
+
+// src/commands/users.ts
+function registerUsersCommands(program2) {
+  const users = program2.command("users").description("User management");
+  users.command("me").description("Show current user info").action(async () => {
+    const opts = program2.opts();
+    const client = getClient();
+    const result = await client.getMe();
+    const u = result.data;
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: u }, opts);
+      return;
+    }
+    printDetail(
+      [
+        ["ID", u.id],
+        ["Name", u.name],
+        ["Email", u.email],
+        ["Role", u.role],
+        ["Active", u.active]
+      ],
+      opts
+    );
+  });
+  users.command("list").description("List all users").action(async () => {
+    const opts = program2.opts();
+    const client = getClient();
+    const result = await client.getUsers();
+    const items = result.data ?? [];
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult({ data: items, meta: { count: items.length } }, opts);
+      return;
+    }
+    const rows = items.map((u) => [
+      String(u.id),
+      u.name,
+      u.email,
+      u.role ?? "\u2014",
+      u.active ? "Yes" : "No"
+    ]);
+    printTable(["ID", "Name", "Email", "Role", "Active"], rows, opts);
+  });
+}
+
+// src/commands/worktimes.ts
+import { styleText as styleText8 } from "util";
+function computeDayStats(day) {
+  if (day.intervals.length === 0) {
+    return {
+      startTime: null,
+      endTime: null,
+      totalSeconds: 0,
+      breakSeconds: 0,
+      intervalCount: 0
+    };
+  }
+  const first = day.intervals[0];
+  const last = day.intervals[day.intervals.length - 1];
+  let totalSeconds = 0;
+  let breakSeconds = 0;
+  let prevEnd = null;
+  for (const interval of day.intervals) {
+    const start = new Date(interval.timeSince).getTime();
+    const end = interval.timeUntil ? new Date(interval.timeUntil).getTime() : Date.now();
+    totalSeconds += (end - start) / 1e3;
+    if (prevEnd !== null) {
+      breakSeconds += (start - prevEnd) / 1e3;
+    }
+    prevEnd = end;
+  }
+  return {
+    startTime: first?.timeSince ?? null,
+    endTime: last?.timeUntil ?? null,
+    totalSeconds,
+    breakSeconds,
+    intervalCount: day.intervals.length
+  };
+}
+function registerWorktimesCommands(program2) {
+  program2.command("worktimes").description("Show work time intervals").option("--since <date>", "Start date (default: Monday of current week)").option("--until <date>", "End date (default: Sunday of current week)").option("--user <id>", "Filter by user ID", parseIntStrict).action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient();
+    const now = /* @__PURE__ */ new Date();
+    const dateSince = cmdOpts.since ?? formatDate(startOfWeek(now));
+    const dateUntil = cmdOpts.until ?? formatDate(endOfWeek(now));
+    const result = await client.getWorkTimes({
+      dateSince,
+      dateUntil,
+      ...cmdOpts.user && { usersId: cmdOpts.user }
+    });
+    const workTimeDays = result.workTimeDays ?? [];
+    const daysWithStats = workTimeDays.map((day) => ({
+      ...day,
+      stats: computeDayStats(day)
+    }));
+    const totalSeconds = daysWithStats.reduce((sum, d) => sum + d.stats.totalSeconds, 0);
+    const mode = resolveOutputMode(opts);
+    if (mode !== "human") {
+      printResult(
+        {
+          data: daysWithStats,
+          meta: { count: daysWithStats.length, totalSeconds }
+        },
+        opts
+      );
+      return;
+    }
+    console.log();
+    console.log(`  ${styleText8("bold", "Work Times")}: ${dateSince} \u2014 ${dateUntil}`);
+    console.log();
+    if (daysWithStats.length === 0) {
+      console.log(styleText8("dim", "  No work time data found for this period."));
+      return;
+    }
+    const rows = daysWithStats.map((day) => {
+      const stats = day.stats;
+      return [
+        String(day.date),
+        stats.startTime ? formatTime(stats.startTime) : "-",
+        stats.endTime ? formatTime(stats.endTime) : "-",
+        formatDuration(stats.totalSeconds),
+        stats.breakSeconds > 0 ? formatDuration(stats.breakSeconds) : "-",
+        String(stats.intervalCount)
+      ];
+    });
+    printTable(["Date", "Start", "End", "Hours", "Break", "Intervals"], rows, opts);
+    console.log();
+    console.log(`  ${styleText8("bold", "Total")}: ${formatDuration(totalSeconds)}`);
+    console.log();
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("clockodo").description("AI-friendly CLI for the Clockodo time tracking API").version("0.1.0").option("-j, --json", "Output as JSON").option("-p, --plain", "Output as plain text (no colors)").option("--no-color", "Disable colors").option("--no-input", "Disable interactive prompts").option("-v, --verbose", "Verbose output");
+registerConfigCommands(program);
+registerStatusCommand(program);
+registerClockCommands(program);
+registerEntriesCommands(program);
+registerCustomersCommands(program);
+registerProjectsCommands(program);
+registerServicesCommands(program);
+registerUsersCommands(program);
+registerReportCommands(program);
+registerAbsencesCommands(program);
+registerWorktimesCommands(program);
+registerUserReportCommands(program);
+registerSchemaCommand(program);
+program.exitOverride();
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      process.exit(error.exitCode);
+    }
+    const opts = program.opts();
+    handleError(error, opts);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map