logwork-cli 1.0.0 → 1.1.1

package/lib/npm-command.mjs

@@ -0,0 +1,29 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+// How to start npm as a child process on every platform.
+// On Windows, npm is npm.cmd: spawn('npm') fails with ENOENT, and since the
+// Node fix for CVE-2024-27980 spawn('npm.cmd') without a shell fails with
+// EINVAL. Running npm's own npm-cli.js with the current node avoids the shell;
+// when it cannot be found, fall back to npm.cmd through cmd.exe.
+export function npmInvocation(args, {
+  platform = process.platform,
+  execPath = process.execPath,
+  env = process.env,
+  exists = existsSync
+} = {}) {
+  if (platform !== 'win32') {
+    return { command: 'npm', args, shell: false };
+  }
+  const candidates = [
+    env.npm_execpath && /npm-cli\.js$/i.test(env.npm_execpath) ? env.npm_execpath : null,
+    join(dirname(execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js')
+  ].filter(Boolean);
+  const cli = candidates.find((path) => exists(path));
+  if (cli) {
+    return { command: execPath, args: [cli, ...args], shell: false };
+  }
+  // cmd.exe joins the arguments unquoted; the arguments used here have no
+  // spaces or shell metacharacters.
+  return { command: 'npm.cmd', args, shell: true };
+}

package/lib/paths.mjs

@@ -52,7 +52,10 @@ export function reminderStatePath() {
 }
 
 export function legacyUserConfigPath() {
-  return resolve(homedir(), LEGACY_CONFIG_FILE_NAME);
+  // A custom home (tests, separate profiles) keeps its state isolated from
+  // the real ~/.logwork-helper.json.
+  const custom = customHelperHome();
+  return custom ? resolve(custom, LEGACY_CONFIG_FILE_NAME) : resolve(homedir(), LEGACY_CONFIG_FILE_NAME);
 }
 
 // Project-scope mappings live in the repo the user works in. A repo that still

package/lib/release-doctor.mjs

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { npmInvocation } from './npm-command.mjs';
 
 const PACKAGE_NAME = 'logwork-cli';
 const PACK_CACHE_PATH = '/private/tmp/logwork-cli-npm-cache';
@@ -113,10 +114,11 @@ export async function runCommandDefault(command, args = [], {
       ...process.env,
       ...(gitSafe ? { GIT_CONFIG_GLOBAL: '/dev/null' } : {})
     };
-    const child = spawn(command, args, {
+    const invocation = command === 'npm' ? npmInvocation(args) : { command, args, shell: false };
+    const child = spawn(invocation.command, invocation.args, {
       cwd,
       env,
-      shell: false,
+      shell: invocation.shell,
       stdio: ['ignore', 'pipe', 'pipe']
     });
     let stdout = '';

package/lib/ro-delete-workflow.mjs

@@ -1,6 +1,6 @@
 import { ApiError, deleteLogworkEntry } from './api.mjs';
 import { createResourceOptimiserSession } from './query-workflow.mjs';
-import { createF03LogworkReader } from './ro-entry-reader.mjs';
+import { assertOwnUnlockedRoEntry, createF03LogworkReader, createRoEntryRevisionFingerprint } from './ro-entry-reader.mjs';
 
 const DELETABLE_STATUSES = new Set(['submitted', 'approved']);
 
@@ -11,6 +11,7 @@ export async function previewRoLogworkDelete({
   const reader = fetchLogwork || createF03LogworkReader();
   const current = await reader(assertIdentifier(logworkId, 'logworkId'));
   assertDeletableStatus(current);
+  assertOwnUnlockedRoEntry(current, 'delete');
 
   const preview = {
     previewId: `delete_${current.id}`,
@@ -106,10 +107,5 @@ function assertIdentifier(value, label) {
 }
 
 function createLogworkRevisionFingerprint(logwork) {
-  return JSON.stringify({
-    id: logwork.id,
-    hours: logwork.hours,
-    status: logwork.status,
-    taskName: logwork.taskName
-  });
+  return createRoEntryRevisionFingerprint(logwork);
 }

package/lib/ro-edit-workflow.mjs

@@ -100,7 +100,7 @@ export async function applyRoLogworkEdit({
   const reader = fetchLogwork || createF03LogworkReader();
   const creator = submitCreate || createEntryWriter();
   const deleter = submitDelete || createDeleteWriter();
-  const dayReader = fetchDayEntries || createDayEntriesReader();
+  const dayReader = fetchDayEntries || (injected ? null : createDayEntriesReader());
   const ledgerWriter = recordLedger === undefined
     ? (injected ? null : recordApplyResult)
     : recordLedger;
@@ -121,15 +121,27 @@ export async function applyRoLogworkEdit({
     needsProjectId: preview.updated.needsProjectId
   };
 
+  // Entry ids already on the target day, so a replacement found later by its
+  // values is never confused with an older identical entry.
+  const existingIds = await readDayEntryIds(dayReader, preview.updated.date);
+
   let createResult;
   try {
     createResult = await creator(createRequest);
   } catch (error) {
-    error.message = `Could not create the replacement RO entry; the original entry ${preview.logworkId} is unchanged. ${error.message}`;
-    error.applyLedger = await recordEditLedger({
-      writer: ledgerWriter, preview, status: 'failed', entryStatus: 'failed', error: error.message, cwd
-    });
-    throw error;
+    // Writes are not retried, so a timeout is ambiguous: RO may have saved the
+    // entry. Look for it before reporting that nothing changed.
+    const savedId = await findCreatedEntryId({ dayReader, preview, existingIds });
+    if (savedId === null) {
+      error.message = existingIds
+        ? `Could not create the replacement RO entry; the original entry ${preview.logworkId} is unchanged. ${error.message}`
+        : `Could not create the replacement RO entry (${error.message}). The original entry ${preview.logworkId} is unchanged, but check ${preview.updated.date} (get_logwork or \`logwork query\`) in case RO saved a copy.`;
+      error.applyLedger = await recordEditLedger({
+        writer: ledgerWriter, preview, status: 'failed', entryStatus: 'failed', error: error.message, cwd
+      });
+      throw error;
+    }
+    createResult = { entry: { id: savedId } };
   }
 
   if (createResult?.dryRun) {
@@ -156,7 +168,7 @@ export async function applyRoLogworkEdit({
 
   let newLogworkId = createResult?.entry?.id ?? null;
   if (newLogworkId === null || newLogworkId === undefined) {
-    newLogworkId = await findCreatedEntryId({ dayReader, preview });
+    newLogworkId = await findCreatedEntryId({ dayReader, preview, existingIds });
   }
   if (newLogworkId === null || newLogworkId === undefined) {
     const error = new Error(
@@ -172,6 +184,25 @@ export async function applyRoLogworkEdit({
   try {
     await deleter(preview.logworkId);
   } catch (error) {
+    // A failed DELETE may still have deleted the original (timeout). Roll the
+    // replacement back only when the original is confirmed to still exist;
+    // otherwise rolling back could leave neither entry.
+    const originalState = await originalEntryState({ dayReader, preview });
+    if (originalState === 'gone') {
+      return finishReplace({ reader, preview, newLogworkId, ledgerWriter, cwd });
+    }
+    if (originalState === 'unknown') {
+      const message = `Deleting the original RO entry ${preview.logworkId} failed (${error.message}) and its state could not be read. ` +
+        `The replacement entry ${newLogworkId} was kept. Check ${preview.original?.date || preview.updated.date} (get_logwork or \`logwork query\`); if both entries exist, delete ${preview.logworkId}.`;
+      const wrapped = new Error(message);
+      wrapped.cause = error;
+      wrapped.newLogworkId = newLogworkId;
+      wrapped.rolledBack = false;
+      wrapped.applyLedger = await recordEditLedger({
+        writer: ledgerWriter, preview, status: 'partial', entryStatus: 'failed', error: message, newLogworkId, cwd
+      });
+      throw wrapped;
+    }
     const rollback = await rollbackCreatedEntry({ deleter, newLogworkId });
     const message = rollback.ok
       ? `Could not delete the original RO entry ${preview.logworkId} (${error.message}). The replacement entry ${newLogworkId} was rolled back; nothing changed.`
@@ -193,6 +224,10 @@ export async function applyRoLogworkEdit({
     throw wrapped;
   }
 
+  return finishReplace({ reader, preview, newLogworkId, ledgerWriter, cwd });
+}
+
+async function finishReplace({ reader, preview, newLogworkId, ledgerWriter, cwd }) {
   let verified;
   try {
     verified = sanitizeLogwork(await reader(newLogworkId));
@@ -483,11 +518,34 @@ function changeFingerprint(change) {
   };
 }
 
-async function findCreatedEntryId({ dayReader, preview }) {
+async function readDayEntryIds(dayReader, date) {
+  if (!dayReader) {
+    return null;
+  }
+  try {
+    return new Set((await dayReader(date) || []).map((entry) => String(entry.id)));
+  } catch {
+    return null;
+  }
+}
+
+async function originalEntryState({ dayReader, preview }) {
+  const ids = await readDayEntryIds(dayReader, preview.original?.date || preview.updated.date);
+  if (!ids) {
+    return 'unknown';
+  }
+  return ids.has(String(preview.logworkId)) ? 'present' : 'gone';
+}
+
+async function findCreatedEntryId({ dayReader, preview, existingIds = null }) {
+  if (!dayReader) {
+    return null;
+  }
   try {
     const entries = await dayReader(preview.updated.date);
     const candidates = (entries || []).filter((entry) => (
       String(entry.id) !== String(preview.logworkId) &&
+      (!existingIds || !existingIds.has(String(entry.id))) &&
       String(entry.worklogTaskId) === String(preview.updated.worklogTaskId) &&
       Number(entry.hours) === Number(preview.updated.hours) &&
       (entry.description || '') === (preview.updated.description || '') &&

package/lib/ro-entry-reader.mjs

@@ -18,7 +18,12 @@ export function createF03LogworkReader() {
     if (!f03) {
       throw new Error(`RO logwork ${logworkId} was not found on ${legacy.date}; it may have been deleted.`);
     }
-    projectsPromise ||= getProjects(token, userId);
+    // Cache only a successful load: a cached rejection (say a 401) would make
+    // the retry after a forced login fail the same way.
+    projectsPromise ||= getProjects(token, userId).catch((error) => {
+      projectsPromise = null;
+      throw error;
+    });
     const projects = await projectsPromise;
     const projectMemberId = f03.projectMemberId ?? legacy.projectMemberId;
     const project = projects.find((item) => String(item.projectMemberId) === String(projectMemberId));
@@ -54,3 +59,36 @@ function withoutEmpty(record = {}) {
     value !== undefined && value !== null && value !== ''
   )));
 }
+
+// Guards shared by delete and resubmit (edit has its own, stricter set): the
+// entry must be the user's own, not synced from Jira, and on an unlocked day.
+export function assertOwnUnlockedRoEntry(logwork, action) {
+  if (
+    logwork?.currentUserId !== undefined &&
+    logwork?.createdBy !== undefined &&
+    String(logwork.currentUserId) !== String(logwork.createdBy)
+  ) {
+    throw new Error(`Cannot ${action} another user's RO logwork.`);
+  }
+  const jiraId = logwork?.jiraLogworkId;
+  if ((jiraId !== null && jiraId !== undefined && String(jiraId).trim() !== '') || String(logwork?.source || '').toLowerCase() === 'jira') {
+    throw new Error(`This RO logwork was created by Jira; ${action} it in Jira so both systems stay in step.`);
+  }
+  if (logwork?.dayLocked) {
+    throw new Error(`Logwork for ${logwork.date || 'this day'} is locked on Resource Optimiser; cannot ${action} it.`);
+  }
+}
+
+// What a preview was approved against; apply refuses if any of it changed.
+export function createRoEntryRevisionFingerprint(logwork) {
+  return JSON.stringify({
+    id: logwork.id,
+    date: logwork.date ?? null,
+    hours: logwork.hours,
+    status: logwork.status,
+    taskName: logwork.taskName,
+    worklogTaskId: logwork.worklogTaskId ?? null,
+    typeOfWork: logwork.typeOfWork ?? null,
+    description: logwork.description ?? null
+  });
+}

package/lib/ro-resubmit-workflow.mjs

@@ -1,6 +1,6 @@
 import { ApiError, resubmitLogworkEntry } from './api.mjs';
 import { createResourceOptimiserSession } from './query-workflow.mjs';
-import { createF03LogworkReader } from './ro-entry-reader.mjs';
+import { assertOwnUnlockedRoEntry, createF03LogworkReader, createRoEntryRevisionFingerprint } from './ro-entry-reader.mjs';
 
 export async function previewRoLogworkResubmit({
   logworkId,
@@ -15,31 +15,40 @@ export async function previewRoLogworkResubmit({
   if (String(current.status || '').toLowerCase() !== 'rejected') {
     throw new Error('Only rejected RO logwork entries can be resubmitted through this flow.');
   }
+  assertOwnUnlockedRoEntry(current, 'resubmit');
 
   const effortHours = hours === undefined ? current.hours : Number(hours);
-  if (!Number.isFinite(effortHours) || effortHours <= 0) {
-    throw new Error('hours must be a positive number.');
+  if (!Number.isFinite(effortHours) || effortHours <= 0 || effortHours > 24) {
+    throw new Error('hours must be a positive number up to 24.');
   }
 
-  const previewId = `resubmit_${current.id}_${effortHours}`;
+  const updated = {
+    hours: effortHours,
+    typeOfWork: typeOfWork || current.typeOfWork || 'other',
+    noteToPm: noteToPm ?? current.noteToPm ?? '',
+    description: description ?? current.description ?? ''
+  };
+  const originalFingerprint = createLogworkRevisionFingerprint(current);
+  // Every field that will be sent is part of the id, so two different
+  // previews of the same entry never share (and overwrite) one cache slot.
+  const previewId = `resubmit_${current.id}_${hash(JSON.stringify({ updated, originalFingerprint }))}`;
   const preview = {
     previewId,
     status: 'ready',
     logworkId: current.id,
     original: current,
-    updated: {
-      hours: effortHours,
-      typeOfWork: typeOfWork || current.typeOfWork || 'other',
-      noteToPm: noteToPm ?? current.noteToPm ?? '',
-      description: description ?? current.description ?? ''
-    },
-    originalFingerprint: createLogworkRevisionFingerprint(current)
+    updated,
+    originalFingerprint
   };
+  const changeLine = (label, from, to) => (String(from ?? '') === String(to ?? '') ? `- ${label}: ${to || '(empty)'}` : `- ${label}: ${from || '(empty)'} -> ${to || '(empty)'}`);
   preview.summary = [
     'RO logwork resubmit preview:',
-    `- Entry: ${current.id}`,
-    `- Hours: ${current.hours} -> ${effortHours}`,
-    `- Status: rejected -> approved (after resubmit)`
+    `- Entry: ${current.id} (${current.date || 'unknown date'}, ${current.taskName || 'unknown task'})`,
+    changeLine('Hours', current.hours, effortHours),
+    changeLine('Type of work', current.typeOfWork, updated.typeOfWork),
+    changeLine('Description', current.description, updated.description),
+    `- Note to PM: ${updated.noteToPm || '(none)'}`,
+    '- Status: rejected -> resubmitted'
   ].join('\n');
   return preview;
 }
@@ -125,10 +134,14 @@ function assertIdentifier(value, label) {
 }
 
 function createLogworkRevisionFingerprint(logwork) {
-  return JSON.stringify({
-    id: logwork.id,
-    hours: logwork.hours,
-    status: logwork.status,
-    taskName: logwork.taskName
-  });
+  return createRoEntryRevisionFingerprint(logwork);
+}
+
+function hash(value) {
+  let hashValue = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hashValue ^= value.charCodeAt(index);
+    hashValue = Math.imul(hashValue, 16777619);
+  }
+  return (hashValue >>> 0).toString(36);
 }

package/lib/update-service.mjs

@@ -5,6 +5,7 @@ import { atomicWriteFile } from './atomic-file.mjs';
 import { redactText } from './auth-redaction.mjs';
 import { fetchWithPolicy, redactedExcerpt } from './http.mjs';
 import { readPackageInfo } from './package-info.mjs';
+import { npmInvocation } from './npm-command.mjs';
 import { helperHome, updateStatePath } from './paths.mjs';
 
 export const UPDATE_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
@@ -187,7 +188,7 @@ export async function installUpdate({
     };
   }
 
-  const executable = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const executable = 'npm';
   const args = [
     'exec',
     '--yes',
@@ -311,7 +312,9 @@ function requireSemver(value, label) {
 
 function runUpdateCommand(executable, args, { stdio = 'pipe' } = {}) {
   return new Promise((resolveValue, reject) => {
-    const child = spawn(executable, args, {
+    const invocation = executable === 'npm' ? npmInvocation(args) : { command: executable, args, shell: false };
+    const child = spawn(invocation.command, invocation.args, {
+      shell: invocation.shell,
       cwd: helperHome(),
       env: process.env,
       stdio: stdio === 'inherit' ? 'inherit' : ['ignore', 'pipe', 'pipe']

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "logwork-cli",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Log work to Resource Optimiser and Jira from the terminal, an MCP server for AI IDEs, and a terminal UI.",
   "license": "UNLICENSED",
   "type": "module",
@@ -38,6 +38,7 @@
     "bin/",
     "commands/",
     "lib/",
+    "skills/",
     "docs/",
     "examples/mcp/",
     "setup.sh",

package/skills/logwork/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: logwork
+description: Log work hours to Resource Optimiser (RO) and Jira from the user's own git commits with the logwork MCP tools. Use when the user asks to log work, fill in logwork or timesheets for a day or week, check missing hours, or fix existing RO entries.
+---
+
+# Logwork from commits
+
+Goal: every logged line is backed by real work (the user's commits or what the user tells you), uses a valid RO worklog task, has a clear description, and fits the day's booked hours.
+
+## Steps
+
+1. **Find the gaps.** Call `get_logwork` for the period. A day/project still needs time when booked > logged. Skip days that are already full.
+2. **Collect the evidence.** Call `draft_from_commits` with the same period and `repos` set to every repo the user worked in (the open workspace folders; ask the user for others). It groups the user's commits per day by repo, ticket and kind of work, suggests a worklog task per group, and splits each day's remaining RO hours across the groups. Treat its hours as a starting point, not a fact.
+3. **Check the worklog tasks.** For each project involved, call `list_tasks(projectId)`. Keep the suggested task when it exists in that catalog; otherwise pick the catalog task whose description matches the work.
+4. **Write the descriptions.** One line per piece of work: what was done and the outcome, with ticket keys, in English, under about 200 characters, no `|`. Rewrite vague commit subjects ("wip", "fix", "update"); use `get_jira_issue` to read the ticket when the subject alone is unclear.
+5. **Set the hours.**
+   - Stay within the remaining booked hours per day and project unless the user says otherwise. The draft splits the day's total; use each day's `remainingByProject` to move hours to the project the work belongs to.
+   - If `draft_from_commits` returns `authRequired`, call `login` first; do not guess hours without RO.
+   - Use 0.5h steps.
+   - Do not log weekends or days without a booking unless the user asks.
+   - Work without commits (meetings, reviews, support) only comes from the user; ask, then log it as `Other Activities` or `Code Review & Refactoring`.
+6. **Resolve projects.** Ticket prefixes and mappings pick the project. If a line stays unresolved, ask the user and offer `map_project` so it is automatic next time.
+7. **Get approval, then write.**
+   - Show the final block to the user.
+   - On approval, call `log_work(text)` and show its preview summary.
+   - Then call `log_work(batchId, confirm: true)`.
+   - If the user also logs Jira, do the same with `log_jira_work`. Jira needs exactly one issue key per line.
+
+## Line format
+
+```text
+Friday, 06 Nov 2026
++2 Feature Development | Implement SSO login with ADFS (STM-4)
++1 Bug Fix | Fix date picker timezone offset (SAP-42)
+```
+
+`+<hours> <worklog task> | <description>`. The task is an RO catalog name or `#<id>`.
+
+## Rules
+
+- Never invent work that is not in the commits or in what the user told you. When unsure, ask.
+- Never set `confirm: true` without the user's explicit approval of that preview.
+- Never ask for or pass passwords, OTPs or tokens. On `authRequired`, call `login` and let the user finish in the terminal.
+- To fix an existing entry, use `edit_entry` (submitted or approved entries) or `resubmit_entry` (rejected entries). Do not log a duplicate.