@srafis/zsync 0.1.3 → 0.1.5

package/README.md

@@ -4,7 +4,7 @@ Keep tracking time in Clockify and sync your entries to Zoho People when you're
 
 zsync is a terminal app for people who want to keep using their personal Clockify workspace while maintaining their work timesheet in Zoho. It offers another way to log time alongside the Zoho Chrome extension: use the Clockify interface you already know, then choose which completed entries to copy across.
 
-Each run lets you select a period, pick entries, map Clockify projects to Zoho jobs, and confirm the sync. Nothing runs in the background.
+Each run lets you select a period, pick new, changed or deleted entries, map Clockify projects to Zoho jobs, and confirm the sync. Nothing runs in the background.
 
 ## Get started
 
@@ -90,11 +90,11 @@ bun run dev
 1. Choose Today, Yesterday, This week, Last week, or This month.
 2. Use the arrow keys to move through entries and Space to select or deselect them. Press Enter to continue.
 3. Choose a Zoho job for each unmapped Clockify project. zsync remembers your choices. An exact, unique match with a Zoho project or job name is selected automatically.
-4. Review your selection and submit the final Yes/No prompt. Yes is selected initially, but you still have to confirm it.
+4. Review the create/update/delete counts and submit the final Yes/No prompt. It defaults to No when deletions are selected, otherwise Yes.
 
-New entries start selected. Previously synced entries, including changed ones, start unselected. Select a changed entry to update its existing Zoho log. An unchanged entry is skipped.
+New, changed and deleted entries start selected. Changed rows show a yellow `[updated]` label before their description and update the existing Zoho log when confirmed. Unchanged synced entries start unselected and are skipped if selected.
 
-Choosing No or cancelling before the sync makes no time-log changes in Zoho. Job mappings may already have been saved locally.
+The final confirmation lists how many Zoho logs will be created, updated and deleted. It defaults to No if any deletions are selected. Cancelling before confirmation makes no Zoho changes. Job mappings may already have been saved locally.
 
 ## What gets copied
 
@@ -115,17 +115,27 @@ zsync creates duration-based logs. The original start and end timestamps are ret
 
 ## Running sync again
 
-zsync writes readable YAML metadata in the Zoho log's Description and recognizes entries by a sync marker derived from their Clockify ID. Existing JSON descriptions are still recognized; selecting one updates it to YAML. Keep that metadata intact so later runs can find the existing log. Recognition works across machines and OAuth clients without a local sync ledger.
+zsync writes readable YAML metadata in the Zoho log's Description and recognizes entries by a sync marker derived from their Clockify ID. Comparison includes the exact metadata text, excluding the sync marker. Differences in the log fields or metadata appear as updates. Keep that metadata intact so later runs can find the existing log. Recognition works across machines and OAuth clients without a local sync ledger.
 
-Selecting a changed entry overwrites differing Zoho fields with the Clockify values. Older marker-only logs are also recognized within their original account scope; selecting them updates their Work Item and metadata to the current format.
+Selecting a changed entry overwrites differing Zoho fields with the Clockify values.
 
 A manually entered Zoho log without sync metadata is not treated as a match, even if its title and duration are identical. Deleting a synced Zoho log makes its Clockify entry appear new again.
 
 Before writing, zsync checks for changes in both services. It verifies each write afterward and attempts to reconcile an uncertain response without blindly repeating the write. If an entry remains `uncertain`, inspect it in Zoho before retrying. Failures are reported per entry, and failed or uncertain results produce a nonzero exit status. A run can partially succeed.
 
