logwork-cli 1.1.1 → 1.3.0

package/lib/reminder-scheduler.mjs

@@ -3,6 +3,7 @@ import { promises as fs } from 'node:fs';
 import { homedir, userInfo } from 'node:os';
 import { join } from 'node:path';
 import { atomicWriteFile } from './atomic-file.mjs';
+import { resolveLaunchCommand, writeLauncher } from './launcher.mjs';
 import { helperHome } from './paths.mjs';
 import { normalizeReminderConfig } from './reminder-config.mjs';
 
@@ -12,18 +13,24 @@ export const WINDOWS_REMINDER_TASK_NAME = 'Logwork Reminder';
 // point at the old runtime, so installing or removing the reminder clears them.
 export const LEGACY_MACOS_REMINDER_LABEL = 'sg.vinova.logwork-helper.reminder';
 export const LEGACY_WINDOWS_REMINDER_TASK_NAME = 'Logwork Helper Reminder';
-// The scheduler runs `node <home>/bin/logwork.mjs reminder run --home <home>`.
+// The scheduler runs the launch command from lib/launcher.mjs with
+// `reminder run --home <home>`: on macOS the <home>/bin/logwork-launch script
+// (it finds Node itself), on Windows a stable node.exe plus
+// <home>\bin\logwork.mjs.
 export const REMINDER_RUNNER_RELATIVE_PATH = join('bin', 'logwork.mjs');
 
 export async function installReminderScheduler(config, {
   platform = process.platform,
   nodePath = process.execPath,
   home = helperHome(),
+  env = process.env,
+  launch = resolveLaunchCommand({ platform, home, execPath: nodePath, env }),
   userHome = homedir(),
   uid = userInfo().uid,
   run = runCommand,
   writeFile = atomicWriteFile,
-  accessRunner = fs.access
+  accessRunner = fs.access,
+  writeLauncherFn = writeLauncher
 } = {}) {
   const normalized = normalizeReminderConfig({ ...config, enabled: true });
   const runnerPath = join(home, REMINDER_RUNNER_RELATIVE_PATH);
@@ -32,14 +39,17 @@ export async function installReminderScheduler(config, {
   } catch {
     throw new Error(`Reminder runtime is missing at ${runnerPath}. Run \`logwork setup --no-login\` and retry.`);
   }
+  if (launch.kind === 'launcher') {
+    // `reminder enable` can run before `logwork setup` wrote the launcher.
+    await writeLauncherFn({ home, nodePath, platform });
+  }
   await removeLegacyReminderScheduler({ platform, userHome, uid, run });
 
   if (platform === 'darwin') {
     const plistPath = macosReminderPlistPath(userHome);
     await writeFile(plistPath, buildMacosReminderPlist({
       config: normalized,
-      nodePath,
-      runnerPath,
+      launch,
       home
     }));
     const domain = `gui/${uid}`;
@@ -58,8 +68,7 @@ export async function installReminderScheduler(config, {
   if (platform === 'win32') {
     const result = await run('schtasks.exe', buildWindowsReminderCreateArgs({
       config: normalized,
-      nodePath,
-      runnerPath,
+      launch,
       home
     }));
     assertCommandSuccess(result, 'schtasks /Create');
@@ -119,7 +128,8 @@ export async function getReminderSchedulerStatus({
   userHome = homedir(),
   uid = userInfo().uid,
   run = runCommand,
-  accessFile = fs.access
+  accessFile = fs.access,
+  readFile = fs.readFile
 } = {}) {
   if (platform === 'darwin') {
     const plistPath = macosReminderPlistPath(userHome);
@@ -130,7 +140,8 @@ export async function getReminderSchedulerStatus({
       installed: fileExists && result.code === 0,
       scheduler: 'launchd',
       identifier: MACOS_REMINDER_LABEL,
-      path: plistPath
+      path: plistPath,
+      nodePath: fileExists ? await readReminderSchedulerNodePath({ platform, userHome, run, readFile }) : null
     };
   }
 
@@ -141,14 +152,63 @@ export async function getReminderSchedulerStatus({
       installed: result.code === 0,
       scheduler: 'Task Scheduler',
       identifier: WINDOWS_REMINDER_TASK_NAME,
-      path: null
+      path: null,
+      nodePath: result.code === 0 ? await readReminderSchedulerNodePath({ platform, userHome, run, readFile }) : null
     };
   }
 
   throw unsupportedReminderPlatform(platform);
 }
 
-export function buildMacosReminderPlist({ config, nodePath, runnerPath, home }) {
+// The command the installed schedule runs: the first ProgramArguments entry of
+// the launchd plist (the launcher, or a raw node path from an older install),
+// or the <Command> of the Windows task (node.exe). Returns null when no
+// schedule is installed or it cannot be read. Read-only.
+export async function readReminderSchedulerNodePath({
+  platform = process.platform,
+  userHome = homedir(),
+  run = runCommand,
+  readFile = fs.readFile
+} = {}) {
+  try {
+    if (platform === 'darwin') {
+      const plist = await readFile(macosReminderPlistPath(userHome), 'utf8');
+      return parseMacosPlistNodePath(plist);
+    }
+    if (platform === 'win32') {
+      const result = await run('schtasks.exe', ['/Query', '/TN', WINDOWS_REMINDER_TASK_NAME, '/XML']);
+      return result.code === 0 ? parseWindowsTaskNodePath(result.stdout) : null;
+    }
+  } catch {
+    // Missing or unreadable schedule: nothing to compare.
+  }
+  return null;
+}
+
+export function parseMacosPlistNodePath(plist) {
+  const match = /<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]*)<\/string>/.exec(String(plist || ''));
+  return match ? unescapeXml(match[1]).trim() || null : null;
+}
+
+export function parseWindowsTaskNodePath(xml) {
+  // schtasks may write the XML as UTF-16; decoded as UTF-8 that leaves NULs.
+  const match = /<Command>([^<]*)<\/Command>/i.exec(String(xml || '').replaceAll('\0', ''));
+  if (!match) {
+    return null;
+  }
+  // schtasks keeps the quotes /TR put around a path with spaces.
+  return unescapeXml(match[1]).trim().replace(/^"(.*)"$/, '$1') || null;
+}
+
+// `launch` is { command, argsPrefix }. Older callers pass nodePath + runnerPath.
+function scheduleProgram({ launch, nodePath, runnerPath, home }) {
+  const program = launch
+    ? [launch.command, ...(launch.argsPrefix || [])]
+    : [nodePath, runnerPath];
+  return [...program, 'reminder', 'run', '--home', home];
+}
+
+export function buildMacosReminderPlist({ config, launch, nodePath, runnerPath, home }) {
   const normalized = normalizeReminderConfig({ ...config, enabled: true });
   const [hour, minute] = normalized.time.split(':').map(Number);
   const calendarEntries = normalized.days.map((weekday) => `    <dict>
@@ -156,6 +216,9 @@ export function buildMacosReminderPlist({ config, nodePath, runnerPath, home })
       <key>Hour</key><integer>${hour}</integer>
       <key>Minute</key><integer>${minute}</integer>
     </dict>`).join('\n');
+  const programArguments = scheduleProgram({ launch, nodePath, runnerPath, home })
+    .map((part) => `    <string>${escapeXml(assertSafePath(part))}</string>`)
+    .join('\n');
 
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -164,12 +227,7 @@ export function buildMacosReminderPlist({ config, nodePath, runnerPath, home })
   <key>Label</key><string>${escapeXml(MACOS_REMINDER_LABEL)}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${escapeXml(assertSafePath(nodePath))}</string>
-    <string>${escapeXml(assertSafePath(runnerPath))}</string>
-    <string>reminder</string>
-    <string>run</string>
-    <string>--home</string>
-    <string>${escapeXml(assertSafePath(home))}</string>
+${programArguments}
   </array>
   <key>WorkingDirectory</key><string>${escapeXml(assertSafePath(home))}</string>
   <key>StartCalendarInterval</key>
@@ -183,9 +241,9 @@ ${calendarEntries}
 `;
 }
 
-export function buildWindowsReminderCreateArgs({ config, nodePath, runnerPath, home }) {
+export function buildWindowsReminderCreateArgs({ config, launch, nodePath, runnerPath, home }) {
   const normalized = normalizeReminderConfig({ ...config, enabled: true });
-  const action = [nodePath, runnerPath, 'reminder', 'run', '--home', home]
+  const action = scheduleProgram({ launch, nodePath, runnerPath, home })
     .map(quoteWindowsActionPart)
     .join(' ');
   const dayNames = normalized.days.map((day) => ({
@@ -296,6 +354,15 @@ function escapeXml(value) {
     .replaceAll("'", '&apos;');
 }
 
+function unescapeXml(value) {
+  return String(value)
+    .replaceAll('&lt;', '<')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&quot;', '"')
+    .replaceAll('&apos;', "'")
+    .replaceAll('&amp;', '&');
+}
+
 function unsupportedReminderPlatform(platform) {
   return new Error(`Reminder scheduling is unsupported on ${platform}. Supported platforms are macOS and Windows.`);
 }

package/lib/reminder-service.mjs

@@ -1,6 +1,9 @@
+import { checkLaunchCommand, formatLaunchCheckIssue } from './launcher.mjs';
+import { formatNodePathIssue, inspectScheduledCommand } from './node-runtime.mjs';
 import {
   loadReminderConfig,
   normalizeReminderConfig,
+  normalizeReminderRepos,
   saveReminderConfig
 } from './reminder-config.mjs';
 import {
@@ -11,9 +14,12 @@ import {
 import { loadReminderState } from './reminder-state.mjs';
 import { sendTestReminderNotification } from './reminder-workflow.mjs';
 
+// repos: undefined keeps the configured commit repos; an array (even empty)
+// replaces them.
 export async function enableLogworkReminder({
   time,
   target,
+  repos,
   confirm,
   loadConfig = loadReminderConfig,
   saveConfig = saveReminderConfig,
@@ -26,7 +32,8 @@ export async function enableLogworkReminder({
     ...current,
     enabled: true,
     ...(time ? { time } : {}),
-    ...(target ? { target } : {})
+    ...(target ? { target } : {}),
+    ...(repos !== undefined ? { repos: normalizeReminderRepos(repos) } : {})
   });
 
   const scheduler = await installScheduler(config);
@@ -41,7 +48,12 @@ export async function enableLogworkReminder({
     status: 'enabled',
     config,
     scheduler,
-    summary: `Enabled ${config.target} logwork reminder at ${config.time}, Monday-Friday, using ${scheduler.scheduler}.`
+    summary: [
+      `Enabled ${config.target} logwork reminder at ${config.time}, Monday-Friday, using ${scheduler.scheduler}.`,
+      config.repos.length
+        ? `Commit summary repos: ${config.repos.join(', ')}.`
+        : 'No reminder repos set; add --repo <path> to include today\'s commits (repos on project mappings are also used).'
+    ].join('\n')
   };
 }
 
@@ -69,7 +81,9 @@ export async function disableLogworkReminder({
 export async function getLogworkReminderStatus({
   loadConfig = loadReminderConfig,
   loadState = loadReminderState,
-  schedulerStatus = getReminderSchedulerStatus
+  schedulerStatus = getReminderSchedulerStatus,
+  inspectNode = inspectScheduledCommand,
+  checkLaunch = checkLaunchCommand
 } = {}) {
   const [config, state, scheduler] = await Promise.all([
     loadConfig(),
@@ -82,9 +96,32 @@ export async function getLogworkReminderStatus({
     `Schedule: Monday-Friday at ${config.time}; target ${config.target}.`,
     `OS scheduler: ${scheduler.scheduler} ${scheduler.installed ? 'installed' : 'not installed'}.`
   ];
+  if (config.repos?.length) {
+    lines.push(`Commit summary repos: ${config.repos.join(', ')}.`);
+  }
   if (!consistent) {
     lines.push('Warning: reminder config and OS scheduler are out of sync; run reminder enable or disable again.');
   }
+  // The schedule stores an absolute command: the launcher on macOS (an older
+  // install: a raw node path), node.exe on Windows. nvm or Homebrew can remove
+  // a node while the schedule still looks installed.
+  const nodeCheck = scheduler.nodePath
+    ? await inspectNode(scheduler.nodePath).catch(() => ({ status: 'unknown', recordedPath: scheduler.nodePath }))
+    : null;
+  const nodeIssue = nodeCheck ? formatNodePathIssue('reminder', nodeCheck) : '';
+  if (nodeIssue) {
+    lines.push(`Warning: ${nodeIssue}`);
+  }
+  let launchCheck = null;
+  if (nodeCheck?.status === 'ok' && nodeCheck.kind === 'launcher') {
+    launchCheck = await checkLaunch().catch(() => null);
+    const launchIssue = formatLaunchCheckIssue(launchCheck);
+    if (launchIssue) {
+      lines.push(`Warning: ${launchIssue}`);
+    } else if (launchCheck?.node) {
+      lines.push(`Launcher: runs Node ${launchCheck.node}.`);
+    }
+  }
   if (state?.lastRunAt) {
     lines.push(`Last run: ${state.lastRunAt}, status ${state.lastStatus || 'unknown'}.`);
   }
@@ -94,6 +131,8 @@ export async function getLogworkReminderStatus({
     scheduler,
     state,
     consistent,
+    ...(nodeCheck ? { nodeCheck } : {}),
+    ...(launchCheck ? { launchCheck } : {}),
     summary: lines.join('\n')
   };
 }

package/lib/reminder-workflow.mjs

@@ -1,26 +1,37 @@
 import { isAuthRequiredError } from './auth-errors.mjs';
 import { redactText } from './auth-redaction.mjs';
+import { draftLogworkFromCommits } from './commit-workflow.mjs';
 import { withFileLock } from './file-lock.mjs';
 import { searchJiraIssues } from './jira-api.mjs';
 import {
   getStoredJiraSession,
   isJiraAuthRequiredError
 } from './jira-auth.mjs';
+import { loadLocalConfig } from './logwork-config.mjs';
 import { sendOsNotification } from './os-notification.mjs';
-import { reminderStatePath } from './paths.mjs';
+import { helperHome, reminderStatePath } from './paths.mjs';
 import { queryLogwork } from './query-workflow.mjs';
-import { loadReminderConfig } from './reminder-config.mjs';
+import { loadReminderConfig, normalizeReminderRepos } from './reminder-config.mjs';
 import {
   loadReminderState,
   saveReminderState
 } from './reminder-state.mjs';
 import { todayLocalDateISO } from './util.mjs';
 
+const REMINDER_HEADER = 'Logwork hôm nay chưa hoàn tất';
+const DEFAULT_ACTION_LINE = 'Mở Terminal và chạy: logwork';
+const COMMITS_ACTION_LINE = 'Mở Terminal và chạy: logwork commits today (bản nháp từ commit)';
+const COMMIT_SUMMARY_TIMEOUT_MS = 20_000;
+
+// repos: git repos whose commits back up a missing-RO reminder. Without repos,
+// or when reading them fails, the message is the plain RO/Jira one.
 export async function checkLogworkReminder({
   target = 'both',
   date = todayLocalDateISO(),
+  repos = [],
   queryRo = queryResourceOptimiserDay,
-  queryJira = queryJiraWorklogDay
+  queryJira = queryJiraWorklogDay,
+  summarizeCommits = summarizeTodayCommits
 } = {}) {
   const checks = {};
   const jobs = [];
@@ -42,15 +53,16 @@ export async function checkLogworkReminder({
 
   const problemLines = buildProblemLines(checks);
   const notify = problemLines.length > 0;
-  const notification = notify ? {
-    title: 'Logwork',
-    message: [
-      'Logwork hôm nay chưa hoàn tất',
-      ...problemLines,
-      '',
-      'Mở Terminal và chạy: logwork'
-    ].join('\n')
-  } : null;
+  let commits = null;
+  if (notify && checks.ro?.status === 'incomplete' && repos?.length) {
+    // Commit evidence is a bonus: any failure keeps the plain message.
+    try {
+      commits = await summarizeCommits({ date, repos });
+    } catch (error) {
+      commits = { status: 'unavailable', error: redactText(error.message || String(error)).slice(0, 300) };
+    }
+  }
+  const notification = notify ? buildReminderNotification({ problemLines, commits }) : null;
 
   return {
     date,
@@ -58,6 +70,7 @@ export async function checkLogworkReminder({
     status: notify ? 'notification_required' : 'complete',
     notify,
     checks,
+    ...(commits ? { commits } : {}),
     notification,
     summary: notify
       ? `Logwork reminder requires attention: ${problemLines.join(' | ')}`
@@ -117,8 +130,81 @@ export async function queryJiraWorklogDay({
   };
 }
 
+// Counts today's commits in the given repos with the read-only commit draft
+// (no RO query: the reminder already has the RO totals). Throws when no repo
+// could be read, so the caller falls back to the plain message.
+export async function summarizeTodayCommits({
+  date,
+  repos,
+  draft = draftLogworkFromCommits,
+  cwd = helperHome(),
+  timeoutMs = COMMIT_SUMMARY_TIMEOUT_MS
+} = {}) {
+  const result = await withTimeout(
+    draft({ from: date, repos, useBookings: false, cwd }),
+    timeoutMs,
+    'Reading commits timed out.'
+  );
+  const repoResults = Array.isArray(result?.repos) ? result.repos : [];
+  const readable = repoResults.filter((repo) => !repo.error);
+  if (!readable.length) {
+    throw new Error('None of the reminder repos could be read.');
+  }
+  return {
+    status: 'ok',
+    commitCount: Number(result.commitCount || 0),
+    repoCount: readable.filter((repo) => Number(repo.commitCount || 0) > 0).length,
+    readRepoCount: readable.length,
+    failedRepoCount: repoResults.length - readable.length
+  };
+}
+
+// Reminder repos plus any `repos` listed on project mappings in the local
+// config. Mapping repos are optional and read defensively.
+export async function collectReminderRepos({
+  config,
+  loadMappings = loadLocalConfig,
+  cwd = helperHome()
+} = {}) {
+  const repos = [...(Array.isArray(config?.repos) ? config.repos : [])];
+  let mappings = [];
+  try {
+    mappings = (await loadMappings(cwd))?.projectMappings || [];
+  } catch {
+    mappings = [];
+  }
+  for (const mapping of Array.isArray(mappings) ? mappings : []) {
+    if (!Array.isArray(mapping?.repos)) {
+      continue;
+    }
+    for (const repo of mapping.repos) {
+      try {
+        repos.push(...normalizeReminderRepos([repo], { cwd }));
+      } catch {
+        // Skip a malformed mapping path.
+      }
+    }
+  }
+  return [...new Set(repos)];
+}
+
+export function buildReminderNotification({ header = REMINDER_HEADER, problemLines = [], commits = null } = {}) {
+  const hasCommits = commits?.status === 'ok' && commits.commitCount > 0;
+  return {
+    title: 'Logwork',
+    message: [
+      header,
+      ...problemLines,
+      ...(hasCommits ? [`Hôm nay: ${commits.commitCount} commit trong ${commits.repoCount} repo`] : []),
+      '',
+      hasCommits ? COMMITS_ACTION_LINE : DEFAULT_ACTION_LINE
+    ].join('\n')
+  };
+}
+
 export async function runScheduledReminder({
   loadConfig = loadReminderConfig,
+  collectRepos = collectReminderRepos,
   loadState = loadReminderState,
   saveState = saveReminderState,
   check = checkLogworkReminder,
@@ -165,9 +251,11 @@ export async function runScheduledReminder({
       return result;
     }
 
+    const repos = await collectRepos({ config }).catch(() => []);
     const checkResult = await check({
       target: config.target,
-      date
+      date,
+      repos
     });
     if (!checkResult.notify) {
       const result = {
@@ -219,15 +307,13 @@ export async function sendTestReminderNotification({
   if (!lines.length) {
     throw new Error('Reminder target must be ro, jira, or both.');
   }
-  const notification = {
-    title: 'Logwork',
-    message: [
-      'Đây là notification thử nghiệm',
-      ...lines,
-      '',
-      'Mở Terminal và chạy: logwork'
-    ].join('\n')
-  };
+  // Sample data in the real message format, including the commit line a
+  // reminder with repos shows when RO hours are missing.
+  const notification = buildReminderNotification({
+    header: 'Đây là notification thử nghiệm',
+    problemLines: lines,
+    commits: target === 'jira' ? null : { status: 'ok', commitCount: 5, repoCount: 2 }
+  });
   const result = await notify(notification);
   return {
     status: 'sent',
@@ -292,6 +378,16 @@ function formatHours(value) {
   return Number(value || 0).toFixed(2).replace(/\.00$/, '').replace(/(\.\d)0$/, '$1');
 }
 
+function withTimeout(promise, timeoutMs, message) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+    })
+  ]).finally(() => clearTimeout(timer));
+}
+
 function assertDateOnly(value) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(String(value || ''))) {
     throw new Error('Reminder date must use YYYY-MM-DD format.');