logwork-cli 0.0.0-stage → 1.1.0

package/lib/reminder-scheduler.mjs

@@ -0,0 +1,301 @@
+import { spawn } from 'node:child_process';
+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 { helperHome } from './paths.mjs';
+import { normalizeReminderConfig } from './reminder-config.mjs';
+
+export const MACOS_REMINDER_LABEL = 'sg.vinova.logwork-cli.reminder';
+export const WINDOWS_REMINDER_TASK_NAME = 'Logwork Reminder';
+// Scheduler names used before the logwork-helper -> logwork-cli rename. They
+// 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>`.
+export const REMINDER_RUNNER_RELATIVE_PATH = join('bin', 'logwork.mjs');
+
+export async function installReminderScheduler(config, {
+  platform = process.platform,
+  nodePath = process.execPath,
+  home = helperHome(),
+  userHome = homedir(),
+  uid = userInfo().uid,
+  run = runCommand,
+  writeFile = atomicWriteFile,
+  accessRunner = fs.access
+} = {}) {
+  const normalized = normalizeReminderConfig({ ...config, enabled: true });
+  const runnerPath = join(home, REMINDER_RUNNER_RELATIVE_PATH);
+  try {
+    await accessRunner(runnerPath);
+  } catch {
+    throw new Error(`Reminder runtime is missing at ${runnerPath}. Run \`logwork setup --no-login\` and retry.`);
+  }
+  await removeLegacyReminderScheduler({ platform, userHome, uid, run });
+
+  if (platform === 'darwin') {
+    const plistPath = macosReminderPlistPath(userHome);
+    await writeFile(plistPath, buildMacosReminderPlist({
+      config: normalized,
+      nodePath,
+      runnerPath,
+      home
+    }));
+    const domain = `gui/${uid}`;
+    await run('/bin/launchctl', ['bootout', domain, plistPath]);
+    const loaded = await run('/bin/launchctl', ['bootstrap', domain, plistPath]);
+    assertCommandSuccess(loaded, 'launchctl bootstrap');
+    return {
+      platform,
+      installed: true,
+      scheduler: 'launchd',
+      identifier: MACOS_REMINDER_LABEL,
+      path: plistPath
+    };
+  }
+
+  if (platform === 'win32') {
+    const result = await run('schtasks.exe', buildWindowsReminderCreateArgs({
+      config: normalized,
+      nodePath,
+      runnerPath,
+      home
+    }));
+    assertCommandSuccess(result, 'schtasks /Create');
+    return {
+      platform,
+      installed: true,
+      scheduler: 'Task Scheduler',
+      identifier: WINDOWS_REMINDER_TASK_NAME,
+      path: null
+    };
+  }
+
+  throw unsupportedReminderPlatform(platform);
+}
+
+export async function removeReminderScheduler({
+  platform = process.platform,
+  userHome = homedir(),
+  uid = userInfo().uid,
+  run = runCommand,
+  removeFile = fs.rm
+} = {}) {
+  await removeLegacyReminderScheduler({ platform, userHome, uid, run, removeFile });
+  if (platform === 'darwin') {
+    const plistPath = macosReminderPlistPath(userHome);
+    await run('/bin/launchctl', ['bootout', `gui/${uid}`, plistPath]);
+    await removeFile(plistPath, { force: true });
+    return {
+      platform,
+      installed: false,
+      scheduler: 'launchd',
+      identifier: MACOS_REMINDER_LABEL,
+      path: plistPath
+    };
+  }
+
+  if (platform === 'win32') {
+    const existing = await run('schtasks.exe', ['/Query', '/TN', WINDOWS_REMINDER_TASK_NAME]);
+    if (existing.code === 0) {
+      const deleted = await run('schtasks.exe', ['/Delete', '/TN', WINDOWS_REMINDER_TASK_NAME, '/F']);
+      assertCommandSuccess(deleted, 'schtasks /Delete');
+    }
+    return {
+      platform,
+      installed: false,
+      scheduler: 'Task Scheduler',
+      identifier: WINDOWS_REMINDER_TASK_NAME,
+      path: null
+    };
+  }
+
+  throw unsupportedReminderPlatform(platform);
+}
+
+export async function getReminderSchedulerStatus({
+  platform = process.platform,
+  userHome = homedir(),
+  uid = userInfo().uid,
+  run = runCommand,
+  accessFile = fs.access
+} = {}) {
+  if (platform === 'darwin') {
+    const plistPath = macosReminderPlistPath(userHome);
+    const fileExists = await accessFile(plistPath).then(() => true).catch(() => false);
+    const result = await run('/bin/launchctl', ['print', `gui/${uid}/${MACOS_REMINDER_LABEL}`]);
+    return {
+      platform,
+      installed: fileExists && result.code === 0,
+      scheduler: 'launchd',
+      identifier: MACOS_REMINDER_LABEL,
+      path: plistPath
+    };
+  }
+
+  if (platform === 'win32') {
+    const result = await run('schtasks.exe', ['/Query', '/TN', WINDOWS_REMINDER_TASK_NAME, '/FO', 'LIST']);
+    return {
+      platform,
+      installed: result.code === 0,
+      scheduler: 'Task Scheduler',
+      identifier: WINDOWS_REMINDER_TASK_NAME,
+      path: null
+    };
+  }
+
+  throw unsupportedReminderPlatform(platform);
+}
+
+export function buildMacosReminderPlist({ config, nodePath, runnerPath, home }) {
+  const normalized = normalizeReminderConfig({ ...config, enabled: true });
+  const [hour, minute] = normalized.time.split(':').map(Number);
+  const calendarEntries = normalized.days.map((weekday) => `    <dict>
+      <key>Weekday</key><integer>${weekday}</integer>
+      <key>Hour</key><integer>${hour}</integer>
+      <key>Minute</key><integer>${minute}</integer>
+    </dict>`).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">
+<plist version="1.0">
+<dict>
+  <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>
+  </array>
+  <key>WorkingDirectory</key><string>${escapeXml(assertSafePath(home))}</string>
+  <key>StartCalendarInterval</key>
+  <array>
+${calendarEntries}
+  </array>
+  <key>ProcessType</key><string>Background</string>
+  <key>ThrottleInterval</key><integer>60</integer>
+</dict>
+</plist>
+`;
+}
+
+export function buildWindowsReminderCreateArgs({ config, nodePath, runnerPath, home }) {
+  const normalized = normalizeReminderConfig({ ...config, enabled: true });
+  const action = [nodePath, runnerPath, 'reminder', 'run', '--home', home]
+    .map(quoteWindowsActionPart)
+    .join(' ');
+  const dayNames = normalized.days.map((day) => ({
+    1: 'MON',
+    2: 'TUE',
+    3: 'WED',
+    4: 'THU',
+    5: 'FRI'
+  })[day]).join(',');
+
+  return [
+    '/Create',
+    '/TN', WINDOWS_REMINDER_TASK_NAME,
+    '/TR', action,
+    '/SC', 'WEEKLY',
+    '/D', dayNames,
+    '/ST', normalized.time,
+    '/IT',
+    '/RL', 'LIMITED',
+    '/F'
+  ];
+}
+
+export function macosReminderPlistPath(userHome = homedir(), label = MACOS_REMINDER_LABEL) {
+  return join(userHome, 'Library', 'LaunchAgents', `${label}.plist`);
+}
+
+export async function removeLegacyReminderScheduler({
+  platform = process.platform,
+  userHome = homedir(),
+  uid = userInfo().uid,
+  run = runCommand,
+  removeFile = fs.rm
+} = {}) {
+  try {
+    if (platform === 'darwin') {
+      const plistPath = macosReminderPlistPath(userHome, LEGACY_MACOS_REMINDER_LABEL);
+      const exists = await fs.access(plistPath).then(() => true).catch(() => false);
+      if (!exists) {
+        return false;
+      }
+      await run('/bin/launchctl', ['bootout', `gui/${uid}`, plistPath]);
+      await removeFile(plistPath, { force: true });
+      return true;
+    }
+    if (platform === 'win32') {
+      const existing = await run('schtasks.exe', ['/Query', '/TN', LEGACY_WINDOWS_REMINDER_TASK_NAME]);
+      if (existing.code !== 0) {
+        return false;
+      }
+      await run('schtasks.exe', ['/Delete', '/TN', LEGACY_WINDOWS_REMINDER_TASK_NAME, '/F']);
+      return true;
+    }
+  } catch {
+    // Best effort: a leftover legacy schedule only fires the old runtime.
+  }
+  return false;
+}
+
+export function runCommand(command, args) {
+  return new Promise((resolveValue, reject) => {
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.setEncoding('utf8');
+    child.stderr?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk) => { stdout += chunk; });
+    child.stderr?.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', reject);
+    child.on('close', (code, signal) => {
+      resolveValue({
+        code: signal ? 1 : (code ?? 1),
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+
+function assertCommandSuccess(result, command) {
+  if (result.code !== 0) {
+    throw new Error(`${command} failed with exit code ${result.code}: ${String(result.stderr || result.stdout || 'no output').trim()}`);
+  }
+}
+
+function quoteWindowsActionPart(value) {
+  const path = assertSafePath(value);
+  return /[\s&()^%!,;]/.test(path) ? `"${path}"` : path;
+}
+
+function assertSafePath(value) {
+  const path = String(value || '');
+  if (!path || /[\r\n"<>|]/.test(path)) {
+    throw new Error('Reminder scheduler path contains unsupported characters.');
+  }
+  return path;
+}
+
+function escapeXml(value) {
+  return String(value)
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+}
+
+function unsupportedReminderPlatform(platform) {
+  return new Error(`Reminder scheduling is unsupported on ${platform}. Supported platforms are macOS and Windows.`);
+}

package/lib/reminder-service.mjs

@@ -0,0 +1,118 @@
+import {
+  loadReminderConfig,
+  normalizeReminderConfig,
+  saveReminderConfig
+} from './reminder-config.mjs';
+import {
+  getReminderSchedulerStatus,
+  installReminderScheduler,
+  removeReminderScheduler
+} from './reminder-scheduler.mjs';
+import { loadReminderState } from './reminder-state.mjs';
+import { sendTestReminderNotification } from './reminder-workflow.mjs';
+
+export async function enableLogworkReminder({
+  time,
+  target,
+  confirm,
+  loadConfig = loadReminderConfig,
+  saveConfig = saveReminderConfig,
+  installScheduler = installReminderScheduler,
+  removeScheduler = removeReminderScheduler
+} = {}) {
+  requireConfirmation(confirm, 'enable');
+  const current = await loadConfig();
+  const config = normalizeReminderConfig({
+    ...current,
+    enabled: true,
+    ...(time ? { time } : {}),
+    ...(target ? { target } : {})
+  });
+
+  const scheduler = await installScheduler(config);
+  try {
+    await saveConfig(config);
+  } catch (error) {
+    await removeScheduler().catch(() => {});
+    throw error;
+  }
+
+  return {
+    status: 'enabled',
+    config,
+    scheduler,
+    summary: `Enabled ${config.target} logwork reminder at ${config.time}, Monday-Friday, using ${scheduler.scheduler}.`
+  };
+}
+
+export async function disableLogworkReminder({
+  confirm,
+  loadConfig = loadReminderConfig,
+  saveConfig = saveReminderConfig,
+  removeScheduler = removeReminderScheduler
+} = {}) {
+  requireConfirmation(confirm, 'disable');
+  const current = await loadConfig();
+  const scheduler = await removeScheduler();
+  const config = await saveConfig({
+    ...current,
+    enabled: false
+  });
+  return {
+    status: 'disabled',
+    config,
+    scheduler,
+    summary: 'Disabled the logwork reminder and removed its OS schedule.'
+  };
+}
+
+export async function getLogworkReminderStatus({
+  loadConfig = loadReminderConfig,
+  loadState = loadReminderState,
+  schedulerStatus = getReminderSchedulerStatus
+} = {}) {
+  const [config, state, scheduler] = await Promise.all([
+    loadConfig(),
+    loadState(),
+    schedulerStatus()
+  ]);
+  const consistent = config.enabled === scheduler.installed;
+  const lines = [
+    `Logwork reminder: ${config.enabled ? 'enabled' : 'disabled'}.`,
+    `Schedule: Monday-Friday at ${config.time}; target ${config.target}.`,
+    `OS scheduler: ${scheduler.scheduler} ${scheduler.installed ? 'installed' : 'not installed'}.`
+  ];
+  if (!consistent) {
+    lines.push('Warning: reminder config and OS scheduler are out of sync; run reminder enable or disable again.');
+  }
+  if (state?.lastRunAt) {
+    lines.push(`Last run: ${state.lastRunAt}, status ${state.lastStatus || 'unknown'}.`);
+  }
+  return {
+    status: 'ok',
+    config,
+    scheduler,
+    state,
+    consistent,
+    summary: lines.join('\n')
+  };
+}
+
+export async function testLogworkReminder({
+  target,
+  confirm,
+  loadConfig = loadReminderConfig,
+  sendTest = sendTestReminderNotification
+} = {}) {
+  requireConfirmation(confirm, 'test');
+  const config = await loadConfig();
+  return sendTest({
+    target: target || config.target
+  });
+}
+
+function requireConfirmation(confirm, action) {
+  if (confirm !== true) {
+    throw new Error(`Reminder ${action} requires confirm: true.`);
+  }
+}

package/lib/reminder-state.mjs

@@ -0,0 +1,38 @@
+import { readFile } from 'node:fs/promises';
+import { atomicWriteFile } from './atomic-file.mjs';
+import { redactText } from './auth-redaction.mjs';
+import { reminderStatePath } from './paths.mjs';
+
+export async function loadReminderState({ path = reminderStatePath() } = {}) {
+  try {
+    const parsed = JSON.parse(await readFile(path, 'utf8'));
+    return sanitizeReminderState(parsed);
+  } catch (error) {
+    if (error.code === 'ENOENT' || error instanceof SyntaxError) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+export async function saveReminderState(state, { path = reminderStatePath() } = {}) {
+  const sanitized = sanitizeReminderState(state);
+  await atomicWriteFile(path, `${JSON.stringify(sanitized, null, 2)}\n`);
+  return sanitized;
+}
+
+export function sanitizeReminderState(state = {}) {
+  return {
+    lastRunAt: cleanText(state.lastRunAt, 80),
+    lastRunDate: cleanText(state.lastRunDate, 20),
+    lastStatus: cleanText(state.lastStatus, 80),
+    lastNotifiedDate: cleanText(state.lastNotifiedDate, 20),
+    summary: cleanText(state.summary, 1_000),
+    error: cleanText(state.error, 500)
+  };
+}
+
+function cleanText(value, maxLength) {
+  const text = redactText(String(value || '')).replace(/[\r\n]+/g, ' ').trim();
+  return text.slice(0, maxLength);
+}