+## Review deleted entries
+
+Before showing the combined sync table, zsync checks synced Zoho logs dated within your selected period. For each eligible log, it looks up the Clockify entry by ID, regardless of date. A moved entry or running timer that still exists is not offered for deletion. For a Clockify workspace-mismatch response, zsync checks the complete paginated user entry list without date filters. Only confirmed absence becomes a deletion candidate. Authentication errors and other failed lookups stop discovery rather than counting as deletions.
+
+If Clockify confirms an entry is absent, its Zoho log appears in the same checkbox table as new and changed entries, labelled with a red `[deleted]` before its description. Deletion rows start checked. Deselect any logs you want to keep and review the create/update/delete counts at the final confirmation. The app rechecks each selected log and its Clockify source before deleting, then verifies that the Zoho log is gone. Deletions are not retried automatically after an uncertain response.
+
+Logs need Clockify source metadata, an entry ID and a valid sync marker. Explicit workspace/user IDs must match your configuration. Deletion checks use the configured Clockify workspace. Use the same workspace for tracking and syncing. Manual logs and locked logs are excluded.
+
+Deletion review also runs when the selected period has no completed Clockify entries. After confirmation, the app applies creations and updates, then deletions. A failure does not roll back successful operations. A deletion failure is reported per entry and produces a nonzero exit status.
+
 ## Limits to know
 
-- Sync runs one way, from Clockify to Zoho. It does not copy Zoho edits back, delete Zoho logs, or submit or approve timesheets.
+- Sync runs one way, from Clockify to Zoho. It does not copy Zoho edits back or submit or approve timesheets.
 - Locked or approved logs and multiple Zoho logs identifying the same Clockify entry are conflicts. Resolve them or deselect those entries before continuing.
 - Lookup covers the selected entries' date span. If you move a previously synced entry to a date outside that span, reconcile its old Zoho log before syncing again.
 - Run one sync at a time. There is no protection against simultaneous runs across terminals or machines.

package/dist/zsync.js

@@ -44,6 +44,16 @@ var __esm = (fn, res, err) => () => {
   return res;
 };
 
+// src/types.ts
+function accountScope(config) {
+  return JSON.stringify([config.clockifyWorkspaceId, config.clockifyUserId, config.zohoRegion, config.zohoClientId, config.zohoEmployeeId]);
+}
+var RejectedWriteError;
+var init_types = __esm(() => {
+  RejectedWriteError = class RejectedWriteError extends Error {
+  };
+});
+
 // node_modules/sisteransi/src/index.js
 var require_src = __commonJS(function(exports, module) {
   var ESC = "\x1B";
@@ -102,16 +112,6 @@ var require_src = __commonJS(function(exports, module) {
   module.exports = { cursor, scroll, erase, beep };
 });
 
-// src/types.ts
-function accountScope(config) {
-  return JSON.stringify([config.clockifyWorkspaceId, config.clockifyUserId, config.zohoRegion, config.zohoClientId, config.zohoEmployeeId]);
-}
-var RejectedWriteError;
-var init_types = __esm(() => {
-  RejectedWriteError = class RejectedWriteError extends Error {
-  };
-});
-
 // node_modules/jsbi/dist/jsbi-cjs.js
 var require_jsbi_cjs = __commonJS(function(exports, module) {
   class JSBI extends Array {
@@ -5701,7 +5701,7 @@ function dateRange(name, zone, now = qi.Now.instant().toString()) {
     lastDate: qi.PlainDate.compare(first, end.subtract({ nanoseconds: 1 }).toZonedDateTimeISO(zone).toPlainDate()) > 0 ? first.toString() : end.subtract({ nanoseconds: 1 }).toZonedDateTimeISO(zone).toPlainDate().toString()
   };
 }
-function entryInput(entry, jobId, employeeId, zone) {
+function entryInput(entry, jobId, employeeId, zone, source) {
   const start = qi.Instant.from(entry.start);
   const end = qi.Instant.from(entry.end);
   const seconds = Number(end.epochNanoseconds - start.epochNanoseconds) / 1e9;
@@ -5719,6 +5719,7 @@ function entryInput(entry, jobId, employeeId, zone) {
     workItem: entry.description,
     description: [
       "source: Clockify",
+      ...source ? [`workspaceId: ${JSON.stringify(source.workspaceId)}`, `userId: ${JSON.stringify(source.userId)}`] : [],
       `entryId: ${JSON.stringify(entry.id)}`,
       "project:",
       `  id: ${JSON.stringify(entry.projectId)}`,
@@ -5755,7 +5756,7 @@ var init_dates = __esm(() => {
 });
 
 // src/sync.ts
-import { createHash as createHash2, randomUUID } from "node:crypto";
+import { createHash as createHash3, randomUUID } from "node:crypto";
 import { open, mkdir as mkdir2, readFile as readFile2, rename as rename2, unlink } from "node:fs/promises";
 import { join as join3 } from "node:path";
 function isRecord2(value) {
@@ -5791,7 +5792,7 @@ function assertKey(key) {
     throw new Error("Sync entry keys must be non-empty strings");
 }
 function markerFor(scope, key) {
-  return createHash2("sha256").update(scope).update("\x00").update(key).digest("hex");
+  return createHash3("sha256").update(scope).update("\x00").update(key).digest("hex");
 }
 function markerIn(description) {
   return description.match(MARKER_RE)?.[1];
@@ -5873,7 +5874,7 @@ function contextFor(store) {
 }
 async function openStore(directory, scope) {
   await mkdir2(directory, { recursive: true, mode: 448 });
-  const hash = createHash2("sha256").update(scope).digest("hex").slice(0, 32);
+  const hash = createHash3("sha256").update(scope).digest("hex").slice(0, 32);
   const path = join3(directory, `zsync-preferences-${hash}.json`);
   let mappings = {};
   for (const candidate of [path, join3(directory, `zsync-state-${hash}.json`)]) {
@@ -6148,6 +6149,9 @@ async function demoServices() {
   entries.push({ ...entries[0], id: "demo-entry-2", description: "Already synced example", tags: [] });
   const logs = new Map;
   const zoho = {
+    async deleteLog(id) {
+      logs.delete(id);
+    },
     async validate() {},
     async listJobs() {
       return [{ id: "demo-job", name: "Example project" }];
@@ -6170,14 +6174,18 @@ async function demoServices() {
   };
   const store = await openStore(stateDir, accountScope(config));
   try {
-    await commit(store, zoho, await prepare(store, zoho, [{ key: entries[1].id, input: entryInput(entries[1], "demo-job", "demo", "UTC") }]));
+    await commit(store, zoho, await prepare(store, zoho, [{ key: entries[1].id, input: entryInput(entries[1], "demo-job", "demo", "UTC", { workspaceId: "demo", userId: "demo" }) }]));
+    const deleted = { ...entries[0], id: "demo-deleted", description: "Deleted Clockify example" };
+    await commit(store, zoho, await prepare(store, zoho, [{ key: deleted.id, input: entryInput(deleted, "demo-job", "demo", "UTC", { workspaceId: "demo", userId: "demo" }) }]));
   } finally {
     await store.close();
   }
   return {
     config,
     zoho,
-    clockify: { async validate() {}, async listEntries() {
+    clockify: { async entryExists(id) {
+      return entries.some((entry) => entry.id === id);
+    }, async validate() {}, async listEntries() {
       return entries.map((entry) => ({ ...entry }));
     } },
     cleanup: () => rm(stateDir, { recursive: true, force: true })
@@ -6190,6 +6198,64 @@ var init_demo = __esm(() => {
   init_dates();
 });
 
+// src/deletions.ts
+init_types();
+import { createHash } from "node:crypto";
+function field(description, name) {
+  try {
+    const metadata = JSON.parse(description.replace(/\n\n\[zsync-source:[a-f0-9]{64}\]$/, ""));
+    return typeof metadata?.[name] === "string" ? metadata[name] : undefined;
+  } catch {}
+  if (name === "source" && description.startsWith(`source: Clockify
+`))
+    return "Clockify";
+  const lines = description.split(`
+`).filter((line) => line.startsWith(`${name}: `));
+  if (lines.length !== 1)
+    return;
+  try {
+    const value = JSON.parse(lines[0].slice(name.length + 2));
+    return typeof value === "string" && value ? value : undefined;
+  } catch {
+    return;
+  }
+}
+async function findDeletions(logs, source, config) {
+  const candidates = [];
+  for (const log of logs) {
+    if (log.locked || log.employeeId !== config.zohoEmployeeId || field(log.description, "source") !== "Clockify" || field(log.description, "workspaceId") !== undefined && field(log.description, "workspaceId") !== config.clockifyWorkspaceId || field(log.description, "userId") !== undefined && field(log.description, "userId") !== config.clockifyUserId)
+      continue;
+    const entryId = field(log.description, "entryId");
+    if (!entryId)
+      continue;
+    const markers = ["", accountScope(config)].map((scope) => createHash("sha256").update(scope).update("\x00").update(entryId).digest("hex"));
+    if (!markers.some((marker) => log.description.endsWith(`
+
+[zsync-source:${marker}]`)))
+      continue;
+    if (await source.entryExists(entryId) === false)
+      candidates.push({ log: { ...log }, entryId });
+  }
+  return candidates;
+}
+async function deleteConfirmed(item, source, destination) {
+  const current = await destination.getLog(item.log.id);
+  if (!current)
+    throw new Error("Zoho entry is already absent; refresh the list.");
+  if (current.locked || JSON.stringify(current) !== JSON.stringify(item.log))
+    throw new Error("Zoho entry changed after review; refresh the list.");
+  if (await source.entryExists(item.entryId) !== false)
+    throw new Error("Clockify entry exists or its deletion cannot be confirmed; deletion cancelled.");
+  let failure;
+  try {
+    await destination.deleteLog(item.log.id);
+  } catch (error) {
+    failure = error;
+  }
+  if (await destination.getLog(item.log.id) !== null)
+    throw failure ?? new Error("Deletion was not verified. Check Zoho before retrying.");
+}
+
 // node_modules/@clack/core/dist/index.mjs
 import { styleText } from "node:util";
 import { stdout, stdin } from "node:process";
@@ -7318,7 +7384,7 @@ ${i}
 }).prompt();
 
 // src/auth.ts
-import { createHash, randomBytes } from "node:crypto";
+import { createHash as createHash2, randomBytes } from "node:crypto";
 import { mkdir, readFile, writeFile, rename } from "node:fs/promises";
 import { join as join2 } from "node:path";
 import { spawn } from "node:child_process";
@@ -7375,6 +7441,10 @@ function responseMessage(body) {
   const parts = [];
   if (typeof response.message === "string")
     parts.push(response.message);
+  if (typeof response.error === "string")
+    parts.push(response.error);
+  if (typeof response.error_description === "string")
+    parts.push(response.error_description);
   if (Array.isArray(response.errors)) {
     for (const error of response.errors) {
       if (!isRecord(error))
@@ -7568,7 +7638,31 @@ function createClockify(config, options = {}) {
     }
     return entries;
   }
-  return { validate, listEntries };
+  async function entryExists(id) {
+    if (!id)
+      throw new Error("Clockify entry ID is required");
+    const path = `/workspaces/${encodeURIComponent(config.clockifyWorkspaceId)}/time-entries/${encodeURIComponent(id)}`;
+    const result = await fetchRaw(fetcher, `${CLOCKIFY_API}${path}`, { headers: { "X-Api-Key": config.clockifyKey } }, "Clockify entry lookup", [config.clockifyKey], options.timeoutMs ?? REQUEST_TIMEOUT_MS, false);
+    if (result.status === 400 && isRecord(result.body) && result.body.message === "Time entry doesn't belong to Workspace") {
+      await validate();
+      const entries = await clockifyPages(fetcher, config, `/workspaces/${encodeURIComponent(config.clockifyWorkspaceId)}/user/${encodeURIComponent(config.clockifyUserId)}/time-entries`, {}, options);
+      const ids = entries.map((entry) => {
+        if (entry.userId !== undefined && String(entry.userId) !== config.clockifyUserId)
+          throw new Error("Clockify returned an entry for a different user");
+        return valueId(entry.id, "id", "Clockify entry");
+      });
+      return ids.includes(id);
+    }
+    if (result.status === 404) {
+      await validate();
+      return false;
+    }
+    const body = requireHttp(result, "Clockify entry lookup", [config.clockifyKey]);
+    if (!isRecord(body) || body.id !== id)
+      throw new Error("Clockify entry lookup returned an unexpected entry");
+    return true;
+  }
+  return { validate, listEntries, entryExists };
 }
 function validDate(value, name) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
@@ -7747,6 +7841,8 @@ function createZoho(config, options = {}) {
     const body = requireHttp(result, "Zoho OAuth token refresh", secrets);
     if (!isRecord(body))
       throw new Error("Zoho OAuth token refresh returned malformed data");
+    if (typeof body.error === "string")
+      throw new Error(`Zoho OAuth token refresh failed: ${redact(responseMessage(body), secrets)}`);
     const token = valueString(body.access_token, "access_token", "Zoho OAuth token refresh");
     secrets.push(token);
     const expiresIn = Number(body.expires_in ?? 3600);
@@ -7882,9 +7978,17 @@ function createZoho(config, options = {}) {
       throw new Error("Zoho timelog id is required");
     await rateLimit(writesRate, ZOHO_WRITE_INTERVAL_MS, sleep, () => writeLog("/timetracker/edittimelog", { timeLogId: id, ...logFields(input, config) }, id));
   }
+  async function deleteLog(id) {
+    if (!id)
+      throw new Error("Zoho timelog id is required");
+    await rateLimit(writesRate, ZOHO_WRITE_INTERVAL_MS, sleep, async () => {
+      const body = await zohoRequest(queryUrl("", "/timetracker/deletetimelog", { timeLogId: id }), {}, true);
+      zohoStatus(body, "Zoho deletetimelog", secrets, true);
+    });
+  }
   return { validate: async () => {
     await listJobs();
-  }, listJobs, listLogs, getLog, createLog, updateLog };
+  }, listJobs, listLogs, getLog, createLog, updateLog, deleteLog };
 }
 
 // src/auth.ts
@@ -7896,7 +8000,7 @@ function answer(value) {
   return value;
 }
 function authPath(config) {
-  const key = createHash("sha256").update(JSON.stringify([config.zohoClientId, config.clockifyWorkspaceId, config.clockifyUserId])).digest("hex");
+  const key = createHash2("sha256").update(JSON.stringify([config.zohoClientId, config.clockifyWorkspaceId, config.clockifyUserId])).digest("hex");
   return join2(config.stateDir, `zoho-auth-${key}.json`);
 }
 async function readAuth(config) {
@@ -8147,7 +8251,7 @@ function entryTable(rows, columns) {
   if (columns >= 110)
     fields.push({ title: "Tags", size: 14, value: (row) => row.entry.tags.join("/") || "—" });
   const used = fields.reduce((sum, field) => sum + field.size + 3, 0);
-  fields.push({ title: "Description", size: Math.max(1, available - used), value: (row) => row.entry.description || "—" });
+  fields.push({ title: "Description", size: Math.max(1, available - used), value: (row) => `${row.status === "changed" || row.status === "deleted" ? `[${row.status === "changed" ? "updated" : "deleted"}] ` : ""}${row.entry.description || "—"}` });
   const line = (cells) => fitCell(cells.join(" │ "), available).trimEnd();
   return {
     header: line(fields.map((field) => fitCell(field.title, field.size))),
@@ -8155,10 +8259,13 @@ function entryTable(rows, columns) {
     labels: rows.map((row) => line(fields.map((field) => fitCell(field.value(row), field.size))))
   };
 }
+function colorEntryLabel(label, dim = false) {
+  return label.split(/(\[updated\]|\[deleted\])/).map((part) => part === "[updated]" ? styleText3(["bold", "yellow"], part) : part === "[deleted]" ? styleText3(["bold", "red"], part) : dim ? styleText3("dim", part) : part).join("");
+}
 function pickEntries(rows) {
   return new a({
     options: rows.map((row) => ({ value: row.entry.id })),
-    initialValues: rows.filter((row) => row.status === "new").map((row) => row.entry.id),
+    initialValues: rows.filter((row) => row.status === "new" || row.status === "changed" || row.status === "deleted").map((row) => row.entry.id),
     required: false,
     render() {
       const columns = process.stdout.columns || 80;
@@ -8180,7 +8287,7 @@ function pickEntries(rows) {
           gap,
           mutedLine(`│     ${table.header}`),
           mutedLine(`│     ${table.separator}`),
-          ...table.labels.map((label) => `${gap}   ${styleText3("green", "◼")} ${styleText3("dim", label)}`)
+          ...table.labels.map((label) => `${gap}   ${styleText3("green", "◼")} ${colorEntryLabel(label, true)}`)
         ].join(`
 `);
       }
@@ -8196,7 +8303,7 @@ ${heading("Selection cancelled")}`;
         const checked = selected.has(row.entry.id);
         const check = styleText3(checked ? "green" : focused ? "cyan" : "dim", checked ? "◼" : "◻");
         const label = table.labels[index + start];
-        return `${gap} ${focused ? styleText3("cyan", "›") : " "} ${check} ${focused ? label : styleText3("dim", label)}`;
+        return `${gap} ${focused ? styleText3("cyan", "›") : " "} ${check} ${colorEntryLabel(label, !focused)}`;
       });
       const focused = rows[this.cursor];
       return [
@@ -8208,6 +8315,7 @@ ${heading("Selection cancelled")}`;
         ...visible,
         gap,
         line(`│  ${selected.size}/${rows.length} selected · ${start + 1}–${Math.min(start + count, rows.length)} shown`),
+        ...focused?.status === "changed" ? [line("│  Changed · updates the existing Zoho entry")] : [],
         ...focused?.reason ? [line(`│  ${focused.reason}`)] : [],
         mutedLine("└  ↑↓ move · Space toggle · Enter confirm · Esc cancel")
       ].join(`
@@ -8254,7 +8362,7 @@ async function main(argv = process.argv.slice(2)) {
 Usage: zsync [--demo | --connect | --help | --version]
 
 Choose a date range, select entries, review mappings, then confirm.
-Existing logs are unchecked by default. No background automation.
+New, changed and deleted entries are checked by default. No background automation.
 
 Required environment:
   CLOCKIFY_API_KEY, CLOCKIFY_USER_ID, CLOCKIFY_WORKSPACE_ID
@@ -8294,26 +8402,25 @@ Optional: ZOHO_REFRESH_TOKEN, ZOHO_EMPLOYEE_ID, ZOHO_REGION, ZSYNC_TIMEZONE, ZSY
       await zoho.validate();
     });
     const entries = (await busy("Fetching Clockify entries", () => clockify.listEntries(range.start, range.end))).filter((entry) => inRange(entry, range)).sort((a, b) => a.start.localeCompare(b.start) || a.id.localeCompare(b.id));
-    if (!entries.length) {
-      outro("No completed entries in this period.");
+    const deletions = await busy("Checking for deleted Clockify entries", async () => findDeletions(await zoho.listLogs(range.firstDate, range.lastDate), clockify, config));
+    if (!entries.length && !deletions.length) {
+      outro("No entries to sync in this period.");
       return;
     }
     const scope = accountScope(config);
     store = await openStore(config.stateDir, scope);
     const jobs = await busy("Fetching Zoho People jobs", () => zoho.listJobs());
-    if (!jobs.length)
-      throw new Error("No eligible Zoho jobs. Ask your People administrator to assign a job first.");
     const jobFor = (entry) => {
       const saved = store.mappings[entry.projectId ?? "(no project)"];
       return jobs.some((job) => job.id === saved) ? saved : automaticJob(entry, jobs);
     };
     const makeInputs = (items) => items.map((entry) => ({
       key: entry.id,
-      input: entryInput(entry, jobFor(entry) ?? "__unmapped__", config.zohoEmployeeId, config.timezone)
+      input: entryInput(entry, jobFor(entry) ?? "__unmapped__", config.zohoEmployeeId, config.timezone, { workspaceId: config.clockifyWorkspaceId, userId: config.clockifyUserId })
     }));
     const initialPlan = await busy("Checking sync status", () => prepare(store, zoho, makeInputs(entries)));
     const initialByKey = new Map(initialPlan.map((item) => [item.key, item]));
-    const selectedIds = answer2(await pickEntries(entries.map((entry) => {
+    const selectedIds = answer2(await pickEntries([...entries.map((entry) => {
       const item = initialByKey.get(entry.id);
       return {
         entry,
@@ -8321,14 +8428,31 @@ Optional: ZOHO_REFRESH_TOKEN, ZOHO_EMPLOYEE_ID, ZOHO_REGION, ZSYNC_TIMEZONE, ZSY
         status: item.status === "create" ? "new" : item.status === "skip" ? "synced" : item.status === "update" ? "changed" : "conflict",
         reason: item.reason ?? (!jobFor(entry) ? "Choose a Zoho job after selection" : undefined)
       };
-    })));
+    }), ...deletions.map(({ log: log2, entryId }) => ({
+      entry: {
+        id: `delete:${log2.id}`,
+        projectId: null,
+        projectName: jobs.find((job) => job.id === log2.jobId)?.projectName || jobs.find((job) => job.id === log2.jobId)?.name || `Job ${log2.jobId}`,
+        tags: [],
+        description: log2.workItem || entryId,
+        start: "",
+        end: "",
+        billable: log2.billable
+      },
+      input: log2,
+      status: "deleted",
+      reason: `Deletes Zoho entry · ${log2.date} · ${log2.billable ? "billable" : "non-billable"}`
+    }))]));
+    const selectedDeletions = deletions.filter((item) => selectedIds.includes(`delete:${item.log.id}`));
     const selected = entries.filter((entry) => selectedIds.includes(entry.id));
-    if (!selected.length) {
+    if (!selected.length && !selectedDeletions.length) {
       moveCursor2(process.stdout, 0, -1);
       clearLine2(process.stdout, 0);
-      outro("\uD83C\uDF2A️ Nothing selected. No Zoho changes.");
+      outro("Nothing selected. No Zoho changes.");
       return;
     }
+    if (selected.length && !jobs.length)
+      throw new Error("No eligible Zoho jobs. Ask your People administrator to assign a job first.");
     for (const entry of selected) {
       const key = entry.projectId ?? "(no project)";
       if (!jobFor(entry)) {
@@ -8352,8 +8476,8 @@ Optional: ZOHO_REFRESH_TOKEN, ZOHO_EMPLOYEE_ID, ZOHO_REGION, ZSYNC_TIMEZONE, ZSY
       throw new Error("Resolve the conflicts or deselect those entries, then rerun. No selected logs were written.");
     }
     const confirmed = answer2(await select({
-      message: "Do you want to commit?",
-      initialValue: true,
+      message: `Create ${plan.filter((item) => item.status === "create").length}, update ${plan.filter((item) => item.status === "update").length}, delete ${selectedDeletions.length} Zoho entries?`,
+      initialValue: selectedDeletions.length === 0,
       options: [
         { value: true, label: "Yes" },
         { value: false, label: "No" }
@@ -8370,6 +8494,14 @@ Optional: ZOHO_REFRESH_TOKEN, ZOHO_EMPLOYEE_ID, ZOHO_REGION, ZSYNC_TIMEZONE, ZSY
         throw new Error(`Clockify entry ${entry.id} changed. Rerun to review the updated plan; no writes made.`);
     }
     const results = await busy("Syncing selected entries", () => commit(store, zoho, plan));
+    for (const item of selectedDeletions) {
+      try {
+        await busy("Deleting selected Zoho entry", () => deleteConfirmed(item, clockify, zoho));
+        results.push({ key: item.log.id, status: "deleted" });
+      } catch (error) {
+        results.push({ key: item.log.id, status: "failed", message: error instanceof Error ? error.message : String(error) });
+      }
+    }
     for (const result of results.filter((item) => item.status === "failed" || item.status === "uncertain")) {
       log.error(`${result.key}: ${result.status} — ${cleanText(result.message ?? "Check sync state before retrying.")}`);
     }
@@ -8377,6 +8509,7 @@ Optional: ZOHO_REFRESH_TOKEN, ZOHO_EMPLOYEE_ID, ZOHO_REGION, ZSYNC_TIMEZONE, ZSY
       process.exitCode = 1;
     const icons = {
       created: "✅",
+      deleted: "\uD83D\uDDD1️",
       updated: "\uD83D\uDD04",
       skipped: "⏭️",
       failed: "❌",

package/package.json

@@ -12,7 +12,7 @@
     "@js-temporal/polyfill": "^0.5.1",
     "fast-string-width": "3.0.2"
   },
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Interactively sync Clockify entries to Zoho People",
   "bin": {
     "zsync": "dist/zsync.js"